diff --git a/packages/core/.gitattributes b/packages/core/.gitattributes new file mode 100644 index 00000000..f471b248 --- /dev/null +++ b/packages/core/.gitattributes @@ -0,0 +1 @@ +doc/source/conf.py export-subst diff --git a/packages/core/.github/social-preview.png b/packages/core/.github/social-preview.png new file mode 100644 index 00000000..c591787d Binary files /dev/null and b/packages/core/.github/social-preview.png differ diff --git a/packages/core/.github/workflows/build-wheels.yml b/packages/core/.github/workflows/build-wheels.yml new file mode 100644 index 00000000..237feffd --- /dev/null +++ b/packages/core/.github/workflows/build-wheels.yml @@ -0,0 +1,35 @@ +name: Build Wheels + +on: + workflow_call: + inputs: + release-tag: + description: Release tag; empty on pull requests + required: false + type: string + default: "" + +permissions: + contents: read + +jobs: + build: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1 + with: + persist-credentials: false + # hatch-vcs needs Git history and tags to derive the package version. + fetch-depth: 0 + - uses: astral-sh/setup-uv@37802adc94f370d6bfd71619e3f0bf239e1f3b78 # v7.6.0 + - uses: actions/setup-python@ece7cb06caefa5fff74198d8649806c4678c61a1 # v6.3.0 + with: + python-version-file: .python-version + - name: Build wheel and source distribution + run: uv build + - uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1 + with: + name: python-package-distributions + path: dist/ + if-no-files-found: error + retention-days: ${{ inputs.release-tag != '' && 90 || 3 }} diff --git a/packages/core/.github/workflows/ci.yml b/packages/core/.github/workflows/ci.yml new file mode 100644 index 00000000..b75a8029 --- /dev/null +++ b/packages/core/.github/workflows/ci.yml @@ -0,0 +1,87 @@ +name: CI + +on: + pull_request: + release: + types: [published] + +permissions: + contents: read + +concurrency: + group: ${{ github.workflow }}-${{ github.ref }} + cancel-in-progress: ${{ github.event_name == 'pull_request' }} + +# lint (PR only) +# build ──┬──► test ──────────┬──► publish (release only) +# └──► version-guard ─┘ +# ci-complete collects all required results. + +jobs: + lint: + if: github.event_name == 'pull_request' + uses: ./.github/workflows/lint.yml + + build: + uses: ./.github/workflows/build-wheels.yml + with: + release-tag: ${{ github.event.release.tag_name || '' }} + + test: + needs: build + uses: ./.github/workflows/test.yml + + version-guard: + name: versions + if: github.event_name == 'release' + needs: build + uses: ./.github/workflows/version-guard.yml + with: + release-tag: ${{ github.event.release.tag_name }} + + # PyPI trusted publishing must run in a top-level workflow. + publish: + if: github.event_name == 'release' + needs: [build, test, version-guard] + runs-on: ubuntu-latest + environment: + name: pypi + url: https://pypi.org/project/pyannote-core/ + permissions: + contents: write + id-token: write + steps: + - uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1 + with: + name: python-package-distributions + path: dist/ + - name: Upload distributions to GitHub Release + uses: softprops/action-gh-release@3d0d9888cb7fd7b750713d6e236d1fcb99157228 # v3.0.2 + with: + tag_name: ${{ github.event.release.tag_name }} + files: | + dist/*.whl + dist/*.tar.gz + fail_on_unmatched_files: true + - uses: astral-sh/setup-uv@37802adc94f370d6bfd71619e3f0bf239e1f3b78 # v7.6.0 + - name: Upload to PyPI + run: >- + uv publish --trusted-publishing always + --publish-url https://upload.pypi.org/legacy/ + --check-url https://pypi.org/simple/ + + ci-complete: + if: always() + needs: [lint, build, test, version-guard, publish] + runs-on: ubuntu-latest + env: + RESULTS: ${{ join(needs.*.result, ' ') }} + steps: + - name: Check results + run: | + for result in $RESULTS; do + if [[ "$result" == failure || "$result" == cancelled ]]; then + echo "::error::Required job finished with result: $result" + exit 1 + fi + done diff --git a/packages/core/.github/workflows/doc.yml b/packages/core/.github/workflows/doc.yml new file mode 100644 index 00000000..5fc070cc --- /dev/null +++ b/packages/core/.github/workflows/doc.yml @@ -0,0 +1,55 @@ +name: Documentation + +on: + pull_request: + push: + branches: [main] + +permissions: + contents: read + +concurrency: + group: ${{ github.workflow }}-${{ github.ref }} + cancel-in-progress: ${{ github.event_name == 'pull_request' }} + +jobs: + build: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1 + with: + persist-credentials: false + # hatch-vcs needs Git history and tags to derive the package version. + fetch-depth: 0 + - uses: astral-sh/setup-uv@37802adc94f370d6bfd71619e3f0bf239e1f3b78 # v7.6.0 + - uses: actions/setup-python@ece7cb06caefa5fff74198d8649806c4678c61a1 # v6.3.0 + with: + python-version-file: .python-version + - name: Install documentation dependencies + run: | + uv venv + uv pip install '.[doc]' + - name: Build documentation + run: .venv/bin/sphinx-build -b html doc/source doc/build/html + - uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1 + with: + name: documentation + path: doc/build/html + include-hidden-files: true + retention-days: 3 + + deploy: + if: github.event_name == 'push' + needs: build + runs-on: ubuntu-latest + permissions: + contents: write + steps: + - uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1 + with: + name: documentation + path: doc/build/html + - uses: peaceiris/actions-gh-pages@373f7f263a76c20808c831209c920827a82a2847 # v3 + with: + github_token: ${{ secrets.GITHUB_TOKEN }} + publish_dir: doc/build/html diff --git a/packages/core/.github/workflows/lint.yml b/packages/core/.github/workflows/lint.yml new file mode 100644 index 00000000..4219144e --- /dev/null +++ b/packages/core/.github/workflows/lint.yml @@ -0,0 +1,28 @@ +name: Lint + +on: + workflow_call: + +permissions: + contents: read + +jobs: + ruff: + name: python + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1 + with: + persist-credentials: false + # Report lint/format issues without blocking PRs. + # Remove continue-on-error once the codebase is clean. + - name: Run ruff check + uses: astral-sh/ruff-action@0ce1b0bf8b818ef400413f810f8a11cdbda0034b # v4.0.0 + continue-on-error: true + with: + args: "check ." + - name: Run ruff format + uses: astral-sh/ruff-action@0ce1b0bf8b818ef400413f810f8a11cdbda0034b # v4.0.0 + continue-on-error: true + with: + args: "format --check ." diff --git a/packages/core/.github/workflows/test.yml b/packages/core/.github/workflows/test.yml new file mode 100644 index 00000000..9a38c682 --- /dev/null +++ b/packages/core/.github/workflows/test.yml @@ -0,0 +1,36 @@ +name: Test + +on: + workflow_call: + +permissions: + contents: read + +jobs: + test: + name: Test Python ${{ matrix.python-version }} + runs-on: ubuntu-latest + strategy: + fail-fast: false + matrix: + python-version: ["3.11", "3.12", "3.13", "3.14", "3.15", "3.x"] + steps: + - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1 + with: + persist-credentials: false + - uses: astral-sh/setup-uv@37802adc94f370d6bfd71619e3f0bf239e1f3b78 # v7.6.0 + - id: python + uses: actions/setup-python@ece7cb06caefa5fff74198d8649806c4678c61a1 # v6.3.0 + with: + python-version: ${{ matrix.python-version }} + check-latest: ${{ matrix.python-version == '3.x' }} + - uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1 + with: + name: python-package-distributions + path: dist/ + - name: Install the built wheel with test dependencies + run: | + uv venv --python "${{ steps.python.outputs.python-path }}" + uv pip install "$(echo dist/*.whl)[test]" + - name: Run tests against the installed wheel + run: .venv/bin/python -m pytest tests diff --git a/packages/core/.github/workflows/version-guard.yml b/packages/core/.github/workflows/version-guard.yml new file mode 100644 index 00000000..c63aeeb3 --- /dev/null +++ b/packages/core/.github/workflows/version-guard.yml @@ -0,0 +1,70 @@ +name: Version Guard + +on: + workflow_call: + inputs: + release-tag: + description: Release tag expected to match the package version + required: true + type: string + +permissions: + contents: read + +jobs: + not-already-published: + name: pyannote-core + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1 + with: + persist-credentials: false + - uses: actions/setup-python@ece7cb06caefa5fff74198d8649806c4678c61a1 # v6.3.0 + with: + python-version-file: .python-version + - uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1 + with: + name: python-package-distributions + path: dist/ + - name: Compare distributions with PyPI + env: + RELEASE_TAG: ${{ inputs.release-tag }} + shell: python + run: | + import hashlib + import json + import os + from pathlib import Path + from urllib.error import HTTPError + from urllib.request import urlopen + from zipfile import ZipFile + from email.parser import BytesParser + + + directory = Path("dist") + tag = os.environ["RELEASE_TAG"] + wheels = list(directory.glob("*.whl")) + sources = list(directory.glob("*.tar.gz")) + if len(wheels) != 1 or len(sources) != 1: + raise ValueError("Expected exactly one wheel and one source distribution") + with ZipFile(wheels[0]) as wheel: + metadata_path, = [n for n in wheel.namelist() if n.endswith(".dist-info/METADATA")] + metadata = BytesParser().parsebytes(wheel.read(metadata_path)) + version = metadata["Version"] + if metadata["Name"] != "pyannote-core" or version != tag.removeprefix("v"): + raise ValueError(f"Release tag {tag!r} does not match pyannote-core {version}") + try: + with urlopen(f"https://pypi.org/pypi/pyannote-core/{version}/json", timeout=30) as response: + published = json.load(response)["urls"] + except HTTPError as error: + if error.code != 404: + raise + published = [] + hashes = {item["filename"]: item["digests"]["sha256"] for item in published} + for artifact in wheels + sources: + if artifact.name not in hashes: + print(f"{artifact.name}: not published yet") + elif hashlib.sha256(artifact.read_bytes()).hexdigest() == hashes[artifact.name]: + print(f"{artifact.name}: already published with identical contents") + else: + raise ValueError(f"{artifact.name} already exists with different contents. Use a new version.") diff --git a/packages/core/.gitignore b/packages/core/.gitignore new file mode 100644 index 00000000..bce3533b --- /dev/null +++ b/packages/core/.gitignore @@ -0,0 +1,64 @@ +# Byte-compiled / optimized / DLL files +__pycache__/ +*.py[cod] + +# C extensions +*.so + +# Distribution / packaging +MANIFEST +.Python +env/ +bin/ +build/ +develop-eggs/ +dist/ +eggs/ +lib/ +lib64/ +parts/ +sdist/ +var/ +*.egg-info/ +.installed.cfg +*.egg + +# Installer logs +pip-log.txt +pip-delete-this-directory.txt + +# Unit test / coverage reports +htmlcov/ +.tox/ +.coverage +.cache +nosetests.xml +coverage.xml + +# Translations +*.mo + +# Mr Developer +.mr.developer.cfg +.project +.pydevproject + +# Rope +.ropeproject + +# Django stuff: +*.log +*.pot + +# Sphinx documentation +docs/_build/ + +doc/.ipynb_checkpoints + +# emacs temporary files +*~ + +# PyCharm +.idea/ + +.mypy_cache/ \ No newline at end of file diff --git a/packages/core/.python-version b/packages/core/.python-version new file mode 100644 index 00000000..2c073331 --- /dev/null +++ b/packages/core/.python-version @@ -0,0 +1 @@ +3.11 diff --git a/packages/core/CHANGELOG.md b/packages/core/CHANGELOG.md new file mode 100644 index 00000000..c42a8ab1 --- /dev/null +++ b/packages/core/CHANGELOG.md @@ -0,0 +1,412 @@ +# CHANGELOG + +## Version 6.1.0 (2026-10-15) + +- BREAKING: require Python 3.11 or newer; Python 3.10 is no longer supported +- BREAKING: `from pyannote.core import *` now exports only public classes, constants, + and `notebook` when available; incidental module imports are no longer exported +- fix(cluster): restore pooling clustering with NumPy 2 +- fix(cluster): place the larger cluster first in linkage rows, including + must-link merges; cluster membership and merge distances are unchanged + +## Version 6.0.1 (2025-09-16) + +- feat: add `Annotation.__iter__` (turn: Segment, speaker: str) iterator + +## Version 6.0.0 (2025-09-09) + +- BREAKING: drop support to `Python` < 3.10 +- BREAKING: switch to native namespace package +- setup: switch to `uv` + +## Version 5.0.1 (2024-06-14) + +- fix: fix return type of Timeline.__iter__ (@domsmrz) +- improve: remove MatplotlibDeprecationWarning (@kimdwkimdw) + +## Version 5.0.0 (2022-12-15) + +- BREAKING: remove support for JSON serialization + +## Version 4.5 (2022-08-24) + +- feat: add Annotation.write_lab method (@FrancescoBonzi) +- feat: add Annotation.to_{rttm|lab} and Timeline.to_uem serializers (@juanmc2005) +- setup: exclude tests from package (@kimdwkimdw) + +## Version 4.4 (2022-03-09) + +- BREAKING: remove empty segments in Timeline.__init__ +- BREAKING: Timeline.extent() returns Segment(0.0, 0.0) for empty timelines +- feat: add "duration" option to Annotation.discretize +- fix: handle various corner cases in 1D pdist and cdist +- fix: fix documentation of {Timeline | Annotation}.__bool__ +- test: check robustness to Segment.set_precision + +## Version 4.3 (2021-10-11) + +- feat: add support for visualizing 3D SlidingWindowFeatures (#66) +- feat: add Annotation.discretize (#65) + +## Version 4.2.1 (2021-09-27) + +- fix: fix automatic deployment of documentation + +## Version 4.2 (2021-09-24) + +- feat: add Segment.set_precision to automatically round start/end timestamps (@kimdwkimdw) +- feat: add methods {Timeline|Annotation}.{extrude|get_overlap} (@hadware) +- feat: add support for `Segment` in `one_hot_encoding` +- feat: make notebook visualization support an optional installation via the [notebook] extra_requires (@hadware) +- setup: add [doc] and [testing] extra_requires (@hadware) +- fix: several type annotation fixes (@kimdwkimdw, @PaulLerner) + +## Version 4.1 (2020-05-27) + +- feat: add "must_link_method" option to "pool" clustering + +## Version 4.0 (2020-05-15) + +- feat: add support for cannot/must link constraints in "pool" clustering +- BREAKING: make one_hot_encoding return SlidingWindowFeature with labels +- feat: add "labels" optional attribute to SlidingWindowFeature + +## Version 3.7.1 (2020-03-23) + +- fix: fix corner case in pyannote.core.utils.numpy.one_hot_encoding + +## Version 3.7 (2020-03-21) + +- feat: add new method SlidingWindowFeature.align + +## Version 3.6 (2020-03-03) + +- feat: add collar argument to Timeline.support (@nryant) +- feat: add new method Timeline.covers (@PaulLerner) +- fix: check for spaces before writing with RTTM or UEM format (@PaulLerner) +- improve: speed up Annotation.{from_df | from_json} (@nryant) + +## Version 3.5 (2020-01-23) + +- feat: add align_last option to SlidingWindow.__call__ + +## Version 3.4 (2020-01-21) + +- feat: add SlidingWindow.__call__ to slide over a specific support +- feat: add pyannote.core.utils.random + +## Version 3.3 (2020-01-08) + +- BREAKING: remove pyannote.core.Scores +- fix: fix legend corner case with empty Annotation instances +- fix: fix {Timeline|Annotation}.crop with overlapping segments in support + +## Version 3.2.2 (2020-01-06) + +- fix: fix Segment.__bool__ return type + +## Version 3.2 (2019-12-13) + +- feat: add type hints (@hadware) +- chore: Python3-ize code base (@hadware) + +## Version 3.1.10 (2019-12-12) + +- feat: add Annotation.write_rttm and Timeline.write_uem (@PaulLerner) +- feat: add numpy interface to SlidingWindowFeature (experimental) +- feat: setup continuous integration +- improve: speed up SlidingWindowFeature plotting +- doc: update notebooks to Python 3 (@PaulLerner) +- BREAKING: remove deprecated Segment.pretty() + +## Version 3.0 (2019-06-24) + +- BREAKING: `Annotation.__mul__` now returns `np.ndarray` instance +- BREAKING: remove `Annotation` methods (that were deprecated version 1.0) +- BREAKING: `Scores.retrack` has been renamed `rename_tracks` +- improve: remove `six` and `xarray` dependencies +- BREAKING: remove `pyannote.core.time` module + +## Version 2.2.2 (2019-04-18) + +- improve: speed-up several `Segment` methods +- improve: decrease `one_hot_encoding` memory usage +- feat: add support for "fixed" option in all cropping modes +- setup: switch to scipy 1.1 + +## Version 2.1 (2019-01-17) + +- feat: add basic implementation of Chinese Whispers clustering +- feat: add "utils.hierarchy.fcluster_auto" parameter-free "fcluster" + +## Version 2.0.3 (2018-11-23) + +- BREAKING: move pyannote.core.util to pyannote.core.utils.generators +- BREAKING: remove support for Python 2 +- feat: add one_hot_{encoding | decoding} functions +- feat: add get_class_by_name utiltiy function +- feat: add custom pdist and cdist +- feat: add custom hierachical clustering "linkage" function +- setup: add scipy dependency + +## Version 1.4.1 (2018-09-13) + +- feat: add unit tests for feature cropping +- fix: fix out-of-bounds feature cropping + +## Version 1.4 (2018-07-09) + +- feat: expose `SlidingWindow.closest_frame` + +## Version 1.3.2 (2018-06-12) + +- feat: add support for multi-dimensional SlidingWindowFeatures +- setup: switch to sortedcontainers 2.x +- fix: update SWF.crop docstring +- chore: remove support for "segment" option in Annotation.argmax + +## Version 1.3.1 (2017-12-14) + +- feat: add "return_ranges" option to SlidingWindow.crop +- improve: faster SlidingWindowFeature.crop +- fix: fix documentation + +## Version 1.2 (2017-10-05) + +- BREAKING: remove all things "Transcription" +- feat: add return_data parameter to SlidingWindowFeature.crop (SWF) +- feat: add support for len(SWF) +- feat: add ylim parameter to plot_feature +- fix: fix corner case where notebook.crop is larger than SWF extent + +## Version 1.1 (2017-09-19) + +- feat: make iterators out of SlidingWindowFeature instances +- improve: make Annotation.__mul__ (much) faster + +## Version 1.0.5 (2017-09-13) + +- fix: make iterators out of SlidingWindow instances + +## Version 1.0.4 (2017-07-18) + +- fix: add missing import +- fix: fix corner case in Timeline.crop_iter + +## Version 1.0.2 (2017-07-15) + +- fix: use Timeline.support() instead of .coverage() + +## Version 1.0.1 (2017-07-04) + +- improve: switch from banyan to sortedcontainers +- feat: add Timeline.{remove|discard|overlapping_iter} methods +- BREAKING: Timeline.__init__ now raises ValueError in case of empty segment +- BREAKING: Timeline.crop now raises ValueError for bad mode +- BREAKING: rename "mapping" arguments to "returns_mapping" in Timeline.crop +- test: add more tests + +## Version 0.13.3 (2017-06-29) + +- fix: fix SlidingWindowFeature.iterfeatures() + +## Version 0.13.2 (2017-03-29) + +- setup: add dependencies for notebook visualization + +## Version 0.13.1 (2017-02-20) + +- fix: fix Annotation.rename_labels + +## Version 0.13 (2017-02-05) + +- improve: faster Annotation.subset and Annotation.rename_labels + +## Version 0.12.1 (2017-30-01) + +- fix: fix Annotation.uri setter + +## Version 0.12 (2017-29-01) + +- feat: add Timeline.to_annotation() + +## Version 0.11.1 (2017-25-01) + +- fix: fix (deprecated) "smooth" method + +## Version 0.11 (2017-24-01) + +- feat: add (Sphinx-based) documentation +- chore: move sample notebooks to /notebook +- feat: add unit tests +- BREAKING: rename some Timeline and Annotation methods + +## Version 0.10 (2017-18-01) + +- feat: add 'copy' parameter to Annotation.{label|get}_timeline() +- improve: speed-up Timeline.extent() +- chore: move tests at root directory +- chore: remove support for Unknown labels + +## Version 0.9 (2017-01-17) + +- improve: speed up Timeline and Annotation + +## Version 0.8 (2016-11-05) + +- feat: add "copy" option to Annotation.update + +## Version 0.7.3 (2016-11-01) + +- feat: SlidingWindowFeature notebook display + +## Version 0.7.2 (2016-07-12) + +- feat: new SlidingWindow.{samples|crop} methods +- feat: new 'mode' parameter to SlidingWindowFeature.crop method +- doc: updated notebooks for SlidingWindow and SlidingWindowFeature + +## Version 0.6.6 (2016-06-23) + +- fix: force internal timeline update after copy + +## Version 0.6.5 (2016-06-13) + +- BREAKING: make segmentToRange deterministic wrt. segment duration + +## Version 0.6.4 (2016-06-06) + +- fix: Python 3 support in pyannote.core.features + +## Version 0.6.3 (2016-03-29) + +- setup: versioneer 0.15 + +## Version 0.6.1 (2016-03-20) + +- fix: prevent adding empty segments in Annotation and Scores + +## Version 0.6 (2016-02-25) + +- BREAKING: pyannote.core.json.{load|dump} expects file handles +- feat: load_from, dump_to + +## Version 0.5.2 (2016-02-19) + +- feat: Annotation * Annotation returns cooccurrence matrix +- fix: Annotation.itertracks would raise a UnicodeDecodeError in some + cases + +## Version 0.5.1 (2016-02-17) + +- improve: notebook display +- improve: Annotation.anonymize_{tracks|labels} no longer use Unknown + instances +- improve: empty segments are now printed as "[]" + +## Version 0.4.7 (2016-02-04) + +- feat: deterministic order in Annotation.co_iter +- fix: LabelMatrix.argmax corner case +- setup: update dependencies + +## Version 0.4.4 (2015-11-02) + +- feat: Travis continuous integration + +## Version 0.4.3 (2015-10-28) + +- fix: Python 2/3 notebook representations +- fix: bug in Scores with integer-values segments + +## Version 0.4.1 (2015-10-27) + +- fix: update Scores.from_df to pandas 0.17 + +## Version 0.4 (2015-10-26) + +- feat: Python 3 support +- feat: pytest test suite +- fix: Annotation comparison +- fix: deterministic order in Annotation.itertracks + +## Version 0.3.6 (2015-05-06) + +- feat: LabelMatrix save/load methods + +## Version 0.3.4 (2015-03-04) + +- fix: MAJOR bug in Annotation lazy-update + +## Version 0.3.3 (2015-02-27) + +- fix: Scores IPython display + +## Version 0.3.1 (2015-01-26) + +- feat: new Annotation.update method +- improve: Annotation.subset support for any label iterable + +## Version 0.3 (2014-12-04) + +- refactor: rewrote Scores internals +- setup: use pandas 0.15.1+ + +## Version 0.2.5 (2014-11-21) + +- setup: use pyannote-banyan 0.1.6 + +## Version 0.2.4 (2014-11-18) + +- fix: extent of empty Timeline + +## Version 0.2.3 (2014-11-14) + +- fix: force revert to pandas 0.13.1 for Scores to work again... + +## Version 0.2.2 (2014-11-12) + +- setup: use banyan 0.1.5.1 from GitHub + +## Version 0.2.1 (2014-10-30) + +- feat: pyannote/core Docker image +- feat(Timeline): add from_df constructor + +## Version 0.2 (2014-10-24) + +- breaking change: new PyAnnote JSON format + +## Version 0.1 (2014-08-05) + +- fix(Transcription): fix potential edge/key conflict during alignment + +## Version 0.0.5 (2014-07-23) + +- feat(SlidingWindow): add durationToSamples (and vice-versa) +- fix(Transcription): fix loading from JSON +- fix(Transcription): fix cropping corner cases +- docs: add installation instruction for IPython display support +- docs(Scores): add IPython documentation for Scores + +## Version 0.0.3 (2014-06-02) + +- feat(Annotation): add 'collar' param to .smooth() +- refactor(Annotation): remove support for >> operator +- maintain(Mapping): remove label mapping data structure +- feat(LabelMatrix): add IPython display +- improve(LabelMatrix): 10x faster cooccurrence matrix +- feat(Scores): add IPython display +- feat(Transcription): add edge timerange prediction +- feat(Transcription): add node temporal sort +- fix(Transcription): make label_timeline return a copy +- fix(Transcription): fix IPython display +- docs(Transcription): add IPython documentation for Transcription + +## Version 0.0.2 (2014-05-06) + +- feat: Transcription data structure (annotation graph) + +## Version 0.0.1 (2014-05-02) + +- first public version diff --git a/packages/core/LICENSE b/packages/core/LICENSE new file mode 100644 index 00000000..69526b96 --- /dev/null +++ b/packages/core/LICENSE @@ -0,0 +1,24 @@ +The MIT License (MIT) + +Copyright (c) 2014 CNRS + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. + +AUTHORS +Hervé BREDIN - http://herve.niderb.fr \ No newline at end of file diff --git a/packages/core/README.md b/packages/core/README.md new file mode 100644 index 00000000..51b89bc0 --- /dev/null +++ b/packages/core/README.md @@ -0,0 +1,37 @@ +![pyannote.core](https://raw.githubusercontent.com/pyannote/pyannote-core/main/.github/social-preview.png) + +> advanced data structures for handling and visualizing temporal segments with attached labels. + +## Installation + +```bash +$ pip install pyannote.core +``` + +Support for graphical visualization in Jupyter notebooks can be added with: + +```bash +$ pip install pyannote.core[notebook] +``` + +## Documentation + +The documentation is available at [http://pyannote.github.io/pyannote-core](http://pyannote.github.io/pyannote-core). + +Sample notebooks are available [here](https://nbviewer.jupyter.org/github/pyannote/pyannote-core/blob/develop/notebook/index.ipynb). + +## Citation + +If you use `pyannote.core` in your research, please use the following citation: + +```bibtex +@inproceedings{pyannote.metrics, + author = {Herv\'e Bredin}, + title = {{pyannote.metrics: a toolkit for reproducible evaluation, diagnostic, and error analysis of speaker diarization systems}}, + booktitle = {{Interspeech 2017, 18th Annual Conference of the International Speech Communication Association}}, + year = {2017}, + month = {August}, + address = {Stockholm, Sweden}, + url = {http://pyannote.github.io/pyannote-metrics}, +} +``` diff --git a/packages/core/doc/Makefile b/packages/core/doc/Makefile new file mode 100644 index 00000000..1f01f19f --- /dev/null +++ b/packages/core/doc/Makefile @@ -0,0 +1,20 @@ +# Minimal makefile for Sphinx documentation +# + +# You can set these variables from the command line. +SPHINXOPTS = +SPHINXBUILD = sphinx-build +SPHINXPROJ = pyannotecore +SOURCEDIR = source +BUILDDIR = build + +# Put it first so that "make" without argument is like "make help". +help: + uv run --extra doc $(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 + uv run --extra doc $(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O) \ No newline at end of file diff --git a/packages/core/doc/source/conf.py b/packages/core/doc/source/conf.py new file mode 100644 index 00000000..b2ef02e9 --- /dev/null +++ b/packages/core/doc/source/conf.py @@ -0,0 +1,201 @@ +# +# pyannote.core documentation build configuration file, created by +# sphinx-quickstart on Tue Jan 24 15:45:55 2017. +# +# This file is execfile()d with the current directory set to its +# containing dir. +# +# Note that not all possible configuration values are present in this +# autogenerated file. +# +# All configuration values have a default; values that are commented out +# serve to show the default. + +# 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. +# + +# allow pyannote.core import +import os +import sys + +sys.path.insert(0, os.path.abspath("../..")) + + +# -- General configuration ------------------------------------------------ + +# If your documentation needs a minimal Sphinx version, state it here. +# +# needs_sphinx = '1.0' + +# Add any Sphinx extension module names here, as strings. They can be +# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom +# ones. +extensions = [ + "sphinx.ext.autodoc", + "sphinx.ext.napoleon", + "sphinx.ext.intersphinx", + "sphinx.ext.todo", + "sphinx.ext.coverage", + "sphinx.ext.mathjax", + "sphinx.ext.viewcode", + "sphinx.ext.githubpages", + "matplotlib.sphinxext.plot_directive", + "IPython.sphinxext.ipython_directive", +] + + +# Napoleon settings +napoleon_google_docstring = True +napoleon_numpy_docstring = True +napoleon_include_init_with_doc = False +napoleon_include_private_with_doc = False +napoleon_include_special_with_doc = False +napoleon_use_admonition_for_examples = False +napoleon_use_admonition_for_notes = False +napoleon_use_admonition_for_references = False +napoleon_use_ivar = False +napoleon_use_param = True +napoleon_use_rtype = True +napoleon_use_keyword = True + +# Add any paths that contain templates here, relative to this directory. +templates_path = ["_templates"] + +# The suffix(es) of source filenames. +# You can specify multiple suffix as a list of string: +# +# source_suffix = ['.rst', '.md'] +source_suffix = {".rst": "restructuredtext"} + +# The master toctree document. +master_doc = "index" + +# General information about the project. +project = "pyannote.core" +copyright = "2017, CNRS" +author = "Hervé Bredin" + +# The version info for the project you're documenting, acts as replacement for +# |version| and |release|, also used in various other places throughout the +# built documents. + +import pyannote.core + +# The short X.Y version. +version = pyannote.core.__version__.split("+")[0] +# The full version, including alpha/beta/rc tags. +release = pyannote.core.__version__ + +# The language for content autogenerated by Sphinx. Refer to documentation +# for a list of supported languages. +# +# This is also used if you do content translation via gettext catalogs. +# Usually you set "language" from the command line for these cases. +language = "en" + +# List of patterns, relative to source directory, that match files and +# directories to ignore when looking for source files. +# This patterns also effect to html_static_path and html_extra_path +exclude_patterns = [] + +# The name of the Pygments (syntax highlighting) style to use. +pygments_style = "sphinx" + +# If true, `todo` and `todoList` produce output, else they produce nothing. +todo_include_todos = True + + +# -- Options for HTML output ---------------------------------------------- + +# The theme to use for HTML and HTML Help pages. See the documentation for +# a list of builtin themes. +# +html_theme = "sphinx_rtd_theme" + +# Theme options are theme-specific and customize the look and feel of a theme +# further. For a list of options available for each theme, see the +# documentation. +# +# html_theme_options = {} + +# Add any paths that contain custom static files (such as style sheets) here, +# relative to this directory. They are copied after the builtin static files, +# so a file named "default.css" will overwrite the builtin "default.css". +html_static_path = ["_static"] + + +# -- Options for HTMLHelp output ------------------------------------------ + +# Output file base name for HTML help builder. +htmlhelp_basename = "pyannotecoredoc" + + +# -- Options for LaTeX output --------------------------------------------- + +latex_elements = { + # The paper size ('letterpaper' or 'a4paper'). + # + # 'papersize': 'letterpaper', + # The font size ('10pt', '11pt' or '12pt'). + # + # 'pointsize': '10pt', + # Additional stuff for the LaTeX preamble. + # + # 'preamble': '', + # Latex figure (float) alignment + # + # 'figure_align': 'htbp', +} + +# Grouping the document tree into LaTeX files. List of tuples +# (source start file, target name, title, +# author, documentclass [howto, manual, or own class]). +latex_documents = [ + ( + master_doc, + "pyannotecore.tex", + "pyannote.core Documentation", + "Hervé Bredin", + "manual", + ), +] + + +# -- Options for manual page output --------------------------------------- + +# One entry per manual page. List of tuples +# (source start file, name, description, authors, manual section). +man_pages = [(master_doc, "pyannotecore", "pyannote.core Documentation", [author], 1)] + + +# -- Options for Texinfo output ------------------------------------------- + +# Grouping the document tree into Texinfo files. List of tuples +# (source start file, target name, title, author, +# dir menu entry, description, category) +texinfo_documents = [ + ( + master_doc, + "pyannotecore", + "pyannote.core Documentation", + author, + "pyannotecore", + "One line description of project.", + "Miscellaneous", + ), +] + +# Example configuration for intersphinx: refer to the Python standard library. + + +plot_pre_code = """import matplotlib.pyplot as plt +from pyannote.core import notebook +from pyannote.core import Segment +from pyannote.core import Timeline +from pyannote.core import Annotation +from pyannote.core import SlidingWindow +from pyannote.core import SlidingWindowFeature""" + +ipython_savefig_dir = "../../build/html/_static" diff --git a/packages/core/doc/source/index.rst b/packages/core/doc/source/index.rst new file mode 100644 index 00000000..2a89dea5 --- /dev/null +++ b/packages/core/doc/source/index.rst @@ -0,0 +1,54 @@ +.. pyannote.core documentation master file, created by + sphinx-quickstart on Thu Jan 19 13:25:34 2017. + You can adapt this file completely to your liking, but it should at least + contain the root `toctree` directive. + +############# +pyannote.core +############# + +`pyannote.core` is an open-source Python library providing advanced data structures for handling temporal segments with attached labels. + +.. plot:: pyplots/introduction.py + +It is the foundation of the `pyannote` ecosystem, made of a (growing) number of libraries ( `pyannote.parser`, `pyannote.metrics`, `pyannote.database`, `pyannote.audio`, `pyannote.video`). + +It also provides a convenient way to visualize this temporal data in IPython notebooks. + + +Installation +============ + +:: + +$ conda create -n pyannote python=3.5 anaconda +$ source activate pyannote +$ pip install pyannote.core + + + +User guide +========== + +.. toctree:: + :maxdepth: 2 + + structure + visualization + + +API documentation +================= + +.. toctree:: + :maxdepth: 2 + + reference + Changelog + +Indices and tables +================== + +* :ref:`genindex` +* :ref:`modindex` +* :ref:`search` diff --git a/packages/core/doc/source/pyplots/annotation.py b/packages/core/doc/source/pyplots/annotation.py new file mode 100644 index 00000000..43de1bf4 --- /dev/null +++ b/packages/core/doc/source/pyplots/annotation.py @@ -0,0 +1,19 @@ +import matplotlib.pyplot as plt + +from pyannote.core import Annotation, Segment, notebook + +notebook.width = 10 +plt.rcParams["figure.figsize"] = (notebook.width, 2) + +# only display [0, 20] timerange +notebook.crop = Segment(0, 20) + +# plot annotation +annotation = Annotation() +annotation[Segment(1, 5)] = "Carol" +annotation[Segment(6, 8)] = "Bob" +annotation[Segment(12, 18)] = "Carol" +annotation[Segment(7, 20)] = "Alice" +notebook.plot_annotation(annotation, legend=True, time=True) + +plt.show() diff --git a/packages/core/doc/source/pyplots/introduction.py b/packages/core/doc/source/pyplots/introduction.py new file mode 100644 index 00000000..d6038750 --- /dev/null +++ b/packages/core/doc/source/pyplots/introduction.py @@ -0,0 +1,29 @@ +import matplotlib.pyplot as plt + +from pyannote.core import Annotation, Segment, Timeline, notebook + +notebook.width = 10 +plt.rcParams["figure.figsize"] = (notebook.width, 3) + +# only display [0, 20] timerange +notebook.crop = Segment(0, 20) + +# plot annotation +plt.subplot(211) +annotation = Annotation() +annotation[Segment(1, 5)] = "Carol" +annotation[Segment(6, 8)] = "Bob" +annotation[Segment(12, 18)] = "Carol" +annotation[Segment(7, 20)] = "Alice" +notebook.plot_annotation(annotation, legend=True, time=False) + +# plot timeline +plt.subplot(212) +timeline = Timeline() +timeline.add(Segment(1, 5)) +timeline.add(Segment(6, 8)) +timeline.add(Segment(12, 18)) +timeline.add(Segment(7, 20)) +notebook.plot_timeline(timeline, time=True) + +plt.show() diff --git a/packages/core/doc/source/pyplots/segment.py b/packages/core/doc/source/pyplots/segment.py new file mode 100644 index 00000000..11670f77 --- /dev/null +++ b/packages/core/doc/source/pyplots/segment.py @@ -0,0 +1,15 @@ +import matplotlib.pyplot as plt + +from pyannote.core import Segment, notebook + +notebook.width = 10 +plt.rcParams["figure.figsize"] = (notebook.width, 2) + +# only display [0, 20] timerange +notebook.crop = Segment(0, 20) + +# plot segment +segment = Segment(5, 15) +notebook.plot_segment(segment, time=True) + +plt.show() diff --git a/packages/core/doc/source/pyplots/timeline.py b/packages/core/doc/source/pyplots/timeline.py new file mode 100644 index 00000000..001bb63c --- /dev/null +++ b/packages/core/doc/source/pyplots/timeline.py @@ -0,0 +1,19 @@ +import matplotlib.pyplot as plt + +from pyannote.core import Segment, Timeline, notebook + +notebook.width = 10 +plt.rcParams["figure.figsize"] = (notebook.width, 2) + +# only display [0, 20] timerange +notebook.crop = Segment(0, 20) + +# plot timeline +timeline = Timeline() +timeline.add(Segment(1, 5)) +timeline.add(Segment(6, 8)) +timeline.add(Segment(12, 18)) +timeline.add(Segment(7, 20)) +notebook.plot_timeline(timeline, time=True) + +plt.show() diff --git a/packages/core/doc/source/reference.rst b/packages/core/doc/source/reference.rst new file mode 100644 index 00000000..0c9967df --- /dev/null +++ b/packages/core/doc/source/reference.rst @@ -0,0 +1,60 @@ +######### +Reference +######### + +*************** +Data structures +*************** + +.. toctree:: + :maxdepth: 2 + +Segment +======= + +.. autoclass:: pyannote.core.Segment + :members: + :special-members: + +Timeline +======== + +.. autoclass:: pyannote.core.Timeline + :members: + :special-members: + +Annotation +========== + +.. autoclass:: pyannote.core.Annotation + :members: + :special-members: + +.. Scores +.. ====== +.. +.. .. autoclass:: pyannote.core.Scores +.. :members: +.. :special-members: + +SlidingWindow +============= + +.. autoclass:: pyannote.core.SlidingWindow + :members: + :special-members: + +SlidingWindowFeature +==================== + +.. autoclass:: pyannote.core.SlidingWindowFeature + :members: + :special-members: + +************* +Visualization +************* + +.. automodule:: pyannote.core.notebook + :members: + :no-index: diff --git a/packages/core/doc/source/structure.rst b/packages/core/doc/source/structure.rst new file mode 100644 index 00000000..29002cb2 --- /dev/null +++ b/packages/core/doc/source/structure.rst @@ -0,0 +1,12 @@ + +######################### +Available data structures +######################### + +.. automodule:: pyannote.core.segment + +.. automodule:: pyannote.core.timeline + +.. automodule:: pyannote.core.annotation + +.. automodule:: pyannote.core.feature diff --git a/packages/core/doc/source/visualization.rst b/packages/core/doc/source/visualization.rst new file mode 100644 index 00000000..41d96dfc --- /dev/null +++ b/packages/core/doc/source/visualization.rst @@ -0,0 +1 @@ +.. automodule:: pyannote.core.notebook diff --git a/packages/core/notebook/index.ipynb b/packages/core/notebook/index.ipynb new file mode 100644 index 00000000..0d432069 --- /dev/null +++ b/packages/core/notebook/index.ipynb @@ -0,0 +1,310 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Populating the interactive namespace from numpy and matplotlib\n" + ] + } + ], + "source": [ + "%pylab inline\n", + "import random\n", + "\n", + "random.seed(1337)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Documentation for `pyannote.core`" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Install" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "`pyannote.core` package can be installed the easy way:\n", + "```bash\n", + "$ pip install pyannote.core\n", + "```\n", + "\n", + "Adding support for Jupyter/IPython Notebook graphical representations is as easy as:\n", + "```bash\n", + "$ pip install pyannote.core[notebook]\n", + "```" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Available data structures" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "from pyannote.core import *" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Segment ([pyannote.core.segment](pyannote.core.segment.ipynb))" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABHQAAABnCAYAAABhARWQAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", + "text/plain": [ + "" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "segment = Segment(start=0, end=10)\n", + "segment" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Timeline ([pyannote.core.timeline](pyannote.core.timeline.ipynb))" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABHQAAABnCAYAAABhARWQAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nMBiFDgAAAMBg/gtDeo9owLlLVgAAAABJRU5ErkJggg==\n", + "text/plain": [ + ", , , ])>" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "timeline = Timeline([Segment(1, 5), Segment(6, 8), Segment(12, 18), Segment(7, 20)])\n", + "timeline" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Annotation ([pyannote.core.annotation](pyannote.core.annotation.ipynb))" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABHQAAACsCAYAAAAaLvvnAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nfwHFsX66kKOOPQAAAABJRU5ErkJggg==\n", + "text/plain": [ + "" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "annotation = Annotation()\n", + "annotation[Segment(1, 5)] = \"John\"\n", + "annotation[Segment(6, 8)] = \"Jack\"\n", + "annotation[Segment(12, 18)] = \"John\"\n", + "annotation[Segment(7, 20)] = \"Alice\"\n", + "annotation" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Feature ([pyannote.core.feature](pyannote.core.feature.ipynb))" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "# one 4-dimensional feature vector extracted every 100ms from a 200ms window\n", + "frame = SlidingWindow(start=0.0, step=0.100, duration=0.200)\n", + "data = np.random.randn(100, 4)\n", + "features = SlidingWindowFeature(data, frame)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABHQAAACdCAYAAADVCC/vAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", + "text/plain": [ + "" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "features" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 0.4421429 , -1.44502143, -0.43282043, -0.01994535],\n", + " [ 0.95060543, -0.74292602, 1.22086979, 1.95070816],\n", + " [ 1.19066555, 1.29371768, 0.11550674, -3.74567368],\n", + " [ 1.17795762, -0.39977873, -1.27290048, 1.13461351],\n", + " [-0.86933379, -0.69830552, -0.37775889, -0.32930616],\n", + " [-0.20408787, -0.24439993, -0.07213635, -1.17373151],\n", + " [-0.25488363, 0.13070289, 0.56219605, 0.36592598],\n", + " [ 0.82328558, 0.80167407, -1.61040618, -0.18284535],\n", + " [ 1.02423512, 0.78117785, -0.57796508, -0.24171816],\n", + " [ 0.41506776, -1.05395226, -1.32510005, 0.0041201 ],\n", + " [ 0.39898321, -0.4456852 , 0.50380856, -0.64459603],\n", + " [ 1.08797586, 0.48974714, 0.50622516, -0.05644439],\n", + " [-0.30759844, 0.05496161, -0.79779151, -1.32959826]])" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "features.crop(Segment(2, 3))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Scores ([pyannote.core.scores](pyannote.core.scores.ipynb))" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABIcAAACsCAYAAADhVcx9AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", + "text/plain": [ + "" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "scores = Scores()\n", + "scores[Segment(3, 5), \"_\", \"Penny\"] = 0.8\n", + "scores[Segment(3, 5), \"_\", \"Leonard\"] = 0.15\n", + "scores[Segment(3, 5), \"_\", \"Sheldon\"] = 0.05\n", + "scores[Segment(5.5, 7), \"_\", \"Penny\"] = 0.4\n", + "scores[Segment(5.5, 7), \"_\", \"Leonard\"] = 0.5\n", + "scores[Segment(5.5, 7), \"_\", \"Sheldon\"] = 0.1\n", + "scores[Segment(8, 10), \"_\", \"Penny\"] = 0.4\n", + "scores[Segment(8, 10), \"_\", \"Leonard\"] = 0.25\n", + "scores[Segment(8, 10), \"_\", \"Sheldon\"] = 0.35\n", + "scores" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Contribute" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "`pyannote.core` is on [Github](https://github.com/pyannote/pyannote-core). \n", + " \n", + " \n", + " Fork and pull requests are very welcome!" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.5.3" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/packages/core/notebook/pyannote.core.annotation.ipynb b/packages/core/notebook/pyannote.core.annotation.ipynb new file mode 100644 index 00000000..82d4fd39 --- /dev/null +++ b/packages/core/notebook/pyannote.core.annotation.ipynb @@ -0,0 +1,1327 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Populating the interactive namespace from numpy and matplotlib\n" + ] + } + ], + "source": [ + "%pylab inline" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Annotation (`pyannote.core.annotation.Annotation`)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, + "outputs": [], + "source": [ + "from pyannote.core import Annotation" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "**`Annotation`** instances are used to describe sets of annotated temporal fragments. \n", + "For instance, one can use an **`Annotation`** to store the result of speaker identification approach applied on an episode of *The Big Bang Theory* TV series." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, + "outputs": [], + "source": [ + "annotation = Annotation(uri=\"TheBigBangTheory.Season01.Episode01\", modality=\"speaker\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "For instance, to represent a dialogue between Penny and Leonard, we could do the following:" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from pyannote.core import Segment\n", + "\n", + "annotation[Segment(3, 5)] = \"Penny\"\n", + "annotation[Segment(5.5, 7)] = \"Leonard\"\n", + "annotation[Segment(8, 10)] = \"Penny\"\n", + "annotation" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now, suppose (super-annoying) Sheldon speaks over Penny's second speech turn." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "annotation[Segment(8, 10)] = \"Sheldon\"\n", + "annotation" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Damn, Sheldon! That's not what we wanted! We did not want to replace Penny by Sheldon. Instead, we wanted to show that both characters are speaking at the very same time. \n", + "To achieve this, we need to create a new track for the same segment." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "segment = Segment(8, 10)\n", + "annotation[segment, annotation.new_track(segment)] = \"Penny\"\n", + "annotation" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "That's much better!\n", + "A track cannot be identified by a segment alone: it is uniquely identified by a 2-tuple (segment, track_identifier)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In fact, the **new_track** method is simply an helper function to help you generate new track identifiers for a given segment.\n", + "And the previous lines are in fact shortcuts for the following:" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABHQAAACsCAYAAAAaLvvnAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAQT0lEQVR4nO3de6xlVX0H8O8Pp42Ab0G0iJ1GLdiagkARn0XFV7WItWmt2ljbaE2MaE3T2NqEIU0Tm/qssaYKVo2vqigaSXQaLWrTIM4AAoK09QmoIK0vRFGHX/84e+SKwMydmTt71j2fT3Jzz1lnr31/e991753znbX2ru4OAAAAAOPYb+4CAAAAAFgdgQ4AAADAYAQ6AAAAAIMR6AAAAAAMRqADAAAAMBiBDgAAAMBgBDoAAAAAgxHoAAAAAAxGoAMAAAAwGIEOAAAAwGCGC3Sq6rq5a7i5qjqhqj48dx17QlVtq6oLq+qSqnpvVR0wd00jqaqXVdXnquqi6Tw+uKq+XFUHrWIftzqeVrsvAAAA1qfhAp19QVXdbu4a1tAPuvuo7n5gkh8lef7cBY2iqh6S5MlJju7u30hyYpIr5q0KAACA9WhdBDpVdXBVnVlVn5k+Hja1362qzppmS5xbVb8xtW+qqjdX1TlV9cWqOmXFvs6qqq3TLIvnrWi/rqpeWVWfTfKQqnpCVX2+qs5P8rt7+5j3kk8luV+SVNWzquq8adbJP28Ptabz8ndV9dnpHB8ytb+lqv6xqv5zOse/N7W/rapO3v4FquodVfWUGY5tLdwrybXdfUOSdPe13f216bUXVtX5VXVxVR2RJFV14DQOz6uqC27pPFTV3atq8zQeT09SK157yTST6pKqevHUtrGqLquqN019NlfV/mt+5AAAAOxV6yLQSfLaJK/u7t9M8rQkp0/tpyW5YJot8ddJ3raizxFJHp/kuCSnVtUvTO1/0t3HJDk2ySlVdfep/cAkn+7uI5NsSfKmJL+T5Jgk91yzI5tJVW1I8sQkF1fVA5L8QZKHdfdRSbYleea06YFJzp3OyyeTPHfFbu6V5OFZzFp5+dR2RpI/nr7GnZM8NMnZa3owe8/mJIdV1X9V1T9V1W+teO3a7j46yRuS/MXU9rIkH+/u45I8Ksk/VNWBN9vnqUn+o7t/PckHktwnSarqmCTPSfLgJMcneW5VPWjqc/8kr5/6fDuLnwkAAADWkQ270/n4Uz+6KYs3nHvKaeee9vhNu9DvxCS/VvXTyQt3qqo7ZBEmPC1Juvvj02yHO03bnD3NpLihqq5JckiSK7MIcZ46bXNYFm+O/zeLEOPMqf2IJF/q7v9Okqp6e5KfzubZU6469LBN2cPn99Crrti0g232r6oLp8efyiKAeV4WwdVnpnO8f5Jrpm1+lGT79V62Jnnsin2d1d03Jrl0+8yd7v7EFHYcnMX35szu/snuHdbPO+msJ23KHj53Hzr57E23tUF3XzcFLY/IIqD516p66fTy+6fPW3PTjK7HJTmpqrYHPLfPFNis8Mjt23f32VX1ran94Uk+0N3fT5Kqev/0dT+Uxdjc/j3cmmTjKo4TAACAAexWoLMP2S/J8d39w5WNKwKeW3LDisfbkmyoqhOyCIce0t3XV9U5WbzJTpIfdve2PVbxvusH0yycn6rFiXxrd//VLWz/4+7u6fG2/OyYWnmOV34z3pbkWUmensUsk3VjGiPnJDmnqi5O8uzppe3nYuU5qiRP6+7LV+5je/i1G24+ti25AgAAWGfWy5KrzUleuP1JVW0PJD6VaWnQFNZc293fvY393DnJt6Yw54gslrLcks8n2VhV952e/+Fu1D6CjyX5vaq6R/LTaxP98m7s7y1JXpwk3X3p7pe3b6iqw6vq/iuajkryldvo8tEsrq1TU/8H3cI2n0zyjOn1Jya569T+qSQnV9UB0zKtp05tAAAALIHdmqEzLY/atEcq2XkHVNWVK56/KskpSV5fVRdlcUyfzOLuTJuSvHlqvz43zZa4NR9J8vyquizJ5UnOvaWNuvuH0wWTz66q67N4I33HXT+kWzYtj9q0p/e7Wt19aVX9TZLNVbVfkh8neUFuO6y4rf1dPZ3js/ZgmT9jWh61aa32fyvukOR1VXWXJD9J8j9ZLFd78q1s/7dJXpPkoum8fukWtj0tybuq6nNJ/jPJV5Oku8+vqrckOW/a7vTuvqCqNu6xowEAAGCfVTetloG9o6oOSHJxFrf3/s7c9QAAAMBo1suSKwZRVScmuSzJ64Q5AAAAsGvM0AEAAAAYjBk6AAAAAIMR6AAAAAAMRqADAAAAMJhV3bb8oIMO6o0bN65RKQAAAADLZ+vWrdd298Gr6bOqQGfjxo3ZsmXL6qoCAAAA4FZV1VdW28eSKwAAAIDBCHQAAAAABiPQAQAAABiMQAcAAABgMAIdAAAAgMEIdAAAAAAGI9ABAAAAGIxABwAAAGAwAh0AAACAwQh0AAAAAAYj0AEAAAAYjEAHAAAAYDACHQAAAIDBCHQAAAAABiPQAQAAABiMQAcAAABgMAIdAAAAgMEIdAAAAAAGI9ABAAAAGIxABwAAAGAwAh0AAACAwQh0AAAAAAYj0AEAAAAYjEAHAAAAYDACHQAAAIDBCHQAAAAABiPQAQAAABiMQAcAAABgMAIdAAAAgMGsKtDZdvXVa1UHwD7ru6981dwlDOtN//4/c5cA7AI/u8zJ312AnbOqQOdGgQ6whL73qlfPXcKwzjjnC3OXAOwCP7vMyd9dgJ1jyRUAAADAYAQ6AAAAAIPZsNoOVx162FrUAcA6dfypH527BAAG4z0HwI6ZoQMAAAAwGIEOAAAAwGBWveTq0KuuWIs6APZZpn3vnnNPe/zcJQCrZKkkc/OeA1g6VavuYoYOAAAAwGAEOgAAAACDEegAAAAADGZVgc5+hxyyVnUA7LPu+JI/n7uEYf3pCfeduwRgF/jZZU7+7gLsnOrund742GOP7S1btqxhOQAAAADLpaq2dvexq+ljyRUAAADAYAQ6AAAAAIMR6AAAAAAMRqADAAAAMBiBDgAAAMBgBDoAAAAAgxHoAAAAAAxGoAMAAAAwGIEOAAAAwGAEOgAAAACDEegAAAAADEagAwAAADAYgQ4AAADAYAQ6AAAAAIMR6AAAAAAMRqADAAAAMBiBDgAAAMBgBDoAAAAAgxHoAAAAAAxGoAMAAAAwGIEOAAAAwGAEOgAAAACDEegAAAAADEagAwAA7DPeedk75i4BYAgCHQAAYJ/x7svfOXcJAEMQ6AAAAAAMRqADAAAAMBiBDgAAAMBgNsxdAAAAwEonnfWkuUsA2OeZoQMAAAAwGIEOAAAAwGAsuQIAAPYpHzr57LlLANirKrXqPmboAAAAAAxGoAMAAAAwGIEOAACwz3j64c+YuwSAIQh0AACAfcYzHvDMuUsAGIJABwAAAGAwAh0AAACAwQh0AAAAAAYj0AEAAAAYjEAHAAAAYDACHQAAAIDBCHQAAAAABiPQAQAAABiMQAcAAABgMAIdAAAAgMEIdAAAAAAGI9ABAAAAGIxABwAAAGAwAh0AAACAwQh0AAAAAAYj0AEAAAAYjEAHAAAAYDACHQAAAIDBCHQAAAAABiPQAQAAABiMQAcAAABgMAIdAAAAgMEIdAAAAAAGI9ABAAAAGIxABwAAAGAwAh0AAACAwQh0AAAAAAYj0AEAAAAYjEAHAAAAYDDV3Tu/cdX3kly+duXArTooybVzF8HSMv6Yi7HHXIw95mT8MRdjjzkd3t13XE2HDav8Apd397Gr7AO7raq2GHvMxfhjLsYeczH2mJPxx1yMPeZUVVtW28eSKwAAAIDBCHQAAAAABrPaQOeNa1IF7Jixx5yMP+Zi7DEXY485GX/MxdhjTqsef6u6KDIAAAAA87PkCgAAAGAwOwx0qur2VXVeVX22qj5XVaftjcJgu6q6XVVdUFUfnrsWlktVfbmqLq6qC3flqvOwO6rqLlX1vqr6fFVdVlUPmbsm1r+qOnz6nbf947tV9eK562I5VNWfT+83Lqmqd1XV7eeuieVRVS+axt7n/N5jrVXVm6vqmqq6ZEXb3arq36rqv6fPd93RfnZmhs4NSR7d3UcmOSrJE6rq+F0vHVbtRUkum7sIltajuvsot7BkBq9N8pHuPiLJkfF7kL2guy+ffucdleSYJNcn+cDMZbEEqurQJKckOba7H5jkdkmePm9VLIuqemCS5yY5Lou/uU+uqvvNWxXr3FuSPOFmbS9N8rHuvn+Sj03Pb9MOA51euG56+gvThwvvsFdU1b2TPCnJ6XPXArC3VNWdkzwyyRlJ0t0/6u5vz1sVS+gxSb7Q3V+ZuxCWxoYk+1fVhiQHJPnazPWwPB6Q5NPdfX13/yTJJ5L87sw1sY519yeT/N/Nmp+S5K3T47cmOXlH+9mpa+hMS14uTHJNkn/r7k+volbYHa9J8pdJbpy7EJZSJ9lcVVur6nlzF8NS+ZUk30zyL9OS09Or6sC5i2LpPD3Ju+YuguXQ3VcleUWSryb5epLvdPfmeatiiVyS5BFVdfeqOiDJbyc5bOaaWD6HdPfXp8ffSHLIjjrsVKDT3dumqbf3TnLcNCUN1lRVPTnJNd29de5aWFoP7+6jkzwxyQuq6pFzF8TS2JDk6CRv6O4HJfl+dmLaLewpVfWLSU5K8t65a2E5TNeKeEoWgfYvJTmwqp41b1Usi+6+LMnfJ9mc5CNJLkyybdaiWGq9uB35DldGreouV9N073/Pz6/1grXwsCQnVdWXk7w7yaOr6u3zlsQymf63MN19TRbXkDhu3opYIlcmuXLFjNj3ZRHwwN7yxCTnd/fVcxfC0jgxyZe6+5vd/eMk70/y0JlrYol09xndfUx3PzLJt5L819w1sXSurqp7Jcn0+ZodddiZu1wdXFV3mR7vn+SxST6/m4XCDnX3X3X3vbt7YxbTvj/e3f6nhr2iqg6sqjtuf5zkcVlMx4U1193fSHJFVR0+NT0myaUzlsTy+cNYbsXe9dUkx1fVAVVVWfzeczF49pqqusf0+T5ZXD/nnfNWxBL6UJJnT4+fneSDO+qwYSd2eq8kb62q22URAL2nu90+GljvDknygcW/KbMhyTu7+yPzlsSSeWGSd0xLX76Y5Dkz18OSmELsxyb5s7lrYXl096er6n1Jzk/ykyQXJHnjvFWxZM6sqrsn+XGSF7gZAWupqt6V5IQkB1XVlUlOTfLyJO+pqj9N8pUkv7/D/SyWZgEAAAAwilVdQwcAAACA+Ql0AAAAAAYj0AEAAAAYjEAHAAAAYDACHQAAAIDB7MxtywEAZjXdSvZj09N7JtmW5JvT8+u7+6GzFAYAMBO3LQcAhlJVm5Jc192vmLsWAIC5WHIFAAytqq6bPp9QVZ+oqg9W1Rer6uVV9cyqOq+qLq6q+07bHVxVZ1bVZ6aPh817BAAAqyfQAQDWkyOTPD/JA5L8UZJf7e7jkpye5IXTNq9N8uru/s0kT5teAwAYimvoAADryWe6++tJUlVfSLJ5ar84yaOmxycm+bWq2t7nTlV1h+6+bq9WCgCwGwQ6AMB6csOKxzeueH5jbvp3z35Jju/uH+7NwgAA9iRLrgCAZbM5Ny2/SlUdNWMtAAC7RKADACybU5IcW1UXVdWlWVxzBwBgKG5bDgAAADAYM3QAAAAABiPQAQAAABiMQAcAAABgMAIdAAAAgMEIdAAAAAAGI9ABAAAAGIxABwAAAGAwAh0AAACAwfw/AxhbSj/Pf68AAAAASUVORK5CYII=\n", + "text/plain": [ + "" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "annotation = Annotation(uri=\"TheBigBangTheory.Season01.Episode01\", modality=\"speaker\")\n", + "annotation[Segment(3, 5), \"_\"] = \"Penny\"\n", + "annotation[\n", + " Segment(5.5, 7),\n", + " \"_\",\n", + "] = \"Leonard\"\n", + "annotation[Segment(8, 10), \"_\"] = \"Penny\"\n", + "annotation[Segment(8, 10), \"anything\"] = \"Sheldon\"\n", + "annotation" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "`_` is the default track identifier (in case you are sure that each segment has only one associated track). Generally, you should avoid using the shortcut `annotation[segment]` and always add a track identifier of your choosing. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Iterating over segments, tracks and/or labels" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[ 00:00:03.000 --> 00:00:05.000]\n", + "[ 00:00:05.500 --> 00:00:07.000]\n", + "[ 00:00:08.000 --> 00:00:10.000]\n" + ] + } + ], + "source": [ + "for segment in annotation.itersegments():\n", + " print(segment)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[ 00:00:03.000 --> 00:00:05.000] _\n", + "[ 00:00:05.500 --> 00:00:07.000] _\n", + "[ 00:00:08.000 --> 00:00:10.000] _\n", + "[ 00:00:08.000 --> 00:00:10.000] anything\n" + ] + } + ], + "source": [ + "for segment, track in annotation.itertracks():\n", + " print(segment, track)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[ 00:00:03.000 --> 00:00:05.000] _ Penny\n", + "[ 00:00:05.500 --> 00:00:07.000] _ Leonard\n", + "[ 00:00:08.000 --> 00:00:10.000] _ Penny\n", + "[ 00:00:08.000 --> 00:00:10.000] anything Sheldon\n" + ] + } + ], + "source": [ + "for segment, track, label in annotation.itertracks(yield_label=True):\n", + " print(segment, track, label)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Dealing with segments" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "One can use the **get_timeline** method to obtain a [timeline](pyannote.core.timeline.ipynb) made of all segments (not tracks!) in the annotation" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABHMAAABjCAYAAAAYTEz/AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nAACYiDIHAAAAYCL/BBkl8uk1EEtwAAAAAElFTkSuQmCC\n", + "text/plain": [ + ", , ])>" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "annotation.get_timeline()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Dealing with tracks" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Get all tracks for a given segment" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "{'_', 'anything'}" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "annotation.get_tracks(Segment(8, 10))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Check whether a given track exists" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "False" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "annotation.has_track(Segment(8, 10), \"---\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "One can re-initialize tracks as incrementing integer using **retrack** method. This also makes sure that no two tracks have the same identifier." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[ 00:00:03.000 --> 00:00:05.000] 0\n", + "[ 00:00:05.500 --> 00:00:07.000] 1\n", + "[ 00:00:08.000 --> 00:00:10.000] 2\n", + "[ 00:00:08.000 --> 00:00:10.000] 3\n" + ] + } + ], + "source": [ + "for segment, track in annotation.rename_tracks(generator=\"int\").itertracks():\n", + " print(segment, track)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Dealing with labels" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Get (sorted) list of unique labels" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "['Leonard', 'Penny', 'Sheldon']" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "annotation.labels()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "List of labels for a given segment. Read the help message for more options." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "{'Penny', 'Sheldon'}" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "annotation.get_labels(Segment(8, 10))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "One may want to be more precise on the identiy of each speaker and replace character names by actor names. We can use **translate** to do just that:" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABHMAAACxCAYAAABHuvHbAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\nAAALEgAACxIB0t1+/AAAFWVJREFUeJzt3XuUZWV5J+Dfi21UQA1qjKDCqBkjOsEYiTc0IuANb0RN\nogZvyRIzOtFlxmQ0yxjCTIyujGQ5UdcM0TDgNV6BqKN4Y6KTiEoQ0GjwgoqoIApixCB2v/PH3h2L\nspqu6q6u3bvP86xVq85l76/ec853dvf+ne/7TnV3AAAAAJiHvaYuAAAAAIDVE+YAAAAAzIgwBwAA\nAGBGhDkAAAAAMyLMAQAAAJgRYQ4AAADAjAhzAAAAAGZEmAMAAAAwI8IcAAAAgBkR5gAAAADMiDAH\nAAAAYEb2uDCnqu5fVZ+dug52T1W1paruOHUdO6uqnlpVH9nJNg4an4+fOA5U1e2r6qqqqp35G4uk\nqk6uqhOmrgMAANjz7TFhTlV9uKp+q7s/2t0Hr1ObD6yqzeNJ7Xer6rNV9bT1aJv1tfX1X8WmvcuL\nWYWqumFVvbiqPldV36uqi6vq3VX14DU0sx6PZcU2uvvi7r5Zd+8Wz9dGqaqLquqIJdefUFXfqaoH\nTFzXk6rqE2NfuWTsK4dNWRMAADCdPSbM2YUuGU9qb57kBUn+qqrustZGVhr9wCR2l5Emb0/yqCTH\nJtkvyR2SvCLJ0VMWxY9V1VOT/GWSh3f3To2C2sk6fi/JiUn+W5JbJzkwyasy9B8AAGAB7XEBwzia\n5uIl1y+qqudX1fnjCJvXVNWtq+o942ibM6vq5qtpu7tPT3JFkruObb+lqr5RVVdU1VlVddclf/fk\nqnr1+An695IcXlUPr6rPjHVcPJ6kbd3+GVX1+aq6vKpOq6r9l9y3paqeWVUXjqMEXrnkvjuNf/vK\nqrqsqt60U0/gHuD6nsvRg7fxXD61qj5SVX8+3vfFqnrYkvs/XFUnVNVHx9fwvVV1i/G+d1XVs5fV\ncV5VPWaF+o5KcmSSR3f3J7v7R+PPmd39vCXb/Zeq+sL4tz5dVcdcz2O+y9iXvz2OIPu1JffduKpe\nXlVfHvvq31XVjVZo43FV9aWquuv1TcFaBFX1zCR/nuQh3X32ktu3+Z5foY1HVtW547YfrapfGG9/\nflW9bdm2/6Oq/mKFNm6W5E+SPKu7T+/uH3T35u5+T3e/YNzmOtO7VjgG3mXsu1dU1QVV9agl922z\nb1TVo8d+952q+tCOhNgAAMCusWm9Gtqy+dB1m46x1w0+ubOjJ5bX8tgkRyS5YZJPJblHkqcn+VyS\n/5PkOUn+6/U1WFWV5JgkN09ywXjze5I8Lcm1SV6W5A1j21s9McOn+h8bT5AuSvL47v77MUC6w9j2\nEUlekuSoJP+U5OVJ3pzkgUvaekSSeyb56STnVNUZ3X3mWPf7uvvwqvqpJIdu78lZdyfstX5TcV68\nZade+6p6UHb8uUySeyU5OcktkzwzyWuT3HbJvk9M8rAkX0vy3iTPT/KHSU5J8p8zjJhIVd09yQFJ\n3r1CmUcmObu7v7Gdh/OFJId196VjOPP6qrpTd1+67DHvneTMJC9K8tAkhyT5QFVd0N2fG5+Dg5Pc\nJ8mlSe6dZMuyNp6e5IVJjuzui6rqoEwwJe2kY05dt7953GlP2dG+9KwkhyU5ors/vey+7b3nkyRV\ndY8MfecRSc7JMALrjKq6c5LXJ/njqrpZd19VVTdI8hsZXrvl7pvkRklOW+Nj6LGOTUn+Nslrkjw4\nyQOSnF5V9+zuz2cbfWOs841JHp3k/yb5vSR/W1UHd/eP1lgLAACwzhblU/e/7O7Lx5PnjyT5WHef\n390/TPLOrHAytsRtq+o7Sb6V5I+SHDueBKW7/3d3X93d1yY5Icndq+qmS/Y9vbs/Nm57TZIfJrlb\nVd20u7/b3Z8at3tSktd293ljWy9Mct+qOnBJW3/W3d/r7ouTfDjJL463X5vkoKq6bXf/sLv/fkef\npD3Eb2bHn8sk+Up3//W4VswpSfavqlsvuf/k7v7i+Hq+Zcm+ZyT591V1p/H6sUn+ZhsnvrdK8s2t\nV6pqv3FUxJVV9YOtt3f327cGN9391iSfzxA2LffIJBd196k9OC/DNK5fG0PIpyd5Tnd/c7z/Y+Nz\nkwzTzp6XIYh6YHdftEL7i+aoDMeI5UHOat7zWz0jyf8cR151d78uyTVJ7tPd38xwHNo6eurhSb61\n5Hiw1C2TXN7dW1a4bzXum2Sf7n7ZOPrrw0neleSJ2+kbv57kXd39oe7enOS/J7lJkvvtYB0AAMA6\nWreROeswmmZXWjqS4QcrXN/3eva9pLsPXH7jOP3kJUken+HkvMefWyX53rjZxct2e1yGQOhlVXVe\nkheMUzgOyPDpfZKku79fVd/OMCLkqys8hquX1Pz7GdbS+PgYOp3Y3Sdfz+NZfzs5mmad7cxzmSwJ\nWbr7B8P5bvZNctny+5fu293XVNVbkhw7Tnl5YobXeyXfTvJzS/7OFUn2G4OgC7feXlVPyRC0/Lvx\npn0y9K/lDkpyn/H1T4aA5gZJTh23v3GSL22jlmQYXXTCKkYK7XI7MZpmPf3HJC+qqtd2929vvXGV\n7/mtDkrylKr63a27ZxgZeMB4/dT8eOTXbyZ53TZq+XaSW1XVXjsY6OyfnzwOfSXD++H6+sYB43ZJ\nku7ucerWbVfYFgAA2GCLMjJnV3hShgVIj+jun85wwl257gK715ky0t3ndPcxSX4myelJ3jre9fUM\nJ39JkqraJ8Mn8l/bXhHdfVl3H9fdt03yO0leXXvAV2/vhEuyg8/lOjg1w4icI5N8f+laK8t8MMkv\nV9UB27g/40iikzKslbJfd++X5DNZeQHni5Oc1d23GH/2Gxft/k9JLs8QWN5phf2SoY8+JMkfVdVj\nV/EYF8GlGV7DB1TVq5fcvpr3/FYXJ/nTZa/Jvt39N+P9pyU5pKrulmFk1Ru2Ucs/ZBjRs831kpJ8\nP8neS64vXSPq60luv2z7AzO8Ty5P8q9ZuW9c55g0uv24HwAAMLE9NczZiE/3b5rhJOuKMTD4s1zP\nGiM1fBX1k8Z1MjZn+CR/83j3m5I8vaoOGdfWeUmGaR7LP1Ffqd3HV9XWT8uvzLAWyo5OydgTvDk7\n+FzurO7+hwx94OXZ9kiLdPf7M0zvOq2q7jX2jU0ZpsRstU+G1/HyqtprXNPmP2yjyXcluXNVHVtV\nm8b2Dq2qnx+ni52c5MSq2n9s6z5VdcNx38oQEj0sySuXLo6b3eebvzbcOBXqyCQPraoTx5vX8p7/\nqyS/U1X3SoZQsaqOHvdLd/9rkndkWJfm7O5eMWzs7quS/HGSV1XVY6rqJuNr/LCqeum42aeSHD1O\n17tNkucuaeLsJFdX1R+M+x2eITx609g3/jor9423JHlEVT1o3O/5GYKfRZ/GCQAAu4U9LczpZb+X\nX17p+o46NcO0nUuSfDqrO8l5cpKLqurKJMdl+KQ/3f3BDNOv3jG2d4ckT1hlzb+c5OyquirDp/3P\n6e4vr+mR7Dl6J5/LFdtc476nZghdXr+d7X41Qwjz+gzfkPalDFOzHpIk3f3ZDKHQxzJM7bpbko+u\nWGD3v4z7PSHDiIqvJ3lphoVzk2Ea1QVJPpFh2s5L8+P3fo9tnJ9h1MlJVfXQpfctmH97zGMAeGSS\nx1XVn2ZYQ2lV7/nuPifDujmvHKe/XZjkqcs2OyXJL2ToM9suqPvEDAsQvyjDdL+vJnl2frwo8uuS\nnJ/kyxkW5X7zkn2vzfC6Hp1hJM4rkzx567pfGdZK+om+0d0XZhhl9soM64U9IsmjtrEGFAAAsMFq\n+HB2/qrqnCR/0t1nTF0LG293ef2r6tgkx3X3r0xZB7u/qrpdhm/Uu80YyAEAAKzKHjEyZ1x34i5J\nzp26Fjbe7vL6j18R/uwk/2vKOtj9jYspPz/JmwU5AADAWs0+zBnXjXhvkj/YiHVR2L3sLq9/VT0k\nwxSYb2RYAwlWNIZ+301yRIb1cAAAANZkj5lmBQAAALAIZj8yBwAAAGCRCHMAAAAAZkSYAwAAADAj\nm1a7YVVZXAcAAABgnXV3rWX7VYc5Y+NrqwbWyfHHH5/jjz9+6jJYQPoeU9L/mIq+x5T0P6ai7zGV\nqjXlOElMswIAAACYFWEOAAAAwIwIc5iFww8/fOoSWFD6HlPS/5iKvseU9D+mou8xJ7XadXCqqq2Z\nAwAAALB+qmrNCyAbmQMAAAAwI8IcAAAAgBkR5gAAAADMiDAHAAAAYEaEOQAAAAAzIswBAAAAmBFh\nDgAAAMCMCHMAAAAAZkSYAwAAADAjwhwAAACAGRHmAAAAAMyIMAcAAABgRoQ5AAAAADMizAEAAACY\nEWEOAAAAwIwIcwAAAABmRJgDAAAAMCPCHAAAAIAZEeYAAAAAzIgwBwAAAGBGhDkAAAAAMyLMAQAA\nAJgRYQ4AAADAjAhzAAAAAGZEmAMAAAAwI8IcAAAAgBkR5gBsw0nHnJqTjjl16jLm64S9hh9gXrx3\nmZB/e4FFs6PHPP9SAwAAAMyIMAcAAABgRoQ5AAAAADOyaS0bm78KwJpZewOANXLeAXD9/A8bAAAA\nYEbWNDLnuNOesqvqANjt+FRwnbx4y9QVAGthNB27AecdwKLwbVYAAAAAC0CYAwAAADAjwhwAAACA\nGRHmAAAAAMxIdffqNqzq1W4LAAAAwPZVVbq71rKPkTkAAAAAMyLMAQAAAJgRYQ4AAADAjAhzAAAA\nAGZEmAMAAAAwI8IcAAAAgBkR5gAAAADMiDAHAAAAYEaEOQAAAAAzIswBAAAAmBFhDgAAAMCMCHMA\nAAAAZkSYAwAAADAjwhwAAACAGRHmAAAAAMyIMAcAAABgRoQ5AAAAADMizAEAAACYEWEOAAAAwIwI\ncwAAAABmRJgDAAAAMCPCHAAAAIAZEeYAAAAAzIgwBwAAAGBGhDkAAAAAMyLMAQAAdgtbNh+aLZsP\nnboMgA2zo8c8YQ4AAADAjAhzAAAAAGZEmAMAAAAwI8IcAAAAgBnZNHUBAAAAS1kEGeD6GZkDAAAA\nMCNG5gAAALuVvW7wyalLANgQvpocAAAAYAEIcwAAAABmRJgDAAAAMCPV3avbsKpXuy0AAAAA21dV\n6e5ayz5G5gAAAADMiDAHAAAAYEaEOQAAAAAzIswBAAAAmBFhDgAAAMCMCHMAAAAAZkSYAwAAADAj\nwhwAAACAGRHmAAAAAMyIMAcAAABgRoQ5AAAAADMizAEAAACYEWEOAAAAwIwIcwAAAABmRJgDAAAA\nMCPCHAAAAIAZEeYAAAAAzIgwBwAAAGBGhDkAAAAAMyLMAQAAAJgRYQ4AAADAjAhzAAAAAGZEmAMA\nAAAwI8IcAAAAgBkR5gAAAADMiDAHAAAAYEaEOQAAAAAzIsxhFs4666ypS2BB6XtMSf9jKvoeU9L/\nmIq+x5wIc5gFB1amou8xJf2Pqeh7TEn/Yyr6HnMizAEAAACYEWEOAAAAwIxUd69uw6rVbQgAAADA\nqnV3rWX7VYc5AAAAAEzPNCsAAACAGRHmAAAAAMzIdsOcqrpRVZ1dVedW1Weq6iUbURhsVVV7VdU/\nVtUZU9fCYqmqL1fVeePx7+NT18PiqKqbV9Vbq+qz47+99566JhZDVd15POb94/j7u1X1nKnrYjFU\n1QvHY975VfWGqvqpqWtiMVTVc6vqgvHHMY9dqqpeW1WXVtX5S27br6rOrKp/rqr3VdXNt9fOdsOc\n7r4myYO6+x5JDklyRFUdtlPVw9o8N8k/TV0EC2lLksO7+x7dfa+pi2GhvCLJe7r74CR3T/LZieth\nQXT3heMx75eS3DPJ95O8c+KyWABVdVCSZyS5R3cfkmRTkidMWxWLoKruluS3kxya5BeTPLKq7jht\nVezhTk7y0GW3vSDJB7r755N8KMkLt9fIqqZZdffV48Ubjftcsfo6YcdV1e2SHJ3kNVPXwkKqmI7K\nBquqmyV5QHefnCTd/aPuvmrislhMRyX5YndfPHUhLISrkvwwyT5VtSnJ3km+Pm1JLIiDk5zd3dd0\n9+Ykf5fksRPXxB6suz+an8xUHpPklPHyKUmO2V47qzpJGae5nJvkm0nO6m6jJNgof5Hk95P42jWm\n0EneX1WfqKpnTF0MC+MOSS6vqpPHqS4nVdVNpi6KhfQbSd40dREshu6+IsnLk3w1ySVJruzuD0xb\nFQvi00keME5z2TvDB8m3n7gmFs+tu/vSJOnubya59fZ2WO3InC3jNKvbJfmVqnrgTpUJq1BVj0hy\naXd/KsMIiZq4JBbPYeNUg6OTPLuq7j91QSyETUl+Kcmrxv53dYaht7BhquqGSR6d5K1T18JiGKe1\nPC/JQUkOSLJvVT1p2qpYBN39uSQvS/L+JO9Jcm6SzZMWBasYzLCm6QPjMO93Z5hPCLvaYUkeXVVf\nyvDJ4IOq6tSJa2KBdPc3xt/fyrBmhHVz2AhfS3Jxd39yvP62DOEObKSHJzlnPP7BRjg0yf/r7u+M\nU13ekeR+E9fEgujuk7v70O4+PMmVSS6cuCQWz6VV9bNJUlW3SXLZ9nZYzbdZ3WrrSsrjMO8HJ/nU\nThYK29Xdf9jdB3b3HTMsgPeh7n7K1HWxGKpq76rad7y8T5KHZBiGC7vUOMT24qq683jTkbEIPBvv\niTHFio31z0nuU1U3rqrKcOyz+Dsboqp+Zvx9YJJfTfLGaStiASyfeXJGkqeNl5+a5PTtNbBpFX9k\n/ySnjAfVvZK8rrs/uLY6AWbnZ5O8s6o6w7HyDd195sQ1sTiek+QN41SXLyV5+sT1sEDGNSOOSnLc\n1LWwOLr7vHEE9jkZpricm+Skaatigby9qm6R5Nokz/LFA+xKVfXGJIcnuWVVfTXJHyd5aZK3VtVv\nJflKkl/fbjvd1pUFAAAAmAtfuQsAAAAwI8IcAAAAgBkR5gAAAADMiDAHAAAAYEaEOQAAAAAzIswB\nAAAAmJFNUxcAALA9VXWLJB9M0kn2T7I5yWVJKsn3u/v+E5YHALChqrunrgEAYNWq6sVJ/qW7T5y6\nFgCAKZhmBQDMTV3nStX3xt8PrKqzquq0qvpCVb20qo6tqo9X1XlVdYdxu1tV1duq6uzx535TPAgA\ngB0lzAEA5m7pMONDkhyX5K5Jnpzk57r7Xklem+R3x21ekeTE7r53kscnec0G1goAsNOsmQMA7Ek+\n0d2XJUlVfSHJ+8bbL0hy+Hj5qCQHV9XWET77VtXe3X31hlYKALCDhDkAwJ7kmiWXtyy5viU//n9P\nJbl3d1+7kYUBAKwX06wAgLmr7W9yHWcmee6/7Vx19/UtBwBg1xLmAABzt62v5tzW7c9Ncui4KPKn\nkzxz15QFALBr+GpyAAAAgBkxMgcAAABgRoQ5AAAAADMizAEAAACYEWEOAAAAwIwIcwAAAABmRJgD\nAAAAMCPCHAAAAIAZEeYAAAAAzMj/B0/zA7lD9gfFAAAAAElFTkSuQmCC\n", + "text/plain": [ + "" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "mapping = {\n", + " \"Penny\": \"Kaley Cuoco\",\n", + " \"Sheldon\": \"Jim Parsons\",\n", + " \"Leonard\": \"Johnny Galecki\",\n", + "}\n", + "annotation.rename_labels(mapping=mapping)" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABHMAAACxCAYAAABHuvHbAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\nAAALEgAACxIB0t1+/AAAFWVJREFUeJzt3XuUZWV5J+Dfi21UQA1qjKDCqBkjOsEYiTc0IuANb0RN\nogZvyRIzOtFlxmQ0yxjCTIyujGQ5UdcM0TDgNV6BqKN4Y6KTiEoQ0GjwgoqoIApixCB2v/PH3h2L\nspqu6q6u3bvP86xVq85l76/ec853dvf+ne/7TnV3AAAAAJiHvaYuAAAAAIDVE+YAAAAAzIgwBwAA\nAGBGhDkAAAAAMyLMAQAAAJgRYQ4AAADAjAhzAAAAAGZEmAMAAAAwI8IcAAAAgBkR5gAAAADMiDAH\nAAAAYEb2uDCnqu5fVZ+dug52T1W1paruOHUdO6uqnlpVH9nJNg4an4+fOA5U1e2r6qqqqp35G4uk\nqk6uqhOmrgMAANjz7TFhTlV9uKp+q7s/2t0Hr1ObD6yqzeNJ7Xer6rNV9bT1aJv1tfX1X8WmvcuL\nWYWqumFVvbiqPldV36uqi6vq3VX14DU0sx6PZcU2uvvi7r5Zd+8Wz9dGqaqLquqIJdefUFXfqaoH\nTFzXk6rqE2NfuWTsK4dNWRMAADCdPSbM2YUuGU9qb57kBUn+qqrustZGVhr9wCR2l5Emb0/yqCTH\nJtkvyR2SvCLJ0VMWxY9V1VOT/GWSh3f3To2C2sk6fi/JiUn+W5JbJzkwyasy9B8AAGAB7XEBwzia\n5uIl1y+qqudX1fnjCJvXVNWtq+o942ibM6vq5qtpu7tPT3JFkruObb+lqr5RVVdU1VlVddclf/fk\nqnr1+An695IcXlUPr6rPjHVcPJ6kbd3+GVX1+aq6vKpOq6r9l9y3paqeWVUXjqMEXrnkvjuNf/vK\nqrqsqt60U0/gHuD6nsvRg7fxXD61qj5SVX8+3vfFqnrYkvs/XFUnVNVHx9fwvVV1i/G+d1XVs5fV\ncV5VPWaF+o5KcmSSR3f3J7v7R+PPmd39vCXb/Zeq+sL4tz5dVcdcz2O+y9iXvz2OIPu1JffduKpe\nXlVfHvvq31XVjVZo43FV9aWquuv1TcFaBFX1zCR/nuQh3X32ktu3+Z5foY1HVtW547YfrapfGG9/\nflW9bdm2/6Oq/mKFNm6W5E+SPKu7T+/uH3T35u5+T3e/YNzmOtO7VjgG3mXsu1dU1QVV9agl922z\nb1TVo8d+952q+tCOhNgAAMCusWm9Gtqy+dB1m46x1w0+ubOjJ5bX8tgkRyS5YZJPJblHkqcn+VyS\n/5PkOUn+6/U1WFWV5JgkN09ywXjze5I8Lcm1SV6W5A1j21s9McOn+h8bT5AuSvL47v77MUC6w9j2\nEUlekuSoJP+U5OVJ3pzkgUvaekSSeyb56STnVNUZ3X3mWPf7uvvwqvqpJIdu78lZdyfstX5TcV68\nZade+6p6UHb8uUySeyU5OcktkzwzyWuT3HbJvk9M8rAkX0vy3iTPT/KHSU5J8p8zjJhIVd09yQFJ\n3r1CmUcmObu7v7Gdh/OFJId196VjOPP6qrpTd1+67DHvneTMJC9K8tAkhyT5QFVd0N2fG5+Dg5Pc\nJ8mlSe6dZMuyNp6e5IVJjuzui6rqoEwwJe2kY05dt7953GlP2dG+9KwkhyU5ors/vey+7b3nkyRV\ndY8MfecRSc7JMALrjKq6c5LXJ/njqrpZd19VVTdI8hsZXrvl7pvkRklOW+Nj6LGOTUn+Nslrkjw4\nyQOSnF5V9+zuz2cbfWOs841JHp3k/yb5vSR/W1UHd/eP1lgLAACwzhblU/e/7O7Lx5PnjyT5WHef\n390/TPLOrHAytsRtq+o7Sb6V5I+SHDueBKW7/3d3X93d1yY5Icndq+qmS/Y9vbs/Nm57TZIfJrlb\nVd20u7/b3Z8at3tSktd293ljWy9Mct+qOnBJW3/W3d/r7ouTfDjJL463X5vkoKq6bXf/sLv/fkef\npD3Eb2bHn8sk+Up3//W4VswpSfavqlsvuf/k7v7i+Hq+Zcm+ZyT591V1p/H6sUn+ZhsnvrdK8s2t\nV6pqv3FUxJVV9YOtt3f327cGN9391iSfzxA2LffIJBd196k9OC/DNK5fG0PIpyd5Tnd/c7z/Y+Nz\nkwzTzp6XIYh6YHdftEL7i+aoDMeI5UHOat7zWz0jyf8cR151d78uyTVJ7tPd38xwHNo6eurhSb61\n5Hiw1C2TXN7dW1a4bzXum2Sf7n7ZOPrrw0neleSJ2+kbv57kXd39oe7enOS/J7lJkvvtYB0AAMA6\nWreROeswmmZXWjqS4QcrXN/3eva9pLsPXH7jOP3kJUken+HkvMefWyX53rjZxct2e1yGQOhlVXVe\nkheMUzgOyPDpfZKku79fVd/OMCLkqys8hquX1Pz7GdbS+PgYOp3Y3Sdfz+NZfzs5mmad7cxzmSwJ\nWbr7B8P5bvZNctny+5fu293XVNVbkhw7Tnl5YobXeyXfTvJzS/7OFUn2G4OgC7feXlVPyRC0/Lvx\npn0y9K/lDkpyn/H1T4aA5gZJTh23v3GSL22jlmQYXXTCKkYK7XI7MZpmPf3HJC+qqtd2929vvXGV\n7/mtDkrylKr63a27ZxgZeMB4/dT8eOTXbyZ53TZq+XaSW1XVXjsY6OyfnzwOfSXD++H6+sYB43ZJ\nku7ucerWbVfYFgAA2GCLMjJnV3hShgVIj+jun85wwl257gK715ky0t3ndPcxSX4myelJ3jre9fUM\nJ39JkqraJ8Mn8l/bXhHdfVl3H9fdt03yO0leXXvAV2/vhEuyg8/lOjg1w4icI5N8f+laK8t8MMkv\nV9UB27g/40iikzKslbJfd++X5DNZeQHni5Oc1d23GH/2Gxft/k9JLs8QWN5phf2SoY8+JMkfVdVj\nV/EYF8GlGV7DB1TVq5fcvpr3/FYXJ/nTZa/Jvt39N+P9pyU5pKrulmFk1Ru2Ucs/ZBjRs831kpJ8\nP8neS64vXSPq60luv2z7AzO8Ty5P8q9ZuW9c55g0uv24HwAAMLE9NczZiE/3b5rhJOuKMTD4s1zP\nGiM1fBX1k8Z1MjZn+CR/83j3m5I8vaoOGdfWeUmGaR7LP1Ffqd3HV9XWT8uvzLAWyo5OydgTvDk7\n+FzurO7+hwx94OXZ9kiLdPf7M0zvOq2q7jX2jU0ZpsRstU+G1/HyqtprXNPmP2yjyXcluXNVHVtV\nm8b2Dq2qnx+ni52c5MSq2n9s6z5VdcNx38oQEj0sySuXLo6b3eebvzbcOBXqyCQPraoTx5vX8p7/\nqyS/U1X3SoZQsaqOHvdLd/9rkndkWJfm7O5eMWzs7quS/HGSV1XVY6rqJuNr/LCqeum42aeSHD1O\n17tNkucuaeLsJFdX1R+M+x2eITx609g3/jor9423JHlEVT1o3O/5GYKfRZ/GCQAAu4U9LczpZb+X\nX17p+o46NcO0nUuSfDqrO8l5cpKLqurKJMdl+KQ/3f3BDNOv3jG2d4ckT1hlzb+c5OyquirDp/3P\n6e4vr+mR7Dl6J5/LFdtc476nZghdXr+d7X41Qwjz+gzfkPalDFOzHpIk3f3ZDKHQxzJM7bpbko+u\nWGD3v4z7PSHDiIqvJ3lphoVzk2Ea1QVJPpFh2s5L8+P3fo9tnJ9h1MlJVfXQpfctmH97zGMAeGSS\nx1XVn2ZYQ2lV7/nuPifDujmvHKe/XZjkqcs2OyXJL2ToM9suqPvEDAsQvyjDdL+vJnl2frwo8uuS\nnJ/kyxkW5X7zkn2vzfC6Hp1hJM4rkzx567pfGdZK+om+0d0XZhhl9soM64U9IsmjtrEGFAAAsMFq\n+HB2/qrqnCR/0t1nTF0LG293ef2r6tgkx3X3r0xZB7u/qrpdhm/Uu80YyAEAAKzKHjEyZ1x34i5J\nzp26Fjbe7vL6j18R/uwk/2vKOtj9jYspPz/JmwU5AADAWs0+zBnXjXhvkj/YiHVR2L3sLq9/VT0k\nwxSYb2RYAwlWNIZ+301yRIb1cAAAANZkj5lmBQAAALAIZj8yBwAAAGCRCHMAAAAAZkSYAwAAADAj\nm1a7YVVZXAcAAABgnXV3rWX7VYc5Y+NrqwbWyfHHH5/jjz9+6jJYQPoeU9L/mIq+x5T0P6ai7zGV\nqjXlOElMswIAAACYFWEOAAAAwIwIc5iFww8/fOoSWFD6HlPS/5iKvseU9D+mou8xJ7XadXCqqq2Z\nAwAAALB+qmrNCyAbmQMAAAAwI8IcAAAAgBkR5gAAAADMiDAHAAAAYEaEOQAAAAAzIswBAAAAmBFh\nDgAAAMCMCHMAAAAAZkSYAwAAADAjwhwAAACAGRHmAAAAAMyIMAcAAABgRoQ5AAAAADMizAEAAACY\nEWEOAAAAwIwIcwAAAABmRJgDAAAAMCPCHAAAAIAZEeYAAAAAzIgwBwAAAGBGhDkAAAAAMyLMAQAA\nAJgRYQ4AAADAjAhzAAAAAGZEmAMAAAAwI8IcAAAAgBkR5gBsw0nHnJqTjjl16jLm64S9hh9gXrx3\nmZB/e4FFs6PHPP9SAwAAAMyIMAcAAABgRoQ5AAAAADOyaS0bm78KwJpZewOANXLeAXD9/A8bAAAA\nYEbWNDLnuNOesqvqANjt+FRwnbx4y9QVAGthNB27AecdwKLwbVYAAAAAC0CYAwAAADAjwhwAAACA\nGRHmAAAAAMxIdffqNqzq1W4LAAAAwPZVVbq71rKPkTkAAAAAMyLMAQAAAJgRYQ4AAADAjAhzAAAA\nAGZEmAMAAAAwI8IcAAAAgBkR5gAAAADMiDAHAAAAYEaEOQAAAAAzIswBAAAAmBFhDgAAAMCMCHMA\nAAAAZkSYAwAAADAjwhwAAACAGRHmAAAAAMyIMAcAAABgRoQ5AAAAADMizAEAAACYEWEOAAAAwIwI\ncwAAAABmRJgDAAAAMCPCHAAAAIAZEeYAAAAAzIgwBwAAAGBGhDkAAAAAMyLMAQAAdgtbNh+aLZsP\nnboMgA2zo8c8YQ4AAADAjAhzAAAAAGZEmAMAAAAwI8IcAAAAgBnZNHUBAAAAS1kEGeD6GZkDAAAA\nMCNG5gAAALuVvW7wyalLANgQvpocAAAAYAEIcwAAAABmRJgDAAAAMCPV3avbsKpXuy0AAAAA21dV\n6e5ayz5G5gAAAADMiDAHAAAAYEaEOQAAAAAzIswBAAAAmBFhDgAAAMCMCHMAAAAAZkSYAwAAADAj\nwhwAAACAGRHmAAAAAMyIMAcAAABgRoQ5AAAAADMizAEAAACYEWEOAAAAwIwIcwAAAABmRJgDAAAA\nMCPCHAAAAIAZEeYAAAAAzIgwBwAAAGBGhDkAAAAAMyLMAQAAAJgRYQ4AAADAjAhzAAAAAGZEmAMA\nAAAwI8IcAAAAgBkR5gAAAADMiDAHAAAAYEaEOQAAAAAzIsxhFs4666ypS2BB6XtMSf9jKvoeU9L/\nmIq+x5wIc5gFB1amou8xJf2Pqeh7TEn/Yyr6HnMizAEAAACYEWEOAAAAwIxUd69uw6rVbQgAAADA\nqnV3rWX7VYc5AAAAAEzPNCsAAACAGRHmAAAAAMzIdsOcqrpRVZ1dVedW1Weq6iUbURhsVVV7VdU/\nVtUZU9fCYqmqL1fVeePx7+NT18PiqKqbV9Vbq+qz47+99566JhZDVd15POb94/j7u1X1nKnrYjFU\n1QvHY975VfWGqvqpqWtiMVTVc6vqgvHHMY9dqqpeW1WXVtX5S27br6rOrKp/rqr3VdXNt9fOdsOc\n7r4myYO6+x5JDklyRFUdtlPVw9o8N8k/TV0EC2lLksO7+x7dfa+pi2GhvCLJe7r74CR3T/LZieth\nQXT3heMx75eS3DPJ95O8c+KyWABVdVCSZyS5R3cfkmRTkidMWxWLoKruluS3kxya5BeTPLKq7jht\nVezhTk7y0GW3vSDJB7r755N8KMkLt9fIqqZZdffV48Ubjftcsfo6YcdV1e2SHJ3kNVPXwkKqmI7K\nBquqmyV5QHefnCTd/aPuvmrislhMRyX5YndfPHUhLISrkvwwyT5VtSnJ3km+Pm1JLIiDk5zd3dd0\n9+Ykf5fksRPXxB6suz+an8xUHpPklPHyKUmO2V47qzpJGae5nJvkm0nO6m6jJNgof5Hk95P42jWm\n0EneX1WfqKpnTF0MC+MOSS6vqpPHqS4nVdVNpi6KhfQbSd40dREshu6+IsnLk3w1ySVJruzuD0xb\nFQvi00keME5z2TvDB8m3n7gmFs+tu/vSJOnubya59fZ2WO3InC3jNKvbJfmVqnrgTpUJq1BVj0hy\naXd/KsMIiZq4JBbPYeNUg6OTPLuq7j91QSyETUl+Kcmrxv53dYaht7BhquqGSR6d5K1T18JiGKe1\nPC/JQUkOSLJvVT1p2qpYBN39uSQvS/L+JO9Jcm6SzZMWBasYzLCm6QPjMO93Z5hPCLvaYUkeXVVf\nyvDJ4IOq6tSJa2KBdPc3xt/fyrBmhHVz2AhfS3Jxd39yvP62DOEObKSHJzlnPP7BRjg0yf/r7u+M\nU13ekeR+E9fEgujuk7v70O4+PMmVSS6cuCQWz6VV9bNJUlW3SXLZ9nZYzbdZ3WrrSsrjMO8HJ/nU\nThYK29Xdf9jdB3b3HTMsgPeh7n7K1HWxGKpq76rad7y8T5KHZBiGC7vUOMT24qq683jTkbEIPBvv\niTHFio31z0nuU1U3rqrKcOyz+Dsboqp+Zvx9YJJfTfLGaStiASyfeXJGkqeNl5+a5PTtNbBpFX9k\n/ySnjAfVvZK8rrs/uLY6AWbnZ5O8s6o6w7HyDd195sQ1sTiek+QN41SXLyV5+sT1sEDGNSOOSnLc\n1LWwOLr7vHEE9jkZpricm+Skaatigby9qm6R5Nokz/LFA+xKVfXGJIcnuWVVfTXJHyd5aZK3VtVv\nJflKkl/fbjvd1pUFAAAAmAtfuQsAAAAwI8IcAAAAgBkR5gAAAADMiDAHAAAAYEaEOQAAAAAzIswB\nAAAAmJFNUxcAALA9VXWLJB9M0kn2T7I5yWVJKsn3u/v+E5YHALChqrunrgEAYNWq6sVJ/qW7T5y6\nFgCAKZhmBQDMTV3nStX3xt8PrKqzquq0qvpCVb20qo6tqo9X1XlVdYdxu1tV1duq6uzx535TPAgA\ngB0lzAEA5m7pMONDkhyX5K5Jnpzk57r7Xklem+R3x21ekeTE7r53kscnec0G1goAsNOsmQMA7Ek+\n0d2XJUlVfSHJ+8bbL0hy+Hj5qCQHV9XWET77VtXe3X31hlYKALCDhDkAwJ7kmiWXtyy5viU//n9P\nJbl3d1+7kYUBAKwX06wAgLmr7W9yHWcmee6/7Vx19/UtBwBg1xLmAABzt62v5tzW7c9Ncui4KPKn\nkzxz15QFALBr+GpyAAAAgBkxMgcAAABgRoQ5AAAAADMizAEAAACYEWEOAAAAwIwIcwAAAABmRJgD\nAAAAMCPCHAAAAIAZEeYAAAAAzMj/B0/zA7lD9gfFAAAAAElFTkSuQmCC\n", + "text/plain": [ + "" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# this also used to work -- but no longer does\n", + "annotation % mapping" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Cropping and subsetting" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The **crop** method works the same way it does for [timeline](pyannote.core.timeline.ipynb) instances." + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABHMAAACxCAYAAABHuvHbAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nAAAAAAsizAEAAABYkP8P6kcT+He2vk4AAAAASUVORK5CYII=\n", + "text/plain": [ + "" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "annotation" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABHMAAABjCAYAAAAYTEz/AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\nAAALEgAACxIB0t1+/AAACIlJREFUeJzt3VmorWUdBvDnL6fJpGgesMKIwgJNk4xsOJUVDTQRTTRH\nBUVJF0F1kfsq7KKii26iEAvrwsoKCrSBQ9SFTWZzYlLapEVzgpX+u9ifpYbstT3n7Nf3fL8fbNa3\nF99a5znw8q1znvW+71fdHQAAAADmcNToAAAAAABsTpkDAAAAMBFlDgAAAMBElDkAAAAAE1HmAAAA\nAExEmQMAAAAwkX2bnlhV7mEOAAAAcIh1d+3m/I3LnOXNd5cGDpGtra1sbW2NjsEKGXuMZPwxirHH\nSMYfoxh7jFK1qx4niWVWAAAAAFNR5gAAAABMRJnDFPbv3z86Aitl7DGS8ccoxh4jGX+MYuwxk9p0\nH5yqanvmAAAAABw6VbXrDZDNzAEAAACYiDIHAAAAYCLKHAAAAICJKHMAAAAAJqLMAQAAAJiIMgcA\nAABgIsocAAAAgIkocwAAAAAmoswBAAAAmIgyBwAAAGAiyhwAAACAiShzAAAAACaizAEAAACYiDIH\nAAAAYCLKHAAAAICJKHMAAAAAJqLMAQAAAJiIMgcAAABgIsocAAAAgIkocwDgNmpra2t0BABYDZ+7\nzKS6e7MTq3rTcwGAg1dV8dkLAHvD5y6jLGOvdvMaM3MAAAAAJrJvdAAA4JZV7epLGgAAVkCZAwC3\nYaZ7A8De8AUKM7HMCgAAAGAiyhwAuI0688wzR0cAgNXwuctM3M0KAAAAYBB3swIAAAA4wilzAAAA\nACaizAEAAACYiDIHAAAAYCLKHAAAAICJKHMAAAAAJqLMAQAAAJiIMgcAAABgIsocAAAAgIkocwAA\nAAAmoswBAAAAmIgyBwAAAGAiyhwAAACAiShzAAAAACaizAEAAACYiDIHAAAAYCLKHAAAAICJKHMA\nAAAAJqLMAQAAAJiIMocpHDhwYHQEVsrYYyTjj1GMPUYy/hjF2GMmyhym4MLKKMYeIxl/jGLsMZLx\nxyjGHjNR5gAAAABMRJkDAAAAMJHq7s1OrNrsRAAAAAA21t21m/M3LnMAAAAAGM8yKwAAAICJKHMA\nAAAAJrJjmVNVd6iqi6rq4qr6UVW9Zy+CwQ2q6qiq+m5VfX50Ftalqn5RVZcs179vjs7DelTVXavq\nvKr6yfLZe+roTKxDVT10ueZ9d3n8S1W9dXQu1qGq3rlc875fVedW1e1HZ2IdquqMqvrB8uOax2FV\nVR+tqquq6vs3eu5uVXVhVf2sqi6oqrvu9D47ljndfW2SJ3X3SUlOSPLkqjrtoNLD7pyR5MejQ7BK\n1yfZ390ndfejR4dhVT6Y5IvdfXySE5P8ZHAeVqK7L12ueScneVSSfyQ5f3AsVqCqHpTk9UlO6u4T\nkuxL8pKxqViDqnpEktclOSXJI5M8u6oePDYVR7izkzz9Zs+9I8mXu/thSb6a5J07vclGy6y6+5rl\n8A7La/60eU649arq2CTPTPKR0VlYpYrlqOyxqrpLksd399lJ0t3/7u6/Do7FOp2e5OfdfeXoIKzC\nX5P8M8mdq2pfkqOT/GZsJFbi+CQXdfe13X1dkq8lecHgTBzBuvvr+f9O5blJzlmOz0nyvJ3eZ6P/\npCzLXC5O8rskB7rbLAn2ygeSvD2J264xQif5UlV9q6pePzoMq3Fckj9U1dnLUpcPV9WdRodilV6c\n5JOjQ7AO3f2nJO9LckWSXyf5c3d/eWwqVuKHSR6/LHM5OttfJD9gcCbW597dfVWSdPfvktx7pxds\nOjPn+mWZ1bFJnlBVTzyomLCBqnpWkqu6+3vZniFRgyOxPqctSw2emeTNVfW40YFYhX1JTk7yoWX8\nXZPtqbewZ6rqdkmek+S80VlYh2VZy9uSPCjJ/ZMcU1UvG5uKNejunyZ5b5IvJflikouTXDc0FGww\nmWFXyweWad5fyPZ6QjjcTkvynKq6PNvfDD6pqj42OBMr0t2/XR5/n+09I+ybw174VZIru/vby++f\nyna5A3vpGUm+s1z/YC+ckuQb3f3HZanLZ5I8dnAmVqK7z+7uU7p7f5I/J7l0cCTW56qquk+SVNV9\nk1y90ws2uZvVPW/YSXmZ5v3UJN87yKCwo+5+V3c/sLsfnO0N8L7a3a8cnYt1qKqjq+qY5fjOSZ6W\n7Wm4cFgtU2yvrKqHLk89JTaBZ++9NJZYsbd+luQxVXXHqqpsX/ts/s6eqKp7LY8PTPL8JJ8Ym4gV\nuPnKk88nefVy/Kokn9vpDfZt8IfcL8k5y0X1qCQf7+6v7C4nwHTuk+T8qupsXyvP7e4LB2diPd6a\n5NxlqcvlSV4zOA8rsuwZcXqSN4zOwnp09yXLDOzvZHuJy8VJPjw2FSvy6aq6e5J/JXmTGw9wOFXV\nJ5LsT3KPqroiyZlJzkpyXlW9Nskvk7xox/fptq8sAAAAwCzcchcAAABgIsocAAAAgIkocwAAAAAm\noswBAAAAmIgyBwAAAGAiyhwAAACAiewbHQAAYCdVdfckX0nSSe6X5LokVyepJP/o7scNjAcAsKeq\nu0dnAADYWFW9O8nfu/v9o7MAAIxgmRUAMJu6yS9Vf1sen1hVB6rqs1V1WVWdVVUvr6pvVtUlVXXc\nct49q+pTVXXR8vPYEX8JAIBbS5kDAMzuxtOMT0jyhiQPT/KKJA/p7kcn+WiStyznfDDJ+7v71CQv\nTPKRPcwKAHDQ7JkDABxJvtXdVydJVV2W5ILl+R8k2b8cn57k+Kq6YYbPMVV1dHdfs6dJAQBuJWUO\nAHAkufZGx9ff6Pfr879/91SSU7v7X3sZDADgULHMCgCYXe18yk1cmOSM/7646sRDGwcA4PBS5gAA\ns7ulW3Pe0vNnJDll2RT5h0neeHhiAQAcHm5NDgAAADARM3MAAAAAJqLMAQAAAJiIMgcAAABgIsoc\nAAAAgIkocwAAAAAmoswBAAAAmIgyBwAAAGAiyhwAAACAifwHBz7g6SX8/UMAAAAASUVORK5CYII=\n", + "text/plain": [ + "" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "segment = Segment(6, 9)\n", + "segment" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABHMAAACxCAYAAABHuvHbAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nAAvy/wEUbxAIVIiWpgAAAABJRU5ErkJggg==\n", + "text/plain": [ + "" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "annotation.crop(segment)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The **subset** method allows to extract annotations based on their labels." + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABHMAAACxCAYAAABHuvHbAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nAAAAwIr8P9mng5zUawClAAAAAElFTkSuQmCC\n", + "text/plain": [ + "" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "male_characters = {\"Sheldon\", \"Leonard\"}\n", + "annotation.subset(male_characters)" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABHMAAACxCAYAAABHuvHbAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nrkJggg==\n", + "text/plain": [ + "" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# all but male characters\n", + "annotation.subset(male_characters, invert=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Analyzing annotations" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABHMAAABjCAYAAAAYTEz/AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nRU5ErkJggg==\n", + "text/plain": [ + ", ])>" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# timeline made of Penny's segments\n", + "annotation.label_timeline(\"Penny\")" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Penny spoke during 4.000000 seconds\n" + ] + } + ], + "source": [ + "# total Penny's speech duration\n", + "print(f\"Penny spoke during {annotation.label_duration('Penny'):f} seconds\")" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[('Penny', 4), ('Sheldon', 2), ('Leonard', 1.5)]" + ] + }, + "execution_count": 26, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# label chart based on their duration\n", + "annotation.chart()" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "'Penny'" + ] + }, + "execution_count": 27, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# who is the biggest speaker?\n", + "annotation.argmax()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Other operations" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**co_iter** works the same way as for [timeline](pyannote.core.timeline.ipynb) except it iterates over overlapping (segment, track) tuples." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Need help?" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You can always try the following... \n", + "Who knows? It might give you the information you are looking for!" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Help on class Annotation in module pyannote.core.annotation:\n", + "\n", + "class Annotation(__builtin__.object)\n", + " | Annotation\n", + " | \n", + " | Parameters\n", + " | ----------\n", + " | uri : string, optional\n", + " | uniform resource identifier of annotated document\n", + " | modality : string, optional\n", + " | name of annotated modality\n", + " | \n", + " | Methods defined here:\n", + " | \n", + " | __bool__(self)\n", + " | \n", + " | __contains__(self, included)\n", + " | Inclusion\n", + " | \n", + " | Use expression 'segment in annotation' or 'timeline in annotation'\n", + " | \n", + " | Parameters\n", + " | ----------\n", + " | included : `Segment` or `Timeline`\n", + " | \n", + " | Returns\n", + " | -------\n", + " | contains : bool\n", + " | True if every segment in `included` exists in annotation\n", + " | False otherwise\n", + " | \n", + " | __delitem__(self, key)\n", + " | \n", + " | __eq__(self, other)\n", + " | \n", + " | __getitem__(self, key)\n", + " | # label = annotation[segment, track]\n", + " | \n", + " | __init__(self, uri=None, modality=None)\n", + " | \n", + " | __len__(self)\n", + " | Number of segments\n", + " | \n", + " | __mod__(self, translation)\n", + " | \n", + " | __ne__(self, other)\n", + " | \n", + " | __nonzero__(self)\n", + " | \n", + " | __setitem__(self, key, label)\n", + " | # annotation[segment, track] = label\n", + " | \n", + " | __str__(self)\n", + " | Human-friendly representation\n", + " | \n", + " | anonymize_labels(self, generator=u'string')\n", + " | Anonmyize labels\n", + " | \n", + " | Create a new annotation where labels are anonymized.\n", + " | \n", + " | Parameters\n", + " | ----------\n", + " | generator : {'string', 'int', iterator}, optional\n", + " | \n", + " | Returns\n", + " | -------\n", + " | anonymized : :class:`Annotation`\n", + " | New annotation with anonymized labels.\n", + " | \n", + " | anonymize_tracks(self, generator=u'string')\n", + " | Anonymize tracks\n", + " | \n", + " | Create a new annotation where each track has a unique label.\n", + " | \n", + " | Parameters\n", + " | ----------\n", + " | generator : {'string', 'int', iterator}, optional\n", + " | Default to 'string'.\n", + " | \n", + " | Returns\n", + " | -------\n", + " | anonymized : `Annotation`\n", + " | New annotation with anonymized tracks.\n", + " | \n", + " | argmax(self, segment=None, known_first=False)\n", + " | Get most frequent label\n", + " | \n", + " | \n", + " | Parameters\n", + " | ----------\n", + " | segment : Segment, optional\n", + " | Section of annotation where to look for the most frequent label.\n", + " | Defaults to whole annotation extent.\n", + " | known_first: bool, optional\n", + " | If True, artificially reduces the duration of intersection of\n", + " | `Unknown` labels so that 'known' labels are returned first.\n", + " | \n", + " | Returns\n", + " | -------\n", + " | label : any existing label or None\n", + " | Label with longest intersection\n", + " | \n", + " | Examples\n", + " | --------\n", + " | \n", + " | >>> annotation = Annotation(modality='speaker')\n", + " | >>> annotation[Segment(0, 10), 'speaker1'] = 'Alice'\n", + " | >>> annotation[Segment(8, 20), 'speaker1'] = 'Bob'\n", + " | >>> print \"%s is such a talker!\" % annotation.argmax()\n", + " | Bob is such a talker!\n", + " | >>> segment = Segment(22, 23)\n", + " | >>> if not annotation.argmax(segment):\n", + " | ... print \"No label intersecting %s\" % segment\n", + " | No label intersection [22 --> 23]\n", + " | \n", + " | chart(self, percent=False)\n", + " | Label chart based on their duration\n", + " | \n", + " | Parameters\n", + " | ----------\n", + " | percent : bool, optional\n", + " | Return total duration percentage (rather than raw duration)\n", + " | \n", + " | Returns\n", + " | -------\n", + " | chart : (label, duration) iterable\n", + " | Sorted from longest to shortest.\n", + " | \n", + " | co_iter(self, other)\n", + " | Parameters\n", + " | ----------\n", + " | other : Annotation\n", + " | \n", + " | Generates\n", + " | ---------\n", + " | (segment, track), (other_segment, other_track)\n", + " | \n", + " | copy(self)\n", + " | \n", + " | crop(self, other, mode=u'intersection')\n", + " | Crop annotation\n", + " | \n", + " | Parameters\n", + " | ----------\n", + " | other : `Segment` or `Timeline`\n", + " | \n", + " | mode : {'strict', 'loose', 'intersection'}\n", + " | In 'strict' mode, only segments fully included in focus coverage\n", + " | are kept. In 'loose' mode, any intersecting segment is kept\n", + " | unchanged. In 'intersection' mode, only intersecting segments are\n", + " | kept and replaced by their actual intersection with the focus.\n", + " | \n", + " | Returns\n", + " | -------\n", + " | cropped : Annotation\n", + " | \n", + " | Remarks\n", + " | -------\n", + " | In 'intersection' mode, the best is done to keep the track names\n", + " | unchanged. However, in some cases where two original segments are\n", + " | cropped into the same resulting segments, conflicting track names are\n", + " | modified to make sure no track is lost.\n", + " | \n", + " | empty(self)\n", + " | \n", + " | for_json(self)\n", + " | \n", + " | get_labels(self, segment, unknown=True, unique=True)\n", + " | Local set of labels\n", + " | \n", + " | Parameters\n", + " | ----------\n", + " | segment : Segment\n", + " | Segments to get label from.\n", + " | unknown : bool, optional\n", + " | When False, do not return Unknown instances\n", + " | When True, return any label (even Unknown instances)\n", + " | unique : bool, optional\n", + " | When False, return the list of (possibly repeated) labels.\n", + " | When True (default), return the set of labels\n", + " | Returns\n", + " | -------\n", + " | labels : set\n", + " | Set of labels for `segment` if it exists, empty set otherwise.\n", + " | \n", + " | Examples\n", + " | --------\n", + " | \n", + " | >>> annotation = Annotation()\n", + " | >>> segment = Segment(0, 2)\n", + " | >>> annotation[segment, 'speaker1'] = 'Bernard'\n", + " | >>> annotation[segment, 'speaker2'] = 'John'\n", + " | >>> print sorted(annotation.get_labels(segment))\n", + " | set(['Bernard', 'John'])\n", + " | >>> print annotation.get_labels(Segment(1, 2))\n", + " | set([])\n", + " | \n", + " | get_timeline(self)\n", + " | Get timeline made of annotated segments\n", + " | \n", + " | get_track_by_name(self, track)\n", + " | Get all tracks with given name\n", + " | \n", + " | Parameters\n", + " | ----------\n", + " | track : any valid track name\n", + " | Requested name track\n", + " | \n", + " | Returns\n", + " | -------\n", + " | tracks : list\n", + " | List of (segment, track) tuples\n", + " | \n", + " | get_tracks(self, segment)\n", + " | Set of tracks for query segment\n", + " | \n", + " | Parameters\n", + " | ----------\n", + " | segment : `Segment`\n", + " | Query segment\n", + " | \n", + " | Returns\n", + " | -------\n", + " | tracks : set\n", + " | Set of tracks for query segment\n", + " | \n", + " | has_track(self, segment, track)\n", + " | Check whether a given track exists\n", + " | \n", + " | Parameters\n", + " | ----------\n", + " | segment : `Segment`\n", + " | Query segment\n", + " | track :\n", + " | Query track\n", + " | \n", + " | Returns\n", + " | -------\n", + " | exists : bool\n", + " | True if track exists for segment\n", + " | \n", + " | itersegments(self)\n", + " | Segment iterator\n", + " | \n", + " | itertracks(self, label=False)\n", + " | \n", + " | label_coverage(self, label)\n", + " | Parameters\n", + " | ----------\n", + " | label :\n", + " | \n", + " | Returns\n", + " | -------\n", + " | \n", + " | label_duration(self, label)\n", + " | \n", + " | label_timeline(self, label)\n", + " | Get timeline for a given label\n", + " | \n", + " | Parameters\n", + " | ----------\n", + " | label :\n", + " | \n", + " | Returns\n", + " | -------\n", + " | timeline : :class:`Timeline`\n", + " | Timeline made of all segments annotated with `label`\n", + " | \n", + " | labels(self, unknown=True)\n", + " | List of labels\n", + " | \n", + " | Parameters\n", + " | ----------\n", + " | unknown : bool, optional\n", + " | When False, do not return Unknown instances\n", + " | When True, return any label (even Unknown instances)\n", + " | \n", + " | Returns\n", + " | -------\n", + " | labels : list\n", + " | Sorted list of labels\n", + " | \n", + " | new_track(self, segment, candidate=None, prefix=None)\n", + " | Track name generator\n", + " | \n", + " | Parameters\n", + " | ----------\n", + " | segment : Segment\n", + " | prefix : str, optional\n", + " | candidate : any valid track name\n", + " | \n", + " | Returns\n", + " | -------\n", + " | track : str\n", + " | New track name\n", + " | \n", + " | retrack(self)\n", + " | \n", + " | smooth(self, collar=0.0)\n", + " | Smooth annotation\n", + " | \n", + " | Create new annotation where contiguous tracks with same label are\n", + " | merged into one longer track.\n", + " | \n", + " | Parameters\n", + " | ----------\n", + " | collar : float\n", + " | If collar is positive, also merge tracks separated by less than\n", + " | collar duration.\n", + " | \n", + " | Returns\n", + " | -------\n", + " | annotation : Annotation\n", + " | New annotation where contiguous tracks with same label are merged\n", + " | into one long track.\n", + " | \n", + " | Remarks\n", + " | -------\n", + " | Track names are lost in the process.\n", + " | \n", + " | subset(self, labels, invert=False)\n", + " | Annotation subset\n", + " | \n", + " | Extract annotation subset based on labels\n", + " | \n", + " | Parameters\n", + " | ----------\n", + " | labels : iterable\n", + " | Label iterable.\n", + " | invert : bool, optional\n", + " | If invert is True, extract all but requested `labels`\n", + " | \n", + " | Returns\n", + " | -------\n", + " | subset : `Annotation`\n", + " | Annotation subset.\n", + " | \n", + " | translate(self, translation)\n", + " | Translate labels\n", + " | \n", + " | Parameters\n", + " | ----------\n", + " | translation: dict\n", + " | Label translation.\n", + " | Labels with no associated translation are kept unchanged.\n", + " | \n", + " | Returns\n", + " | -------\n", + " | translated : :class:`Annotation`\n", + " | New annotation with translated labels.\n", + " | \n", + " | update(self, annotation)\n", + " | Update existing annotations or create new ones\n", + " | \n", + " | Parameters\n", + " | ----------\n", + " | annotation : Annotation\n", + " | Updated (or new) annotations\n", + " | \n", + " | Returns\n", + " | -------\n", + " | self : Annotation\n", + " | Updated annotations.\n", + " | \n", + " | ----------------------------------------------------------------------\n", + " | Class methods defined here:\n", + " | \n", + " | from_df(cls, df, uri=None, modality=None) from __builtin__.type\n", + " | Parameters\n", + " | ----------\n", + " | df : DataFrame\n", + " | Must contain the following columns: 'segment', 'track' and 'label'\n", + " | uri : str, optional\n", + " | Resource identifier\n", + " | modality : str, optional\n", + " | Modality\n", + " | \n", + " | Returns\n", + " | -------\n", + " | \n", + " | from_json(cls, data) from __builtin__.type\n", + " | \n", + " | ----------------------------------------------------------------------\n", + " | Data descriptors defined here:\n", + " | \n", + " | __dict__\n", + " | dictionary for instance variables (if defined)\n", + " | \n", + " | __weakref__\n", + " | list of weak references to the object (if defined)\n", + " | \n", + " | uri\n", + " | Resource identifier\n", + "\n" + ] + } + ], + "source": [ + "help(Annotation)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.4" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/packages/core/notebook/pyannote.core.feature.ipynb b/packages/core/notebook/pyannote.core.feature.ipynb new file mode 100644 index 00000000..bcdbb697 --- /dev/null +++ b/packages/core/notebook/pyannote.core.feature.ipynb @@ -0,0 +1,287 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Populating the interactive namespace from numpy and matplotlib\n" + ] + } + ], + "source": [ + "%pylab inline" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# SlidingWindowFeature (`pyannote.core.feature.SlidingWindowFeature`)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "from pyannote.core import SlidingWindow, SlidingWindowFeature" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**SlidingWindowFeature** are used to manage feature vectors extracted on a sliding window (e.g. MFCC in audio processing)." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "import numpy as np\n", + "\n", + "# one 4-dimensional feature vector extracted every 100ms from a 200ms window\n", + "frame = SlidingWindow(start=0.0, step=0.100, duration=0.200)\n", + "\n", + "# random for illustration purposes\n", + "data = np.random.randn(100, 4)\n", + "\n", + "features = SlidingWindowFeature(data, frame)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Cropping" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You may use `crop` to extract a temporal subset:" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Help on method crop in module pyannote.core.feature:\n", + "\n", + "crop(self, focus, mode=u'loose', fixed=None) method of pyannote.core.feature.SlidingWindowFeature instance\n", + " Extract frames as numpy array\n", + " \n", + " Parameters\n", + " ----------\n", + " focus : Segment or Timeline\n", + " mode : {'loose', 'strict', 'center', 'fixed'}, optional\n", + " In 'strict' mode, only frames fully included in focus coverage are\n", + " returned. In 'loose' mode, any intersecting frames are returned. In\n", + " 'center' mode, first and last frames are chosen to be the positions\n", + " whose centers are the closest to the focus start and end times.\n", + " Defaults to 'loose'.\n", + " fixed : float, optional\n", + " When provided and mode is 'center', override focus duration to make\n", + " sure two `focus` with the same duration always result in the same\n", + " (fixed) number of frames being selected.\n", + " \n", + " Returns\n", + " -------\n", + " data : numpy array\n", + " (nSamples, nFeatures) numpy array\n", + " \n", + " See also\n", + " --------\n", + " SlidingWindow.crop\n", + "\n" + ] + } + ], + "source": [ + "help(features.crop)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[-0.170939 , 0.7268368 , -1.11357192, 0.9102115 ],\n", + " [ 0.75526988, 0.13631738, -1.12959046, 0.57945519],\n", + " [-1.63332126, -1.05239927, -2.80404685, -3.19025518],\n", + " [-1.2622323 , 0.80263563, 0.8912935 , 0.85251067],\n", + " [-0.58865284, -1.05005899, 0.5468816 , 1.03976293],\n", + " [ 2.99740924, 1.544513 , -2.18700361, -0.19051365],\n", + " [-1.16020413, 2.75010658, -1.63448261, 0.96354481],\n", + " [-1.09404058, -0.56915077, -0.73265453, -0.5412315 ],\n", + " [-3.83225883, 2.48916336, -0.475149 , -0.56418448],\n", + " [ 0.01583975, -1.41733235, -0.47454703, -1.18346613],\n", + " [ 0.4350982 , -0.61821957, 0.0458578 , -0.66109202],\n", + " [ 1.39603516, 1.00657646, 1.67931705, 0.01362444],\n", + " [ 0.95027176, -0.02961472, -0.71587331, -0.04884979]])" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from pyannote.core import Segment\n", + "\n", + "features.crop(Segment(2, 3))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Need help?" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You can always try the following... \n", + "Who knows? It might give you the information you are looking for!" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Help on class SlidingWindowFeature in module pyannote.core.feature:\n", + "\n", + "class SlidingWindowFeature(__builtin__.object)\n", + " | Periodic feature vectors\n", + " | \n", + " | Parameters\n", + " | ----------\n", + " | data : (nSamples, nFeatures) numpy array\n", + " | \n", + " | sliding_window : SlidingWindow\n", + " | \n", + " | Methods defined here:\n", + " | \n", + " | __getitem__(self, i)\n", + " | Get ith feature vector\n", + " | \n", + " | __init__(self, data, sliding_window)\n", + " | \n", + " | crop(self, focus, mode=u'loose', fixed=None)\n", + " | Extract frames as numpy array\n", + " | \n", + " | Parameters\n", + " | ----------\n", + " | focus : Segment or Timeline\n", + " | mode : {'loose', 'strict', 'center', 'fixed'}, optional\n", + " | In 'strict' mode, only frames fully included in focus coverage are\n", + " | returned. In 'loose' mode, any intersecting frames are returned. In\n", + " | 'center' mode, first and last frames are chosen to be the positions\n", + " | whose centers are the closest to the focus start and end times.\n", + " | Defaults to 'loose'.\n", + " | fixed : float, optional\n", + " | When provided and mode is 'center', override focus duration to make\n", + " | sure two `focus` with the same duration always result in the same\n", + " | (fixed) number of frames being selected.\n", + " | \n", + " | Returns\n", + " | -------\n", + " | data : numpy array\n", + " | (nSamples, nFeatures) numpy array\n", + " | \n", + " | See also\n", + " | --------\n", + " | SlidingWindow.crop\n", + " | \n", + " | getDimension(self)\n", + " | Dimension of feature vectors\n", + " | \n", + " | getExtent(self)\n", + " | \n", + " | getNumber(self)\n", + " | Number of feature vectors\n", + " | \n", + " | iterfeatures(self, window=False)\n", + " | Feature vector iterator\n", + " | \n", + " | Parameters\n", + " | ----------\n", + " | window : bool, optional\n", + " | When True, yield both feature vector and corresponding window.\n", + " | Default is to only yield feature vector\n", + " | \n", + " | ----------------------------------------------------------------------\n", + " | Data descriptors defined here:\n", + " | \n", + " | __dict__\n", + " | dictionary for instance variables (if defined)\n", + " | \n", + " | __weakref__\n", + " | list of weak references to the object (if defined)\n", + "\n" + ] + } + ], + "source": [ + "help(SlidingWindowFeature)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 2", + "language": "python", + "name": "python2" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.10" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/packages/core/notebook/pyannote.core.scores.ipynb b/packages/core/notebook/pyannote.core.scores.ipynb new file mode 100644 index 00000000..ecd99d87 --- /dev/null +++ b/packages/core/notebook/pyannote.core.scores.ipynb @@ -0,0 +1,175 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "collapsed": false, + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Populating the interactive namespace from numpy and matplotlib\n" + ] + } + ], + "source": [ + "%pylab inline" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Scores (`pyannote.core.scores.Scores`)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "from pyannote.core import Scores" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**`Scores`** instances are used to describe classification scores.\n", + "For instance, one can use a **`Scores`** to store the result of speaker identification approach applied on an episode of *The Big Bang Theory* TV series." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "scores = Scores(uri=\"TheBigBangTheory.Season01.Episode01\", modality=\"speaker\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "For instance, to represent a dialogue between Penny and Leonard, we could do the following:" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABIkAAACxCAYAAABA1O2LAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nwwAAAABJRU5ErkJggg==\n", + "text/plain": [ + "" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from pyannote.core import Segment\n", + "\n", + "scores[Segment(3, 5), \"_\", \"Penny\"] = 8\n", + "scores[Segment(3, 5), \"_\", \"Leonard\"] = 0.15\n", + "scores[Segment(3, 5), \"_\", \"Sheldon\"] = 0.05\n", + "scores[Segment(5.5, 7), \"_\", \"Penny\"] = 0.4\n", + "scores[Segment(5.5, 7), \"_\", \"Leonard\"] = 0.5\n", + "scores[Segment(5.5, 7), \"_\", \"Sheldon\"] = 0.1\n", + "scores[Segment(8, 10), \"_\", \"Penny\"] = 0.4\n", + "scores[Segment(8, 10), \"_\", \"Leonard\"] = 0.25\n", + "scores[Segment(8, 10), \"_\", \"Sheldon\"] = -12\n", + "scores" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABHMAAACxCAYAAABHuvHbAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", + "text/plain": [ + "" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "scores.to_annotation()" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXwAAAEhCAYAAAB89xvjAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nQmCC\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "from pyannote.core import notebook\n", + "\n", + "plt.subplot(211)\n", + "notebook(scores, time=False)\n", + "plt.subplot(212)\n", + "notebook(scores.to_annotation(), legend=False)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 2", + "language": "python", + "name": "python2" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.6" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/packages/core/notebook/pyannote.core.segment.ipynb b/packages/core/notebook/pyannote.core.segment.ipynb new file mode 100644 index 00000000..5da99cff --- /dev/null +++ b/packages/core/notebook/pyannote.core.segment.ipynb @@ -0,0 +1,957 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Populating the interactive namespace from numpy and matplotlib\n" + ] + } + ], + "source": [ + "%pylab inline\n", + "from pyannote.core import notebook" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Segment (`pyannote.core.segment.Segment`)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, + "outputs": [], + "source": [ + "from pyannote.core import Segment" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**`Segment`** instances are used to describe temporal fragments (e.g. of an audio file)." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# start time in seconds\n", + "s = 1.0\n", + "# end time in seconds\n", + "e = 9.0\n", + "segment = Segment(start=s, end=e)\n", + "segment" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**`Segment`** instances are nothing more than 2-tuples augmented with several useful methods and properties." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "from 1.0 to 9.0\n" + ] + } + ], + "source": [ + "start, end = segment\n", + "print(f\"from {start} to {end}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Segment [ 00:00:01.000 --> 00:00:09.000] ends at 9 seconds.\n", + "Its duration is 8 seconds.\n", + "Its middle stands as 5 seconds.\n" + ] + } + ], + "source": [ + "print(f\"Segment {segment} ends at {segment.end:g} seconds.\")\n", + "print(f\"Its duration is {segment.duration:g} seconds.\")\n", + "print(f\"Its middle stands as {segment.middle:g} seconds.\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Intersection" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Segment [ 00:00:01.000 --> 00:00:09.000] intersects other segment [ 00:00:04.000 --> 00:00:13.000].\n", + "Their intersection is [ 00:00:04.000 --> 00:00:09.000].\n" + ] + } + ], + "source": [ + "other_segment = Segment(4, 13)\n", + "if segment.intersects(other_segment):\n", + " print(f\"Segment {segment} intersects other segment {other_segment}.\")\n", + " intersection = segment & other_segment\n", + " print(f\"Their intersection is {intersection!s}.\")" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABG0AAABjCAYAAAAhK/2kAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAImUlEQVR4nO3da6hldRkG8OfNKUqtrMa0HOlE2EWii0xiCdEdu5BBX4qKor4EZReC6ALppxCSSiiKsDJIirCiCCrFor50ccZKSzPt6pilEV1Muvr2YW9xGB08M+4z67/2/H5w2Guts2d4Zng5e51nr/Xf1d0BAAAAYCz3mToAAAAAAHeltAEAAAAYkNIGAAAAYEBKGwAAAIABKW0AAAAABrTtQJ68ffv23tjY2KIoAAAAAIef3bt3/6m7j933+AGVNhsbG9m1a9fqUgEAAAAc5qrqt3d33O1RAAAAAANS2gAAAAAMSGkDAAAAMCClDQAAAMCAlDYAAAAAA1LaAAAAAAxIaQMAAAAwIKUNAAAAwICUNgAAAAADUtoAAAAADEhpAwAAADAgpQ0AAADAgJQ2AAAAAANS2gAAAAAMSGkDAAAAMCClDQAAAMCAlDYAAAAAA1LaAAAAAAxIaQMAAAAwIKUNAAAAwICUNgAAAAADUtoAAAAADEhpAwAAADAgpc0WOOecc6aOAAAwW86lAGChunvTT965c2fv2rVrC+Osh6rKgfy/AgBwJ+dSABxuqmp3d+/c97grbQAAAAAGtG3qAOuqqqaOAAAAAMyY0maLuKQXAODgePMLABbcHrUFzj777KkjAADMlnMpAFiwEDEAAADAhCxEDAAAADAjShsAAACAASltAAAAAAaktAEAAAAYkNIGAAAAYEBKGwAAAIABKW0AAAAABqS0AQAAABiQ0gYAAABgQEobAAAAgAEpbQAAAAAGpLQBAAAAGJDSBgAAAGBAShsAAACAASltAAAAAAaktAEAAAAYkNIGAAAAYEBKGwAAAIABKW0AAAAABqS0AQAAABiQ0gYAAABgQEobAAAAgAEpbQAAAAAGVN29+SdX/T3JtVsXh8PQ9iR/mjoEa8M8sWpmilUzU6yamWLVzBSrZJ4271Hdfey+B7cd4F9ybXfvXFEgSFXtMlOsinli1cwUq2amWDUzxaqZKVbJPN17bo8CAAAAGJDSBgAAAGBAB1rafGJLUnA4M1Osknli1cwUq2amWDUzxaqZKVbJPN1LB7QQMQAAAACHhtujAAAAAAaktAEAAAAY0KZKm6o6o6qurarrq+pdWx2K9VZVJ1bVt6vq6qr6WVW9depMrIeqOqKqflRVX5s6C/NXVcdU1cVV9fOquqaqnj51Juarqt6+fM37aVV9rqruP3Um5qeqPlVVN1fVT/c69tCqurSqrls+PmTKjMzHfubpA8vXvSur6stVdcyUGZmXu5upvb73jqrqqto+RbY5u8fSpqqOSPLRJC9McnKSV1bVyVsdjLX23yTv6O6Tk5yW5E1mihV5a5Jrpg7B2jg/yTe6+/FJnhyzxUGqqhOSvCXJzu5+YpIjkrxi2lTM1IVJztjn2LuSXNbdJyW5bLkPm3Fh7jpPlyZ5Ync/Kckvkrz7UIdi1i7MXWcqVXVikhck+d2hDrQONnOlzalJru/uX3X3v5N8PsmZWxuLddbdN3X3Fcvtv2fxi9AJ06Zi7qpqR5IXJ7lg6izMX1U9OMkzk3wySbr73939l2lTMXPbkjygqrYlOTLJ7yfOwwx193eT/Hmfw2cm+cxy+zNJXnZIQzFbdzdP3X1Jd/93ufv9JDsOeTBmaz8/o5LkQ0nemcSnIB2EzZQ2JyS5Ya/9PfELNitSVRtJnprkB9MmYQ18OIsXg9unDsJaeHSSW5J8ennL3QVVddTUoZin7r4xyXlZvMN4U5K/dvcl06ZijRzX3Tctt/+Q5Lgpw7BWXp/k61OHYN6q6swkN3b3T6bOMlcWImYyVXV0ki8meVt3/23qPMxXVb0kyc3dvXvqLKyNbUlOSfKx7n5qkn/ELQccpOUaI2dmUQY+MslRVfXqaVOxjrq7451sVqCq3pvFkgYXTZ2F+aqqI5O8J8n7ps4yZ5spbW5McuJe+zuWx+CgVdV9syhsLuruL02dh9k7PclLq+o3WdzC+Zyq+uy0kZi5PUn2dPcdVwFenEWJAwfjeUl+3d23dPd/knwpyTMmzsT6+GNVPSJJlo83T5yHmauq1yV5SZJXLYtAOFiPyeINi58sz9N3JLmiqo6fNNXMbKa0uTzJSVX16Kq6XxYL5311a2Oxzqqqslgn4pru/uDUeZi/7n53d+/o7o0sfkZ9q7u9i81B6+4/JLmhqh63PPTcJFdPGIl5+12S06rqyOVr4HNjYWtW56tJXrvcfm2Sr0yYhZmrqjOyuN38pd1929R5mLfuvqq7H97dG8vz9D1JTlmeZ7FJ91jaLBeienOSb2ZxgvGF7v7ZVgdjrZ2e5DVZXA3x4+XXi6YOBbCPs5JcVFVXJnlKkvdPnIeZWl6xdXGSK5JclcX51ycmDcUsVdXnknwvyeOqak9VvSHJuUmeX1XXZXFV17lTZmQ+9jNPH0nywCSXLs/RPz5pSGZlPzPFvVSueAMAAAAYj4WIAQAAAAaktAEAAAAYkNIGAAAAYEBKGwAAAIABKW0AAAAABrRt6gAAAPekqh6W5LLl7vFJ/pfkluX+bd39jEmCAQBsIR/5DQDMSlWdk+TW7j5v6iwAAFvJ7VEAwKxV1a3Lx2dV1Xeq6itV9auqOreqXlVVP6yqq6rqMcvnHVtVX6yqy5dfp0/7LwAAuHtKGwBgnTw5yRuTPCHJa5I8trtPTXJBkrOWzzk/yYe6+2lJXr78HgDAcKxpAwCsk8u7+6YkqapfJrlkefyqJM9ebj8vyclVdcefeVBVHd3dtx7SpAAA90BpAwCsk3/ttX37Xvu3587znvskOa27/3kogwEAHCi3RwEAh5tLcuetUqmqp0yYBQBgv5Q2AMDh5i1JdlbVlVV1dRZr4AAADMdHfgMAAAAMyJU2AAAAAANS2gAAAAAMSGkDAAAAMCClDQAAAMCAlDYAAAAAA1LaAAAAAAxIaQMAAAAwoP8D+i7aL22nSOwAAAAASUVORK5CYII=\n", + "text/plain": [ + "" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "notebook.crop = Segment(0, 15)\n", + "segment" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABG0AAABjCAYAAAAhK/2kAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAImklEQVR4nO3da6hldRkG8OfNKUq7N2blSEeim0Q3JrGE6GJhFzLoS1FR1JegO0F0gfRTCEUXKIqwMkiMsEIJKsWivnRxxkpLs/tlzNKILhZdzLcPe0fD6OCZ4z5n/dee3w8Oe6119hmegZez13n2Wv9d3R0AAAAAxnKXqQMAAAAAcFtKGwAAAIABKW0AAAAABqS0AQAAABiQ0gYAAABgQLuO5Mm7d+/ujY2NbYoCAAAAcPTZv3//H7r7+EOPH1Fps7GxkX379q0uFQAAAMBRrqp+dXvH3R4FAAAAMCClDQAAAMCAlDYAAAAAA1LaAAAAAAxIaQMAAAAwIKUNAAAAwICUNgAAAAADUtoAAAAADEhpAwAAADAgpQ0AAADAgJQ2AAAAAANS2gAAAAAMSGkDAAAAMCClDQAAAMCAlDYAAAAAA1LaAAAAAAxIaQMAAAAwIKUNAAAAwICUNgAAAAADUtoAAAAADEhpAwAAADAgpQ0AAADAgJQ2AAAAAANS2gBr45xzzpk6AgAARwHnneyU6u5NP3nv3r29b9++bYwDsHVVlSP5nQYAAFvhvJNVq6r93b330OOutAEAAAAY0K6pAwCsUlVNHQEAAGAllDbAWnGZKgAA280bhewUt0cBa+Pss8+eOgIAAEcB553sFAsRAwAAAEzIQsQAAAAAM6K0AQAAABiQ0gYAAABgQEobAAAAgAEpbQAAAAAGpLQBAAAAGJDSBgAAAGBAShsAAACAASltAAAAAAaktAEAAAAYkNIGAAAAYEBKGwAAAIABKW0AAAAABqS0AQAAABiQ0gYAAABgQEobAAAAgAEpbQAAAAAGpLQBAAAAGJDSBgAAAGBAShsAAACAASltAAAAAAaktAEAAAAYkNIGAAAAYEDV3Zt/ctVfk1y3fXE4Cu1O8oepQ7A2zBOrZqZYNTPFqpkpVs1MsUrmafMe2t3HH3pw1xH+I9d1994VBYJU1T4zxaqYJ1bNTLFqZopVM1OsmplilczTnef2KAAAAIABKW0AAAAABnSkpc3HtiUFRzMzxSqZJ1bNTLFqZopVM1OsmplilczTnXRECxEDAAAAsDPcHgUAAAAwIKUNAAAAwIA2VdpU1ZlVdV1V/bSq3rbdoVhvVXVSVX2tqq6pqh9W1RunzsR6qKpjquq7VfXFqbMwf1V136q6qKp+VFXXVtWTp87EfFXVm5eveT+oqgur6u5TZ2J+quoTVXVjVf3goGP3r6rLquony8f7TZmR+TjMPL1n+bp3VVV9oaruO2VG5uX2Zuqg772lqrqqdk+Rbc7usLSpqmOSfDjJc5KckuQlVXXKdgdjrd2S5C3dfUqS05K81kyxIm9Mcu3UIVgbH0zy5e5+VJLHxWyxRVV1YpI3JNnb3Y9JckySF0+bipk6P8mZhxx7W5LLu/vhSS5f7sNmnJ/bztNlSR7T3Y9N8uMkb9/pUMza+bntTKWqTkry7CS/3ulA62AzV9qcmuSn3f3z7v5Xks8kOWt7Y7HOuvuG7r5yuf3XLP4QOnHaVMxdVe1J8rwk502dhfmrqvskeWqSjydJd/+ru/80bSpmbleSe1TVriTHJvntxHmYoe7+RpI/HnL4rCSfWm5/KskLdzQUs3V789Tdl3b3LcvdbyXZs+PBmK3D/I5KkvcneWsSn4K0BZspbU5M8puD9g/EH9isSFVtJHlCkm9Pm4Q18IEsXgxunToIa+HkJDcl+eTylrvzquq4qUMxT919fZL3ZvEO4w1J/tzdl06bijVyQnffsNz+XZITpgzDWnlVki9NHYJ5q6qzklzf3d+fOstcWYiYyVTVPZN8LsmbuvsvU+dhvqrq+Ulu7O79U2dhbexK8sQkH+nuJyT5W9xywBYt1xg5K4sy8CFJjquql02binXU3R3vZLMCVfXOLJY0uGDqLMxXVR2b5B1J3jV1ljnbTGlzfZKTDtrfszwGW1ZVd82isLmguz8/dR5m7/QkL6iqX2ZxC+czqurT00Zi5g4kOdDd/7sK8KIsShzYijOS/KK7b+rufyf5fJKnTJyJ9fH7qnpwkiwfb5w4DzNXVa9M8vwkL10WgbBVD8viDYvvL8/T9yS5sqoeNGmqmdlMaXNFkodX1clVdbcsFs67ZHtjsc6qqrJYJ+La7n7f1HmYv+5+e3fv6e6NLH5HfbW7vYvNlnX375L8pqoeuTz0zCTXTBiJeft1ktOq6tjla+AzY2FrVueSJK9Ybr8iycUTZmHmqurMLG43f0F3/33qPMxbd1/d3Q/s7o3lefqBJE9cnmexSXdY2iwXonpdkq9kcYLx2e7+4XYHY62dnuTlWVwN8b3l13OnDgVwiNcnuaCqrkry+CTvnjgPM7W8YuuiJFcmuTqL86+PTRqKWaqqC5N8M8kjq+pAVb06yblJnlVVP8niqq5zp8zIfBxmnj6U5F5JLlueo3900pDMymFmijupXPEGAAAAMB4LEQMAAAAMSGkDAAAAMCClDQAAAMCAlDYAAAAAA1LaAAAAAAxo19QBAADuSFU9IMnly90HJflPkpuW+3/v7qdMEgwAYBv5yG8AYFaq6pwkN3f3e6fOAgCwndweBQDMWlXdvHx8WlV9vaourqqfV9W5VfXSqvpOVV1dVQ9bPu/4qvpcVV2x/Dp92v8BAMDtU9oAAOvkcUlek+TRSV6e5BHdfWqS85K8fvmcDyZ5f3c/KcmLlt8DABiONW0AgHVyRXffkCRV9bMkly6PX53k6cvtM5KcUlX/+5l7V9U9u/vmHU0KAHAHlDYAwDr550Hbtx60f2v+f95zlySndfc/djIYAMCRcnsUAHC0uTT/v1UqVfX4CbMAAByW0gYAONq8Icneqrqqqq7JYg0cAIDh+MhvAAAAgAG50gYAAABgQEobAAAAgAEpbQAAAAAGpLQBAAAAGJDSBgAAAGBAShsAAACAASltAAAAAAb0X7Ut2i96zfc6AAAAAElFTkSuQmCC\n", + "text/plain": [ + "" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "other_segment" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "segment & other_segment" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Those two segments do not intersect.\n" + ] + } + ], + "source": [ + "other_segment = Segment(13, 20)\n", + "if not (segment & other_segment):\n", + " print(\"Those two segments do not intersect.\")" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "notebook.crop = Segment(0, 30)\n", + "segment" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABHIAAABjCAYAAAD3jifBAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nQmCC\n", + "text/plain": [ + "" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "other_segment" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Inclusion" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[ 00:00:05.000 --> 00:00:06.000] in included in [ 00:00:01.000 --> 00:00:09.000]\n" + ] + } + ], + "source": [ + "other_segment = Segment(5, 6)\n", + "if other_segment in segment:\n", + " print(f\"{other_segment} in included in {segment}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[ 00:00:01.000 --> 00:00:09.000] does not contain time 23.000000\n" + ] + } + ], + "source": [ + "t = 23.0\n", + "if not segment.overlaps(t):\n", + " print(f\"{segment} does not contain time {t:f}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Other operations" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Union of [ 00:00:01.000 --> 00:00:09.000] and [ 00:00:10.000 --> 00:00:30.000] is [ 00:00:01.000 --> 00:00:30.000]\n" + ] + } + ], + "source": [ + "other_segment = Segment(10, 30)\n", + "print(f\"Union of {segment} and {other_segment} is {segment | other_segment}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Gap between [ 00:00:01.000 --> 00:00:09.000] and [ 00:00:14.000 --> 00:00:15.000] is [ 00:00:09.000 --> 00:00:14.000]\n" + ] + } + ], + "source": [ + "other_segment = Segment(14, 15)\n", + "print(f\"Gap between {segment} and {other_segment} is {segment ^ other_segment}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# SlidingWindow (`pyannote.core.segment.SlidingWindow`)" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [], + "source": [ + "from pyannote.core import SlidingWindow, Timeline" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Iteration" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + ", , , , , , , , , ])>" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "notebook.crop = Segment(0, 10)\n", + "window = SlidingWindow(start=0.0, step=1.1, duration=2.0, end=10.0)\n", + "Timeline(window)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Cropping" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Given an interval, `.crop` can be used to return every position of the sliding window within this interval. " + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "interval = Segment(3.0, 7.5)\n", + "interval" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "`strict` mode only returns fully contained positions." + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + ", , ])>" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "indices = window.crop(interval, mode=\"strict\")\n", + "Timeline(window[i] for i in indices)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "`loose` mode returns any intersecting position." + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + ", , , , , ])>" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "indices = window.crop(interval, mode=\"loose\")\n", + "Timeline(window[i] for i in indices)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "`center` mode centers first and last position on interval boundaries." + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + ", , , , ])>" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "indices = window.crop(interval, mode=\"center\")\n", + "Timeline(window[i] for i in indices)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Need help?" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You can always try the following... \n", + "Who knows? It might give you the information you are looking for!" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Help on class Segment in module pyannote.core.segment:\n", + "\n", + "class Segment(Segment)\n", + " | Temporal interval defined by its `start` and `end` times.\n", + " | \n", + " | Multiple segment operators are available -- including intersection (&),\n", + " | inclusion (in), emptiness test, start/end time shifting (+, -, >>, <<).\n", + " | They are illustrated in **Examples** section.\n", + " | \n", + " | Comparison of two segments is also available (==, !=, <, <=, >, >=).\n", + " | Two segments are equal iff they have identical start and end times.\n", + " | Segment S is smaller than segment T iff S.start < T.start or if they have\n", + " | the same start time and S.end < T.start.\n", + " | \n", + " | Parameters\n", + " | ----------\n", + " | start, end : float\n", + " | `start` and `end` times, in seconds.\n", + " | \n", + " | Returns\n", + " | -------\n", + " | segment : Segment\n", + " | New segment with `start` and `end` times.\n", + " | \n", + " | Examples\n", + " | --------\n", + " | Create a new temporal interval between 00:13.000 and 00:37.000.\n", + " | \n", + " | >>> segment = Segment(start=13., end=37)\n", + " | >>> print segment\n", + " | [13.000 --> 37.000]\n", + " | \n", + " | Inclusion, intersection, union & gap\n", + " | \n", + " | >>> s1 = Segment(1, 2)\n", + " | >>> s2 = Segment(0, 3)\n", + " | >>> if s1 in s2:\n", + " | ... print \"Segment %s is included in segment %s.\" % (s1, s2)\n", + " | Segment [1.000 --> 2.000] is included in segment [0.000 --> 3.000].\n", + " | >>> s3 = Segment(2, 5)\n", + " | >>> print s1 & s3\n", + " | ∅\n", + " | >>> print s2 & s3\n", + " | [2.000 --> 3.000]\n", + " | >>> print s2 | s3\n", + " | [0.000 --> 5.000]\n", + " | >>> print s1 ^ Segment(5, 7)\n", + " | [2.000 --> 5.000]\n", + " | \n", + " | Test whether segment is empty or not.\n", + " | \n", + " | >>> if not Segment(10, 10):\n", + " | ... print \"Segment is empty.\"\n", + " | Segment is empty.\n", + " | \n", + " | Comparison\n", + " | \n", + " | >>> s1 = Segment(1, 3)\n", + " | >>> s2 = Segment(1, 3)\n", + " | >>> s3 = Segment(2, 6)\n", + " | >>> s4 = Segment(1, 2)\n", + " | >>> for s in sorted([s1, s2, s3, s4]):\n", + " | ... print s\n", + " | [1.000 --> 2.000]\n", + " | [1.000 --> 3.000]\n", + " | [1.000 --> 3.000]\n", + " | [2.000 --> 6.000]\n", + " | \n", + " | Method resolution order:\n", + " | Segment\n", + " | Segment\n", + " | __builtin__.tuple\n", + " | __builtin__.object\n", + " | \n", + " | Methods defined here:\n", + " | \n", + " | __and__(self, other)\n", + " | Use the expression 'segment & other'\n", + " | \n", + " | Returns\n", + " | -------\n", + " | segment : Segment\n", + " | Intersection of the two segments\n", + " | \n", + " | __bool__(self)\n", + " | Use the expression 'if segment'\n", + " | \n", + " | Returns\n", + " | -------\n", + " | valid : bool\n", + " | False is segment is empty, True otherwise.\n", + " | \n", + " | __contains__(self, other)\n", + " | Use the expression 'other in segment'\n", + " | \n", + " | Returns\n", + " | -------\n", + " | contains : bool\n", + " | True if other segment is fully included, False otherwise\n", + " | \n", + " | __iter__(self)\n", + " | Makes sure tuple(segment) is a tuple of float\n", + " | \n", + " | __nonzero__(self)\n", + " | \n", + " | __or__(self, other)\n", + " | Use the expression 'segment | other'\n", + " | \n", + " | Returns\n", + " | -------\n", + " | segment : Segment\n", + " | Shortest segment that contains both segments\n", + " | \n", + " | __repr__(self)\n", + " | \n", + " | __str__(self)\n", + " | Use the expression str(segment)\n", + " | \n", + " | __xor__(self, other)\n", + " | Use the expression 'segment ^ other'\n", + " | \n", + " | Returns\n", + " | -------\n", + " | segment : Segment\n", + " | Gap between the two segments\n", + " | \n", + " | _get_duration(self)\n", + " | \n", + " | _get_middle(self)\n", + " | \n", + " | _pretty(self, seconds)\n", + " | \n", + " | _repr_png_(self)\n", + " | \n", + " | copy(self)\n", + " | Duplicate segment.\n", + " | \n", + " | for_json(self)\n", + " | \n", + " | intersects(self, other)\n", + " | Check whether two segments intersect each other\n", + " | \n", + " | Parameters\n", + " | ----------\n", + " | other : Segment\n", + " | Other segment\n", + " | \n", + " | Returns\n", + " | -------\n", + " | intersects : bool\n", + " | True if segments intersect, False otherwise\n", + " | \n", + " | overlaps(self, t)\n", + " | \n", + " | pretty(self)\n", + " | Human-readable representation of segments\n", + " | \n", + " | ----------------------------------------------------------------------\n", + " | Class methods defined here:\n", + " | \n", + " | from_json(cls, data) from __builtin__.type\n", + " | \n", + " | ----------------------------------------------------------------------\n", + " | Static methods defined here:\n", + " | \n", + " | __new__(cls, start=0.0, end=0.0)\n", + " | \n", + " | ----------------------------------------------------------------------\n", + " | Data descriptors defined here:\n", + " | \n", + " | __dict__\n", + " | dictionary for instance variables (if defined)\n", + " | \n", + " | duration\n", + " | \n", + " | middle\n", + " | \n", + " | ----------------------------------------------------------------------\n", + " | Methods inherited from Segment:\n", + " | \n", + " | __getnewargs__(self)\n", + " | Return self as a plain tuple. Used by copy and pickle.\n", + " | \n", + " | __getstate__(self)\n", + " | Exclude the OrderedDict from pickling\n", + " | \n", + " | _asdict(self)\n", + " | Return a new OrderedDict which maps field names to their values\n", + " | \n", + " | _replace(_self, **kwds)\n", + " | Return a new Segment object replacing specified fields with new values\n", + " | \n", + " | ----------------------------------------------------------------------\n", + " | Class methods inherited from Segment:\n", + " | \n", + " | _make(cls, iterable, new=, len=) from __builtin__.type\n", + " | Make a new Segment object from a sequence or iterable\n", + " | \n", + " | ----------------------------------------------------------------------\n", + " | Data descriptors inherited from Segment:\n", + " | \n", + " | end\n", + " | Alias for field number 1\n", + " | \n", + " | start\n", + " | Alias for field number 0\n", + " | \n", + " | ----------------------------------------------------------------------\n", + " | Data and other attributes inherited from Segment:\n", + " | \n", + " | _fields = ('start', 'end')\n", + " | \n", + " | ----------------------------------------------------------------------\n", + " | Methods inherited from __builtin__.tuple:\n", + " | \n", + " | __add__(...)\n", + " | x.__add__(y) <==> x+y\n", + " | \n", + " | __eq__(...)\n", + " | x.__eq__(y) <==> x==y\n", + " | \n", + " | __ge__(...)\n", + " | x.__ge__(y) <==> x>=y\n", + " | \n", + " | __getattribute__(...)\n", + " | x.__getattribute__('name') <==> x.name\n", + " | \n", + " | __getitem__(...)\n", + " | x.__getitem__(y) <==> x[y]\n", + " | \n", + " | __getslice__(...)\n", + " | x.__getslice__(i, j) <==> x[i:j]\n", + " | \n", + " | Use of negative indices is not supported.\n", + " | \n", + " | __gt__(...)\n", + " | x.__gt__(y) <==> x>y\n", + " | \n", + " | __hash__(...)\n", + " | x.__hash__() <==> hash(x)\n", + " | \n", + " | __le__(...)\n", + " | x.__le__(y) <==> x<=y\n", + " | \n", + " | __len__(...)\n", + " | x.__len__() <==> len(x)\n", + " | \n", + " | __lt__(...)\n", + " | x.__lt__(y) <==> x x*n\n", + " | \n", + " | __ne__(...)\n", + " | x.__ne__(y) <==> x!=y\n", + " | \n", + " | __rmul__(...)\n", + " | x.__rmul__(n) <==> n*x\n", + " | \n", + " | count(...)\n", + " | T.count(value) -> integer -- return number of occurrences of value\n", + " | \n", + " | index(...)\n", + " | T.index(value, [start, [stop]]) -> integer -- return first index of value.\n", + " | Raises ValueError if the value is not present.\n", + "\n" + ] + } + ], + "source": [ + "help(Segment)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.4" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/packages/core/notebook/pyannote.core.timeline.ipynb b/packages/core/notebook/pyannote.core.timeline.ipynb new file mode 100644 index 00000000..7e3ee7e4 --- /dev/null +++ b/packages/core/notebook/pyannote.core.timeline.ipynb @@ -0,0 +1,1036 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Populating the interactive namespace from numpy and matplotlib\n" + ] + } + ], + "source": [ + "%pylab inline\n", + "from pyannote.core import notebook" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Timeline (`pyannote.core.timeline.Timeline`)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, + "outputs": [], + "source": [ + "from pyannote.core import Timeline" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**`Timeline`** instances are used to describe sets of temporal fragments (e.g. of an audio file). \n", + "One can optionally store an identifier of the associated multimedia document using **`uri`** keyword argument. " + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, + "outputs": [], + "source": [ + "timeline = Timeline(uri=\"MyAudioFile\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Temporal fragments can be added to the timeline in any order and may be overlapping." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + ", , , , , ])>" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from pyannote.core import Segment\n", + "\n", + "timeline.add(Segment(6, 8))\n", + "timeline.add(Segment(0.5, 3))\n", + "timeline.add(Segment(8.5, 10))\n", + "timeline.add(Segment(1, 4))\n", + "timeline.add(Segment(5, 7))\n", + "timeline.add(Segment(7, 8))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "They are automatically sorted internally (by start time first)." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[ 00:00:00.500 --> 00:00:03.000]\n", + "[ 00:00:01.000 --> 00:00:04.000]\n", + "[ 00:00:05.000 --> 00:00:07.000]\n", + "[ 00:00:06.000 --> 00:00:08.000]\n", + "[ 00:00:07.000 --> 00:00:08.000]\n", + "[ 00:00:08.500 --> 00:00:10.000]\n" + ] + } + ], + "source": [ + "for segment in timeline:\n", + " print(segment)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Timeline contains 6 segments\n", + "The second segment of timeline is [ 00:00:01.000 --> 00:00:04.000]\n" + ] + } + ], + "source": [ + "print(f\"Timeline contains {len(timeline)} segments\")\n", + "print(f\"The second segment of timeline is {timeline[1]!s}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "One can visualize **`Timeline`** instances in IPython Notebook." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + ", , , , , ])>" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "timeline" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Coverage, extent and gaps" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The **extent** of a timeline is the segment of minimum duration that contains every segments of the timeline." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABHAAAABjCAYAAADze/f8AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nxUld8fURQQAAAABJRU5ErkJggg==\n", + "text/plain": [ + "" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "timeline.extent()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The **coverage** of a timeline is the timeline with the minimum number of segments with exactly the same time span as the original timeline." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABHAAAABjCAYAAADze/f8AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", + "text/plain": [ + ", , ])>" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "timeline.support()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "One can also retrieve **gaps** in a timeline." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABHAAAABjCAYAAADze/f8AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nAAAAgMEpcAAAAAAGp8ABAAAAGNx/ABuueExuN2t9AAAAAElFTkSuQmCC\n", + "text/plain": [ + ", ])>" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "timeline.gaps()" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABHAAAABjCAYAAADze/f8AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nAAAAgMEpcAAAAAAGp8ABAAAAGNx/ABuueExuN2t9AAAAAElFTkSuQmCC\n", + "text/plain": [ + ", , , ])>" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "timeline.gaps(focus=Segment(0, 10.5))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Cropping" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Using the **crop** method, it is possible to select a subpart of timeline." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABHAAAABjCAYAAADze/f8AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nSUVORK5CYII=\n", + "text/plain": [ + "" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "selection = Segment(3, 7)\n", + "selection" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABHAAAABjCAYAAADze/f8AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", + "text/plain": [ + ", , , , , ])>" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "timeline" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In **intersection** mode, segments are cut in half if needed." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABHAAAABjCAYAAADze/f8AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n4BQ4AAAAAINT4AAAAAAM7l8sx5tFBc2AZwAAAABJRU5ErkJggg==\n", + "text/plain": [ + ", , ])>" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "timeline.crop(selection, mode=\"intersection\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In **strict** mode, only segments fully included in selection are kept." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABHAAAABjCAYAAADze/f8AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nRU5ErkJggg==\n", + "text/plain": [ + "])>" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "timeline.crop(selection, mode=\"strict\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In **loose** mode, any segment with a non-empty intersection is kept unchanged even though it starts before or end after the selection." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABHAAAABjCAYAAADze/f8AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nAAanwAEAAAAYnAIHAAAAYHD/BjcNm0UiEWeNAAAAAElFTkSuQmCC\n", + "text/plain": [ + ", , ])>" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "timeline.crop(selection, mode=\"loose\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Union of timeline" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The **update** (in place) and **union** (copy) methods can be used to combine two timelines." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + ", , ])>" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "notebook.crop = Segment(0, 6)\n", + "first_timeline = Timeline([Segment(0, 1), Segment(2, 3), Segment(4, 5)])\n", + "first_timeline" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "])>" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "second_timeline = Timeline([Segment(1.5, 4.5)])\n", + "second_timeline" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + ", , , ])>" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "new_timeline = first_timeline.union(second_timeline)\n", + "new_timeline" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Intersection of timelines" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + ", ])>" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "second_timeline.crop(first_timeline)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**co_iter** method allow to iterator over pairs of intersecting segments." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[ 00:00:02.000 --> 00:00:03.000] [ 00:00:01.500 --> 00:00:04.500]\n", + "[ 00:00:04.000 --> 00:00:05.000] [ 00:00:01.500 --> 00:00:04.500]\n" + ] + } + ], + "source": [ + "for s_first, s_second in first_timeline.co_iter(second_timeline):\n", + " print(s_first, s_second)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Need help?" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You can always try the following... \n", + "Who knows? It might give you the information you are looking for!" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": { + "collapsed": false, + "jupyter": { + "outputs_hidden": false + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Help on class Timeline in module pyannote.core.timeline:\n", + "\n", + "class Timeline(__builtin__.object)\n", + " | Ordered set of segments.\n", + " | \n", + " | A timeline can be seen as an ordered set of non-empty segments (Segment).\n", + " | Segments can overlap -- though adding an already exisiting segment to a\n", + " | timeline does nothing.\n", + " | \n", + " | Parameters\n", + " | ----------\n", + " | segments : Segment iterator, optional\n", + " | initial set of segments\n", + " | uri : string, optional\n", + " | name of segmented resource\n", + " | \n", + " | Returns\n", + " | -------\n", + " | timeline : Timeline\n", + " | New timeline\n", + " | \n", + " | Examples\n", + " | --------\n", + " | Create a new empty timeline\n", + " | \n", + " | >>> timeline = Timeline()\n", + " | >>> if not timeline:\n", + " | ... print \"Timeline is empty.\"\n", + " | Timeline is empty.\n", + " | \n", + " | Add one segment (+=)\n", + " | \n", + " | >>> segment = Segment(0, 1)\n", + " | >>> timeline.add(segment)\n", + " | >>> if len(timeline) == 1:\n", + " | ... print \"Timeline contains only one segment.\"\n", + " | Timeline contains only one segment.\n", + " | \n", + " | Add all segments from another timeline\n", + " | \n", + " | >>> other_timeline = Timeline([Segment(0.5, 3), Segment(6, 8)])\n", + " | >>> timeline.update(other_timeline)\n", + " | \n", + " | Get timeline extent, coverage & duration\n", + " | \n", + " | >>> extent = timeline.extent()\n", + " | >>> print extent\n", + " | [0 --> 8]\n", + " | >>> coverage = timeline.support()\n", + " | >>> print coverage\n", + " | [\n", + " | [0 --> 3]\n", + " | [6 --> 8]\n", + " | ]\n", + " | >>> duration = timeline.duration()\n", + " | >>> print \"Timeline covers a total of %g seconds.\" % duration\n", + " | Timeline covers a total of 5 seconds.\n", + " | \n", + " | Iterate over (sorted) timeline segments\n", + " | \n", + " | >>> for segment in timeline:\n", + " | ... print segment\n", + " | [0 --> 1]\n", + " | [0.5 --> 3]\n", + " | [6 --> 8]\n", + " | \n", + " | Segmentation\n", + " | \n", + " | >>> segmentation = timeline.segmentation()\n", + " | >>> print segmentation\n", + " | [\n", + " | [0 --> 0.5]\n", + " | [0.5 --> 1]\n", + " | [1 --> 3]\n", + " | [6 --> 8]\n", + " | ]\n", + " | \n", + " | Gaps\n", + " | \n", + " | >>> timeline = timeline.copy()\n", + " | >>> print timeline\n", + " | [\n", + " | [0 --> 1]\n", + " | [0.5 --> 3]\n", + " | [6 --> 8]\n", + " | ]\n", + " | >>> print timeline.gaps()\n", + " | [\n", + " | [3 --> 6]\n", + " | ]\n", + " | >>> segment = Segment(0, 10)\n", + " | >>> print timeline.gaps(segment)\n", + " | [\n", + " | [3 --> 6]\n", + " | [8 --> 10]\n", + " | ]\n", + " | \n", + " | Methods defined here:\n", + " | \n", + " | __bool__(self)\n", + " | \n", + " | __contains__(self, included)\n", + " | Inclusion\n", + " | \n", + " | Use expression 'segment in timeline' or 'other_timeline in timeline'\n", + " | \n", + " | Parameters\n", + " | ----------\n", + " | included : `Segment` or `Timeline`\n", + " | \n", + " | Returns\n", + " | -------\n", + " | contains : bool\n", + " | True if every segment in `included` exists in timeline,\n", + " | False otherwise\n", + " | \n", + " | __eq__(self, other)\n", + " | \n", + " | __getitem__(self, k)\n", + " | Returns kth segment\n", + " | \n", + " | __init__(self, segments=None, uri=None)\n", + " | \n", + " | __iter__(self)\n", + " | \n", + " | __len__(self)\n", + " | \n", + " | __ne__(self, other)\n", + " | \n", + " | __nonzero__(self)\n", + " | \n", + " | __repr__(self)\n", + " | \n", + " | __str__(self)\n", + " | Human-friendly representation\n", + " | \n", + " | add(self, segment)\n", + " | Add segment\n", + " | \n", + " | co_iter(self, other)\n", + " | \n", + " | copy(self, segment_func=None)\n", + " | Duplicate timeline.\n", + " | \n", + " | If segment_func is provided, apply it to each segment first.\n", + " | \n", + " | Parameters\n", + " | ----------\n", + " | segment_func : function\n", + " | \n", + " | Returns\n", + " | -------\n", + " | timeline : Timeline\n", + " | A (possibly modified) copy of the timeline\n", + " | \n", + " | Examples\n", + " | --------\n", + " | \n", + " | >>> timeline = Timeline(uri=\"MyVideo.avi\")\n", + " | >>> timeline += [Segment(0, 1), Segment(2, 3)]\n", + " | >>> cp = timeline.copy()\n", + " | >>> print cp.uri\n", + " | MyVideo.avi\n", + " | >>> print cp\n", + " | [\n", + " | [0 --> 1]\n", + " | [2 --> 3]\n", + " | ]\n", + " | \n", + " | coverage(self)\n", + " | Timeline coverage\n", + " | \n", + " | The coverage of timeline is the timeline with the minimum number of\n", + " | segments with exactly the same time span as the original timeline.\n", + " | It is (by definition) unique and does not contain any overlapping\n", + " | segments.\n", + " | \n", + " | Returns\n", + " | -------\n", + " | coverage : Timeline\n", + " | Timeline coverage\n", + " | \n", + " | crop(self, other, mode='intersection', mapping=False)\n", + " | \n", + " | duration(self)\n", + " | Timeline duration\n", + " | \n", + " | Returns\n", + " | -------\n", + " | duration : float\n", + " | Duration of timeline coverage, in seconds.\n", + " | \n", + " | empty(self)\n", + " | Empty copy of a timeline.\n", + " | \n", + " | Examples\n", + " | --------\n", + " | \n", + " | >>> timeline = Timeline(uri=\"MyVideo.avi\")\n", + " | >>> timeline += [Segment(0, 1), Segment(2, 3)]\n", + " | >>> empty = timeline.empty()\n", + " | >>> print empty.uri\n", + " | MyVideo.avi\n", + " | >>> print empty\n", + " | [\n", + " | ]\n", + " | \n", + " | extent(self)\n", + " | Timeline extent\n", + " | \n", + " | The extent of a timeline is the segment of minimum duration that\n", + " | contains every segments of the timeline. It is unique, by definition.\n", + " | The extent of an empty timeline is an empty segment.\n", + " | \n", + " | Returns\n", + " | -------\n", + " | extent : Segment\n", + " | Timeline extent\n", + " | \n", + " | Examples\n", + " | --------\n", + " | \n", + " | >>> timeline = Timeline(uri=\"MyVideo.avi\")\n", + " | >>> timeline += [Segment(0, 1), Segment(9, 10)]\n", + " | >>> print timeline.extent()\n", + " | [0 --> 10]\n", + " | \n", + " | for_json(self)\n", + " | \n", + " | gaps(self, focus=None)\n", + " | Timeline gaps\n", + " | \n", + " | Parameters\n", + " | ----------\n", + " | focus : None, Segment or Timeline\n", + " | \n", + " | Returns\n", + " | -------\n", + " | gaps : Timeline\n", + " | Timeline made of all gaps from original timeline, and delimited\n", + " | by provided segment or timeline.\n", + " | \n", + " | Raises\n", + " | ------\n", + " | TypeError when `focus` is neither None, Segment nor Timeline\n", + " | \n", + " | Examples\n", + " | --------\n", + " | \n", + " | index(self, segment)\n", + " | Index of segment\n", + " | \n", + " | Parameter\n", + " | ---------\n", + " | segment : Segment\n", + " | \n", + " | Raises\n", + " | ------\n", + " | ValueError if the segment is not present\n", + " | \n", + " | overlapping(self, timestamp)\n", + " | Get list of segments overlapping `timestamp`\n", + " | \n", + " | segmentation(self)\n", + " | Non-overlapping timeline\n", + " | \n", + " | Create the unique timeline with same coverage and same set of segment\n", + " | boundaries as original timeline, but with no overlapping segments.\n", + " | \n", + " | A picture is worth a thousand words:\n", + " | \n", + " | Original timeline:\n", + " | |------| |------| |----|\n", + " | |--| |-----| |----------|\n", + " | \n", + " | Non-overlapping timeline\n", + " | |-|--|-| |-|---|--| |--|----|--|\n", + " | \n", + " | Returns\n", + " | -------\n", + " | timeline : Timeline\n", + " | \n", + " | Examples\n", + " | --------\n", + " | \n", + " | >>> timeline = Timeline()\n", + " | >>> timeline += [Segment(0, 1), Segment(1, 2), Segment(2,3)]\n", + " | >>> timeline += [Segment(2, 4), Segment(6, 7)]\n", + " | >>> print timeline.segmentation()\n", + " | [\n", + " | [0 --> 1]\n", + " | [1 --> 2]\n", + " | [2 --> 3]\n", + " | [3 --> 4]\n", + " | [6 --> 7]\n", + " | ]\n", + " | \n", + " | union(self, other)\n", + " | Create new timeline made of union of segments\n", + " | \n", + " | update(self, timeline)\n", + " | Add `timeline` segments\n", + " | \n", + " | ----------------------------------------------------------------------\n", + " | Class methods defined here:\n", + " | \n", + " | from_df(cls, df, uri=None) from __builtin__.type\n", + " | \n", + " | from_json(cls, data) from __builtin__.type\n", + " | \n", + " | ----------------------------------------------------------------------\n", + " | Data descriptors defined here:\n", + " | \n", + " | __dict__\n", + " | dictionary for instance variables (if defined)\n", + " | \n", + " | __weakref__\n", + " | list of weak references to the object (if defined)\n", + "\n" + ] + } + ], + "source": [ + "help(Timeline)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.4" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/packages/core/pyproject.toml b/packages/core/pyproject.toml new file mode 100644 index 00000000..6692c7bc --- /dev/null +++ b/packages/core/pyproject.toml @@ -0,0 +1,50 @@ +[project] +name = "pyannote-core" +description = "Advanced data structures for handling temporal segments with attached labels" +readme = "README.md" +authors = [ + { name = "Hervé BREDIN", email = "herve@pyannote.ai" } +] +requires-python = ">=3.11" + +dynamic = [ + "version", +] + +dependencies = [ + "numpy>=2.0", + "pandas>=2.2.3", + "sortedcontainers>=2.4.0", +] + +[project.optional-dependencies] +notebook = [ + "ipython>=8.31.0", + "matplotlib>=3.10.0", +] +test = [ + "matplotlib>=3.10.0", + "pytest>=8.3.4", + "scipy>=1.15.1", +] +doc = [ + "sphinx-rtd-theme>=3.0.2", + "sphinx>=8.1.3", + "matplotlib>=3.10.0", + "ipython>=8.32.0", +] + +[build-system] +requires = ["hatchling==1.32.0", "hatch-vcs"] +build-backend = "hatchling.build" + +[tool.hatch.version] +source = "vcs" + +[tool.hatch.build.targets.wheel] +packages = ["src/pyannote"] + +[dependency-groups] +dev = [ + "ipykernel>=6.29.5", +] diff --git a/packages/core/src/pyannote/core/__init__.py b/packages/core/src/pyannote/core/__init__.py new file mode 100644 index 00000000..9e18147b --- /dev/null +++ b/packages/core/src/pyannote/core/__init__.py @@ -0,0 +1,66 @@ +# The MIT License (MIT) + +# Copyright (c) 2014-2019 CNRS + +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: + +# The above copyright notice and this permission notice shall be included in +# all copies or substantial portions of the Software. + +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +# AUTHORS +# Hervé BREDIN - http://herve.niderb.fr + + +import importlib.metadata + +PYANNOTE_URI = "uri" +PYANNOTE_MODALITY = "modality" +PYANNOTE_SEGMENT = "segment" +PYANNOTE_TRACK = "track" +PYANNOTE_LABEL = "label" +PYANNOTE_SCORE = "score" +PYANNOTE_IDENTITY = "identity" + +from .annotation import Annotation +from .feature import SlidingWindowFeature +from .segment import Segment, SlidingWindow +from .timeline import Timeline + +__all__ = [ + "PYANNOTE_IDENTITY", + "PYANNOTE_LABEL", + "PYANNOTE_MODALITY", + "PYANNOTE_SCORE", + "PYANNOTE_SEGMENT", + "PYANNOTE_TRACK", + "PYANNOTE_URI", + "Annotation", + "Segment", + "SlidingWindow", + "SlidingWindowFeature", + "Timeline", +] + +try: + from .notebook import notebook +except ImportError: + pass +else: + __all__ += ["notebook"] + +Segment.set_precision() + +__version__ = importlib.metadata.version("pyannote-core") diff --git a/packages/core/src/pyannote/core/annotation.py b/packages/core/src/pyannote/core/annotation.py new file mode 100644 index 00000000..9723c8fa --- /dev/null +++ b/packages/core/src/pyannote/core/annotation.py @@ -0,0 +1,1544 @@ +# The MIT License (MIT) + +# Copyright (c) 2014-2021 CNRS + +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: + +# The above copyright notice and this permission notice shall be included in +# all copies or substantial portions of the Software. + +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +# AUTHORS +# Hervé BREDIN - http://herve.niderb.fr +# Paul LERNER + +""" +########## +Annotation +########## + +.. plot:: pyplots/annotation.py + +:class:`pyannote.core.Annotation` instances are ordered sets of non-empty +tracks: + + - ordered, because segments are sorted by start time (and end time in case of tie) + - set, because one cannot add twice the same track + - non-empty, because one cannot add empty track + +A track is a (support, name) pair where `support` is a Segment instance, +and `name` is an additional identifier so that it is possible to add multiple +tracks with the same support. + +To define the annotation depicted above: + +.. code-block:: ipython + + In [1]: from pyannote.core import Annotation, Segment + + In [6]: annotation = Annotation() + ...: annotation[Segment(1, 5)] = 'Carol' + ...: annotation[Segment(6, 8)] = 'Bob' + ...: annotation[Segment(12, 18)] = 'Carol' + ...: annotation[Segment(7, 20)] = 'Alice' + ...: + +which is actually a shortcut for + +.. code-block:: ipython + + In [6]: annotation = Annotation() + ...: annotation[Segment(1, 5), '_'] = 'Carol' + ...: annotation[Segment(6, 8), '_'] = 'Bob' + ...: annotation[Segment(12, 18), '_'] = 'Carol' + ...: annotation[Segment(7, 20), '_'] = 'Alice' + ...: + +where all tracks share the same (default) name ``'_'``. + +In case two tracks share the same support, use a different track name: + +.. code-block:: ipython + + In [6]: annotation = Annotation(uri='my_video_file', modality='speaker') + ...: annotation[Segment(1, 5), 1] = 'Carol' # track name = 1 + ...: annotation[Segment(1, 5), 2] = 'Bob' # track name = 2 + ...: annotation[Segment(12, 18)] = 'Carol' + ...: + +The track name does not have to be unique over the whole set of tracks. + +.. note:: + + The optional *uri* and *modality* keywords argument can be used to remember + which document and modality (e.g. speaker or face) it describes. + +Several convenient methods are available. Here are a few examples: + +.. code-block:: ipython + + In [9]: annotation.labels() # sorted list of labels + Out[9]: ['Bob', 'Carol'] + + In [10]: annotation.chart() # label duration chart + Out[10]: [('Carol', 10), ('Bob', 4)] + + In [11]: list(annotation.itertracks()) + Out[11]: [(, 1), (, 2), (, u'_')] + + In [12]: annotation.label_timeline('Carol') + Out[12]: , ])> + +See :class:`pyannote.core.Annotation` for the complete reference. +""" + +import itertools +import warnings +from collections import defaultdict +from collections.abc import Hashable, Iterable, Iterator +from typing import ( + TYPE_CHECKING, + TextIO, +) + +import numpy as np +from sortedcontainers import SortedDict + +from . import ( + PYANNOTE_LABEL, + PYANNOTE_SEGMENT, + PYANNOTE_TRACK, +) +from .feature import SlidingWindowFeature +from .segment import Segment, SlidingWindow +from .timeline import Timeline +from .utils.generators import int_generator, string_generator +from .utils.types import CropMode, Key, Label, LabelGenerator, Support, TrackName + +if TYPE_CHECKING: + import pandas as pd + + +class Annotation: + """Annotation + + Parameters + ---------- + uri : string, optional + name of annotated resource (e.g. audio or video file) + modality : string, optional + name of annotated modality + + Returns + ------- + annotation : Annotation + New annotation + + """ + + @classmethod + def from_df( + cls, + df: "pd.DataFrame", + uri: str | None = None, + modality: str | None = None, + ) -> "Annotation": + + df = df[[PYANNOTE_SEGMENT, PYANNOTE_TRACK, PYANNOTE_LABEL]] + return Annotation.from_records(df.itertuples(index=False), uri, modality) + + def __init__(self, uri: str | None = None, modality: str | None = None): + + self._uri: str | None = uri + self.modality: str | None = modality + + # sorted dictionary + # keys: annotated segments + # values: {track: label} dictionary + self._tracks: dict[Segment, dict[TrackName, Label]] = SortedDict() + + # dictionary + # key: label + # value: timeline + self._labels: dict[Label, Timeline] = {} + self._labelNeedsUpdate: dict[Label, bool] = {} + + # timeline meant to store all annotated segments + self._timeline: Timeline = None + self._timelineNeedsUpdate: bool = True + + @property + def uri(self): + return self._uri + + @uri.setter + def uri(self, uri: str): + # update uri for all internal timelines + for label in self.labels(): + timeline = self.label_timeline(label, copy=False) + timeline.uri = uri + timeline = self.get_timeline(copy=False) + timeline.uri = uri + self._uri = uri + + def _updateLabels(self): + + # list of labels that needs to be updated + update = {label for label, update in self._labelNeedsUpdate.items() if update} + + # accumulate segments for updated labels + _segments = {label: [] for label in update} + for segment, track, label in self.itertracks(yield_label=True): + if label in update: + _segments[label].append(segment) + + # create timeline with accumulated segments for updated labels + for label in update: + if _segments[label]: + self._labels[label] = Timeline(segments=_segments[label], uri=self.uri) + self._labelNeedsUpdate[label] = False + else: + self._labels.pop(label, None) + self._labelNeedsUpdate.pop(label, None) + + def __len__(self): + """Number of segments + + >>> len(annotation) # annotation contains three segments + 3 + """ + return len(self._tracks) + + def __nonzero__(self): + return self.__bool__() + + def __bool__(self): + """Emptiness + + >>> if annotation: + ... # annotation is not empty + ... else: + ... # annotation is empty + """ + return len(self._tracks) > 0 + + def __iter__(self) -> Iterator[tuple[Segment, Label]]: + """Iterate over (segment, label) pairs in chronological order + + Examples + -------- + + >>> for segment, label in annotation: + ... # do something with the segment and its label + """ + for segment, _, label in self.itertracks(yield_label=True): + yield segment, label + + def itersegments(self): + """Iterate over segments (in chronological order) + + >>> for segment in annotation.itersegments(): + ... # do something with the segment + + See also + -------- + :class:`pyannote.core.Segment` describes how segments are sorted. + """ + return iter(self._tracks) + + def itertracks( + self, yield_label: bool = False + ) -> Iterator[tuple[Segment, TrackName] | tuple[Segment, TrackName, Label]]: + """Iterate over tracks (in chronological order) + + Parameters + ---------- + yield_label : bool, optional + When True, yield (segment, track, label) tuples, such that + annotation[segment, track] == label. Defaults to yielding + (segment, track) tuple. + + Examples + -------- + + >>> for segment, track in annotation.itertracks(): + ... # do something with the track + + >>> for segment, track, label in annotation.itertracks(yield_label=True): + ... # do something with the track and its label + """ + + for segment, tracks in self._tracks.items(): + for track, lbl in sorted( + tracks.items(), key=lambda tl: (str(tl[0]), str(tl[1])) + ): + if yield_label: + yield segment, track, lbl + else: + yield segment, track + + def _updateTimeline(self): + self._timeline = Timeline(segments=self._tracks, uri=self.uri) + self._timelineNeedsUpdate = False + + def get_timeline(self, copy: bool = True) -> Timeline: + """Get timeline made of all annotated segments + + Parameters + ---------- + copy : bool, optional + Defaults (True) to returning a copy of the internal timeline. + Set to False to return the actual internal timeline (faster). + + Returns + ------- + timeline : Timeline + Timeline made of all annotated segments. + + Note + ---- + In case copy is set to False, be careful **not** to modify the returned + timeline, as it may lead to weird subsequent behavior of the annotation + instance. + + """ + if self._timelineNeedsUpdate: + self._updateTimeline() + if copy: + return self._timeline.copy() + return self._timeline + + def __eq__(self, other: "Annotation"): + """Equality + + >>> annotation == other + + Two annotations are equal if and only if their tracks and associated + labels are equal. + """ + pairOfTracks = itertools.zip_longest( + self.itertracks(yield_label=True), other.itertracks(yield_label=True) + ) + return all(t1 == t2 for t1, t2 in pairOfTracks) + + def __ne__(self, other: "Annotation"): + """Inequality""" + pairOfTracks = itertools.zip_longest( + self.itertracks(yield_label=True), other.itertracks(yield_label=True) + ) + + return any(t1 != t2 for t1, t2 in pairOfTracks) + + def __contains__(self, included: Segment | Timeline): + """Inclusion + + Check whether every segment of `included` does exist in annotation. + + Parameters + ---------- + included : Segment or Timeline + Segment or timeline being checked for inclusion + + Returns + ------- + contains : bool + True if every segment in `included` exists in timeline, + False otherwise + + """ + return included in self.get_timeline(copy=False) + + def _iter_rttm(self) -> Iterator[str]: + """Generate lines for an RTTM file for this annotation + + Returns + ------- + iterator: Iterator[str] + An iterator over RTTM text lines + """ + uri = self.uri if self.uri else "" + if isinstance(uri, str) and " " in uri: + msg = ( + f"Space-separated RTTM file format does not allow file URIs " + f'containing spaces (got: "{uri}").' + ) + raise ValueError(msg) + for segment, _, label in self.itertracks(yield_label=True): + if isinstance(label, str) and " " in label: + msg = ( + f"Space-separated RTTM file format does not allow labels " + f'containing spaces (got: "{label}").' + ) + raise ValueError(msg) + yield ( + f"SPEAKER {uri} 1 {segment.start:.3f} {segment.duration:.3f} " + f" {label} \n" + ) + + def to_rttm(self) -> str: + """Serialize annotation as a string using RTTM format + + Returns + ------- + serialized: str + RTTM string + """ + return "".join([line for line in self._iter_rttm()]) + + def write_rttm(self, file: TextIO): + """Dump annotation to file using RTTM format + + Parameters + ---------- + file : file object + + Usage + ----- + >>> with open('file.rttm', 'w') as file: + ... annotation.write_rttm(file) + """ + file.writelines(self._iter_rttm()) + + def _iter_lab(self) -> Iterator[str]: + """Generate lines for a LAB file for this annotation + + Returns + ------- + iterator: Iterator[str] + An iterator over LAB text lines + """ + for segment, _, label in self.itertracks(yield_label=True): + if isinstance(label, str) and " " in label: + msg = ( + f"Space-separated LAB file format does not allow labels " + f'containing spaces (got: "{label}").' + ) + raise ValueError(msg) + yield f"{segment.start:.3f} {segment.start + segment.duration:.3f} {label}\n" + + def to_lab(self) -> str: + """Serialize annotation as a string using LAB format + + Returns + ------- + serialized: str + LAB string + """ + return "".join([line for line in self._iter_lab()]) + + def write_lab(self, file: TextIO): + """Dump annotation to file using LAB format + + Parameters + ---------- + file : file object + + Usage + ----- + >>> with open('file.lab', 'w') as file: + ... annotation.write_lab(file) + """ + file.writelines(self._iter_lab()) + + def crop(self, support: Support, mode: CropMode = "intersection") -> "Annotation": + """Crop annotation to new support + + Parameters + ---------- + support : Segment or Timeline + If `support` is a `Timeline`, its support is used. + mode : {'strict', 'loose', 'intersection'}, optional + Controls how segments that are not fully included in `support` are + handled. 'strict' mode only keeps fully included segments. 'loose' + mode keeps any intersecting segment. 'intersection' mode keeps any + intersecting segment but replace them by their actual intersection. + + Returns + ------- + cropped : Annotation + Cropped annotation + + Note + ---- + In 'intersection' mode, the best is done to keep the track names + unchanged. However, in some cases where two original segments are + cropped into the same resulting segments, conflicting track names are + modified to make sure no track is lost. + + """ + + # TODO speed things up by working directly with annotation internals + + if isinstance(support, Segment): + support = Timeline(segments=[support], uri=self.uri) + return self.crop(support, mode=mode) + + elif isinstance(support, Timeline): + # if 'support' is a `Timeline`, we use its support + support = support.support() + cropped = self.__class__(uri=self.uri, modality=self.modality) + + if mode == "loose": + _tracks = {} + _labels = set() + + for segment, _ in self.get_timeline(copy=False).co_iter(support): + tracks = dict(self._tracks[segment]) + _tracks[segment] = tracks + _labels.update(tracks.values()) + + cropped._tracks = SortedDict(_tracks) + + cropped._labelNeedsUpdate = {label: True for label in _labels} + cropped._labels = {label: None for label in _labels} + + cropped._timelineNeedsUpdate = True + cropped._timeline = None + + return cropped + + elif mode == "strict": + _tracks = {} + _labels = set() + + for segment, other_segment in self.get_timeline(copy=False).co_iter( + support + ): + if segment not in other_segment: + continue + + tracks = dict(self._tracks[segment]) + _tracks[segment] = tracks + _labels.update(tracks.values()) + + cropped._tracks = SortedDict(_tracks) + + cropped._labelNeedsUpdate = {label: True for label in _labels} + cropped._labels = {label: None for label in _labels} + + cropped._timelineNeedsUpdate = True + cropped._timeline = None + + return cropped + + elif mode == "intersection": + for segment, other_segment in self.get_timeline(copy=False).co_iter( + support + ): + intersection = segment & other_segment + for track, label in self._tracks[segment].items(): + track = cropped.new_track(intersection, candidate=track) + cropped[intersection, track] = label + + return cropped + + else: + raise NotImplementedError(f"unsupported mode: '{mode}'") + + def extrude( + self, removed: Support, mode: CropMode = "intersection" + ) -> "Annotation": + """Remove segments that overlap `removed` support. + + A simple illustration: + + .. code-block:: text + + A |------| |------| # + B |----------| # self + C |--------------| |------| # + + # + |-------| |-----------| # removed + # + + A # + B |---| # mode="intersection" + C |--| |------| # + + A # + B # mode="loose" + C |------| # + + A |------| # + B |----------| # mode="strict" + C |--------------| |------| # + + Parameters + ---------- + removed : Segment or Timeline + If `support` is a `Timeline`, its support is used. + mode : {'strict', 'loose', 'intersection'}, optional + Controls how segments that are not fully included in `removed` are + handled. 'strict' mode only removes fully included segments. 'loose' + mode removes any intersecting segment. 'intersection' mode removes + the overlapping part of any intersecting segment. + + Returns + ------- + extruded : Annotation + Extruded annotation + + Note + ---- + In 'intersection' mode, the best is done to keep the track names + unchanged. However, in some cases where two original segments are + cropped into the same resulting segments, conflicting track names are + modified to make sure no track is lost. + + """ + if isinstance(removed, Segment): + removed = Timeline([removed]) + + extent_tl = Timeline([self.get_timeline().extent()], uri=self.uri) + truncating_support = removed.gaps(support=extent_tl) + # loose for truncate means strict for crop and vice-versa + if mode == "loose": + mode = "strict" + elif mode == "strict": + mode = "loose" + return self.crop(truncating_support, mode=mode) + + def get_overlap(self, labels: Iterable[Label] | None = None) -> "Timeline": + """Get overlapping parts of the annotation. + + A simple illustration: + + .. code-block:: text + + annotation + A |------| |------| |----| + B |--| |-----| |----------| + C |--------------| |------| + + annotation.get_overlap() + |------| |-----| |--------| + + annotation.get_overlap(for_labels=["A", "B"]) + |--| |--| |----| + + Parameters + ---------- + labels : optional list of labels + Labels for which to consider the overlap + + Returns + ------- + overlap : `pyannote.core.Timeline` + Timeline of the overlaps. + """ + if labels: + annotation = self.subset(labels) + else: + annotation = self + + overlaps_tl = Timeline(uri=annotation.uri) + for (s1, t1), (s2, t2) in annotation.co_iter(annotation): + # if labels are the same for the two segments, skipping + if self[s1, t1] == self[s2, t2]: + continue + overlaps_tl.add(s1 & s2) + return overlaps_tl.support() + + def get_tracks(self, segment: Segment) -> set[TrackName]: + """Query tracks by segment + + Parameters + ---------- + segment : Segment + Query + + Returns + ------- + tracks : set + Set of tracks + + Note + ---- + This will return an empty set if segment does not exist. + """ + return set(self._tracks.get(segment, {}).keys()) + + def has_track(self, segment: Segment, track: TrackName) -> bool: + """Check whether a given track exists + + Parameters + ---------- + segment : Segment + Query segment + track : + Query track + + Returns + ------- + exists : bool + True if track exists for segment + """ + return track in self._tracks.get(segment, {}) + + def copy(self) -> "Annotation": + """Get a copy of the annotation + + Returns + ------- + annotation : Annotation + Copy of the annotation + """ + + # create new empty annotation + copied = self.__class__(uri=self.uri, modality=self.modality) + + # deep copy internal track dictionary + _tracks, _labels = [], set() + for key, value in self._tracks.items(): + _labels.update(value.values()) + _tracks.append((key, dict(value))) + + copied._tracks = SortedDict(_tracks) + + copied._labels = {label: None for label in _labels} + copied._labelNeedsUpdate = {label: True for label in _labels} + + copied._timeline = None + copied._timelineNeedsUpdate = True + + return copied + + def new_track( + self, + segment: Segment, + candidate: TrackName | None = None, + prefix: str | None = None, + ) -> TrackName: + """Generate a new track name for given segment + + Ensures that the returned track name does not already + exist for the given segment. + + Parameters + ---------- + segment : Segment + Segment for which a new track name is generated. + candidate : any valid track name, optional + When provided, try this candidate name first. + prefix : str, optional + Track name prefix. Defaults to the empty string ''. + + Returns + ------- + name : str + New track name + """ + + # obtain list of existing tracks for segment + existing_tracks = set(self._tracks.get(segment, {})) + + # if candidate is provided, check whether it already exists + # in case it does not, use it + if (candidate is not None) and (candidate not in existing_tracks): + return candidate + + # no candidate was provided or the provided candidate already exists + # we need to create a brand new one + + # by default (if prefix is not provided), use '' + if prefix is None: + prefix = "" + + # find first non-existing track name for segment + # eg. if '0' exists, try '1', then '2', ... + count = 0 + while f"{prefix}{count}" in existing_tracks: + count += 1 + + # return first non-existing track name + return f"{prefix}{count}" + + def __str__(self): + """Human-friendly representation""" + # TODO: use pandas.DataFrame + return "\n".join( + [f"{s} {t} {l}" for s, t, l in self.itertracks(yield_label=True)] + ) + + def __delitem__(self, key: Key): + """Delete one track + + >>> del annotation[segment, track] + + Delete all tracks of a segment + + >>> del annotation[segment] + """ + + # del annotation[segment] + if isinstance(key, Segment): + # Pop segment out of dictionary + # and get corresponding tracks + # Raises KeyError if segment does not exist + tracks = self._tracks.pop(key) + + # mark timeline as modified + self._timelineNeedsUpdate = True + + # mark every label in tracks as modified + for label in tracks.values(): + self._labelNeedsUpdate[label] = True + + # del annotation[segment, track] + elif isinstance(key, tuple) and len(key) == 2: + # get segment tracks as dictionary + # if segment does not exist, get empty dictionary + # Raises KeyError if segment does not exist + tracks = self._tracks[key[0]] + + # pop track out of tracks dictionary + # and get corresponding label + # Raises KeyError if track does not exist + label = tracks.pop(key[1]) + + # mark label as modified + self._labelNeedsUpdate[label] = True + + # if tracks dictionary is now empty, + # remove segment as well + if not tracks: + self._tracks.pop(key[0]) + self._timelineNeedsUpdate = True + + else: + raise NotImplementedError( + "Deletion only works with Segment or (Segment, track) keys." + ) + + # label = annotation[segment, track] + def __getitem__(self, key: Key) -> Label: + """Get track label + + >>> label = annotation[segment, track] + + Note + ---- + ``annotation[segment]`` is equivalent to ``annotation[segment, '_']`` + + """ + + if isinstance(key, Segment): + key = (key, "_") + + return self._tracks[key[0]][key[1]] + + # annotation[segment, track] = label + def __setitem__(self, key: Key, label: Label): + """Add new or update existing track + + >>> annotation[segment, track] = label + + If (segment, track) does not exist, it is added. + If (segment, track) already exists, it is updated. + + Note + ---- + ``annotation[segment] = label`` is equivalent to ``annotation[segment, '_'] = label`` + + Note + ---- + If `segment` is empty, it does nothing. + """ + + if isinstance(key, Segment): + key = (key, "_") + + segment, track = key + + # do not add empty track + if not segment: + return + + # in case we create a new segment + # mark timeline as modified + if segment not in self._tracks: + self._tracks[segment] = {} + self._timelineNeedsUpdate = True + + # in case we modify an existing track + # mark old label as modified + if track in self._tracks[segment]: + old_label = self._tracks[segment][track] + self._labelNeedsUpdate[old_label] = True + + # mark new label as modified + self._tracks[segment][track] = label + self._labelNeedsUpdate[label] = True + + def empty(self) -> "Annotation": + """Return an empty copy + + Returns + ------- + empty : Annotation + Empty annotation using the same 'uri' and 'modality' attributes. + + """ + return self.__class__(uri=self.uri, modality=self.modality) + + def labels(self) -> list[Label]: + """Get sorted list of labels + + Returns + ------- + labels : list + Sorted list of labels + """ + if any(lnu for lnu in self._labelNeedsUpdate.values()): + self._updateLabels() + return sorted(self._labels, key=str) + + def get_labels( + self, segment: Segment, unique: bool = True + ) -> set[Label] | list[Label]: + """Query labels by segment + + Parameters + ---------- + segment : Segment + Query + unique : bool, optional + When False, return the list of (possibly repeated) labels. + Defaults to returning the set of labels. + + Returns + ------- + labels : set or list + Set (resp. list) of labels for `segment` if it exists, empty set (resp. list) otherwise + if unique (resp. if not unique). + + Examples + -------- + >>> annotation = Annotation() + >>> segment = Segment(0, 2) + >>> annotation[segment, 'speaker1'] = 'Bernard' + >>> annotation[segment, 'speaker2'] = 'John' + >>> print sorted(annotation.get_labels(segment)) + set(['Bernard', 'John']) + >>> print annotation.get_labels(Segment(1, 2)) + set([]) + + """ + + labels = self._tracks.get(segment, {}).values() + + if unique: + return set(labels) + + return list(labels) + + def subset(self, labels: Iterable[Label], invert: bool = False) -> "Annotation": + """Filter annotation by labels + + Parameters + ---------- + labels : iterable + List of filtered labels + invert : bool, optional + If invert is True, extract all but requested labels + + Returns + ------- + filtered : Annotation + Filtered annotation + """ + + labels = set(labels) + + if invert: + labels = set(self.labels()) - labels + else: + labels = labels & set(self.labels()) + + sub = self.__class__(uri=self.uri, modality=self.modality) + + _tracks, _labels = {}, set() + for segment, tracks in self._tracks.items(): + sub_tracks = { + track: label for track, label in tracks.items() if label in labels + } + if sub_tracks: + _tracks[segment] = sub_tracks + _labels.update(sub_tracks.values()) + + sub._tracks = SortedDict(_tracks) + + sub._labelNeedsUpdate = {label: True for label in _labels} + sub._labels = {label: None for label in _labels} + + sub._timelineNeedsUpdate = True + sub._timeline = None + + return sub + + def update(self, annotation: "Annotation", copy: bool = False) -> "Annotation": + """Add every track of an existing annotation (in place) + + Parameters + ---------- + annotation : Annotation + Annotation whose tracks are being added + copy : bool, optional + Return a copy of the annotation. Defaults to updating the + annotation in-place. + + Returns + ------- + self : Annotation + Updated annotation + + Note + ---- + Existing tracks are updated with the new label. + """ + + result = self.copy() if copy else self + + # TODO speed things up by working directly with annotation internals + for segment, track, label in annotation.itertracks(yield_label=True): + result[segment, track] = label + + return result + + def label_timeline(self, label: Label, copy: bool = True) -> Timeline: + """Query segments by label + + Parameters + ---------- + label : object + Query + copy : bool, optional + Defaults (True) to returning a copy of the internal timeline. + Set to False to return the actual internal timeline (faster). + + Returns + ------- + timeline : Timeline + Timeline made of all segments for which at least one track is + annotated as label + + Note + ---- + If label does not exist, this will return an empty timeline. + + Note + ---- + In case copy is set to False, be careful **not** to modify the returned + timeline, as it may lead to weird subsequent behavior of the annotation + instance. + + """ + if label not in self.labels(): + return Timeline(uri=self.uri) + + if self._labelNeedsUpdate[label]: + self._updateLabels() + + if copy: + return self._labels[label].copy() + + return self._labels[label] + + def label_support(self, label: Label) -> Timeline: + """Label support + + Equivalent to ``Annotation.label_timeline(label).support()`` + + Parameters + ---------- + label : object + Query + + Returns + ------- + support : Timeline + Label support + + See also + -------- + :func:`~pyannote.core.Annotation.label_timeline` + :func:`~pyannote.core.Timeline.support` + + """ + return self.label_timeline(label, copy=False).support() + + def label_duration(self, label: Label) -> float: + """Label duration + + Equivalent to ``Annotation.label_timeline(label).duration()`` + + Parameters + ---------- + label : object + Query + + Returns + ------- + duration : float + Duration, in seconds. + + See also + -------- + :func:`~pyannote.core.Annotation.label_timeline` + :func:`~pyannote.core.Timeline.duration` + + """ + + return self.label_timeline(label, copy=False).duration() + + def chart(self, percent: bool = False) -> list[tuple[Label, float]]: + """Get labels chart (from longest to shortest duration) + + Parameters + ---------- + percent : bool, optional + Return list of (label, percentage) tuples. + Defaults to returning list of (label, duration) tuples. + + Returns + ------- + chart : list + List of (label, duration), sorted by duration in decreasing order. + """ + + chart = sorted( + ((L, self.label_duration(L)) for L in self.labels()), + key=lambda x: x[1], + reverse=True, + ) + + if percent: + total = np.sum([duration for _, duration in chart]) + chart = [(label, duration / total) for (label, duration) in chart] + + return chart + + def argmax(self, support: Support | None = None) -> Label | None: + """Get label with longest duration + + Parameters + ---------- + support : Segment or Timeline, optional + Find label with longest duration within provided support. + Defaults to whole extent. + + Returns + ------- + label : any existing label or None + Label with longest intersection + + Examples + -------- + >>> annotation = Annotation(modality='speaker') + >>> annotation[Segment(0, 10), 'speaker1'] = 'Alice' + >>> annotation[Segment(8, 20), 'speaker1'] = 'Bob' + >>> print "%s is such a talker!" % annotation.argmax() + Bob is such a talker! + >>> segment = Segment(22, 23) + >>> if not annotation.argmax(support): + ... print "No label intersecting %s" % segment + No label intersection [22 --> 23] + + """ + + cropped = self + if support is not None: + cropped = cropped.crop(support, mode="intersection") + + if not cropped: + return None + + return max( + ((_, cropped.label_duration(_)) for _ in cropped.labels()), + key=lambda x: x[1], + )[0] + + def rename_tracks(self, generator: LabelGenerator = "string") -> "Annotation": + """Rename all tracks + + Parameters + ---------- + generator : 'string', 'int', or iterable, optional + If 'string' (default) rename tracks to 'A', 'B', 'C', etc. + If 'int', rename tracks to 0, 1, 2, etc. + If iterable, use it to generate track names. + + Returns + ------- + renamed : Annotation + Copy of the original annotation where tracks are renamed. + + Example + ------- + >>> annotation = Annotation() + >>> annotation[Segment(0, 1), 'a'] = 'a' + >>> annotation[Segment(0, 1), 'b'] = 'b' + >>> annotation[Segment(1, 2), 'a'] = 'a' + >>> annotation[Segment(1, 3), 'c'] = 'c' + >>> print(annotation) + [ 00:00:00.000 --> 00:00:01.000] a a + [ 00:00:00.000 --> 00:00:01.000] b b + [ 00:00:01.000 --> 00:00:02.000] a a + [ 00:00:01.000 --> 00:00:03.000] c c + >>> print(annotation.rename_tracks(generator='int')) + [ 00:00:00.000 --> 00:00:01.000] 0 a + [ 00:00:00.000 --> 00:00:01.000] 1 b + [ 00:00:01.000 --> 00:00:02.000] 2 a + [ 00:00:01.000 --> 00:00:03.000] 3 c + """ + + renamed = self.__class__(uri=self.uri, modality=self.modality) + + if generator == "string": + generator = string_generator() + elif generator == "int": + generator = int_generator() + + # TODO speed things up by working directly with annotation internals + for s, _, label in self.itertracks(yield_label=True): + renamed[s, next(generator)] = label + return renamed + + def rename_labels( + self, + mapping: dict | None = None, + generator: LabelGenerator = "string", + copy: bool = True, + ) -> "Annotation": + """Rename labels + + Parameters + ---------- + mapping : dict, optional + {old_name: new_name} mapping dictionary. + generator : 'string', 'int' or iterable, optional + If 'string' (default) rename label to 'A', 'B', 'C', ... If 'int', + rename to 0, 1, 2, etc. If iterable, use it to generate labels. + copy : bool, optional + Set to True to return a copy of the annotation. Set to False to + update the annotation in-place. Defaults to True. + + Returns + ------- + renamed : Annotation + Annotation where labels have been renamed + + Note + ---- + Unmapped labels are kept unchanged. + + Note + ---- + Parameter `generator` has no effect when `mapping` is provided. + + """ + + if mapping is None: + if generator == "string": + generator = string_generator() + elif generator == "int": + generator = int_generator() + # generate mapping + mapping = {label: next(generator) for label in self.labels()} + + renamed = self.copy() if copy else self + + for old_label, new_label in mapping.items(): + renamed._labelNeedsUpdate[old_label] = True + renamed._labelNeedsUpdate[new_label] = True + + for segment, tracks in self._tracks.items(): + new_tracks = { + track: mapping.get(label, label) for track, label in tracks.items() + } + renamed._tracks[segment] = new_tracks + + return renamed + + def relabel_tracks(self, generator: LabelGenerator = "string") -> "Annotation": + """Relabel tracks + + Create a new annotation where each track has a unique label. + + Parameters + ---------- + generator : 'string', 'int' or iterable, optional + If 'string' (default) relabel tracks to 'A', 'B', 'C', ... If 'int' + relabel to 0, 1, 2, ... If iterable, use it to generate labels. + + Returns + ------- + renamed : Annotation + New annotation with relabeled tracks. + """ + + if generator == "string": + generator = string_generator() + elif generator == "int": + generator = int_generator() + + relabeled = self.empty() + for s, t, _ in self.itertracks(yield_label=True): + relabeled[s, t] = next(generator) + + return relabeled + + def support(self, collar: float = 0.0) -> "Annotation": + """Annotation support + + The support of an annotation is an annotation where contiguous tracks + with same label are merged into one unique covering track. + + A picture is worth a thousand words:: + + collar + |---| + + annotation + |--A--| |--A--| |-B-| + |-B-| |--C--| |----B-----| + + annotation.support(collar) + |------A------| |------B------| + |-B-| |--C--| + + Parameters + ---------- + collar : float, optional + Merge tracks with same label and separated by less than `collar` + seconds. This is why 'A' tracks are merged in above figure. + Defaults to 0. + + Returns + ------- + support : Annotation + Annotation support + + Note + ---- + Track names are lost in the process. + """ + + generator = string_generator() + + # initialize an empty annotation + # with same uri and modality as original + support = self.empty() + for label in self.labels(): + # get timeline for current label + timeline = self.label_timeline(label, copy=True) + + # fill the gaps shorter than collar + timeline = timeline.support(collar) + + # reconstruct annotation with merged tracks + for segment in timeline.support(): + support[segment, next(generator)] = label + + return support + + def co_iter( + self, other: "Annotation" + ) -> Iterator[tuple[tuple[Segment, TrackName], tuple[Segment, TrackName]]]: + """Iterate over pairs of intersecting tracks + + Parameters + ---------- + other : Annotation + Second annotation + + Returns + ------- + iterable : (Segment, object), (Segment, object) iterable + Yields pairs of intersecting tracks, in chronological (then + alphabetical) order. + + See also + -------- + :func:`~pyannote.core.Timeline.co_iter` + + """ + timeline = self.get_timeline(copy=False) + other_timeline = other.get_timeline(copy=False) + for s, S in timeline.co_iter(other_timeline): + tracks = sorted(self.get_tracks(s), key=str) + other_tracks = sorted(other.get_tracks(S), key=str) + for t, T in itertools.product(tracks, other_tracks): + yield (s, t), (S, T) + + def __mul__(self, other: "Annotation") -> np.ndarray: + """Cooccurrence (or confusion) matrix + + >>> matrix = annotation * other + + Parameters + ---------- + other : Annotation + Second annotation + + Returns + ------- + cooccurrence : (n_self, n_other) np.ndarray + Cooccurrence matrix where `n_self` (resp. `n_other`) is the number + of labels in `self` (resp. `other`). + """ + + if not isinstance(other, Annotation): + raise TypeError( + "computing cooccurrence matrix only works with Annotation instances." + ) + + i_labels = self.labels() + j_labels = other.labels() + + I = {label: i for i, label in enumerate(i_labels)} + J = {label: j for j, label in enumerate(j_labels)} + + matrix = np.zeros((len(I), len(J))) + + # iterate over intersecting tracks and accumulate durations + for (segment, track), (other_segment, other_track) in self.co_iter(other): + i = I[self[segment, track]] + j = J[other[other_segment, other_track]] + duration = (segment & other_segment).duration + matrix[i, j] += duration + + return matrix + + def discretize( + self, + support: Segment | None = None, + resolution: float | SlidingWindow = 0.01, + labels: list[Hashable] | None = None, + duration: float | None = None, + ): + """Discretize + + Parameters + ---------- + support : Segment, optional + Part of annotation to discretize. + Defaults to annotation full extent. + resolution : float or SlidingWindow, optional + Defaults to 10ms frames. + labels : list of labels, optional + Defaults to self.labels() + duration : float, optional + Overrides support duration and ensures that the number of + returned frames is fixed (which might otherwise not be the case + because of rounding errors). + + Returns + ------- + discretized : SlidingWindowFeature + (num_frames, num_labels)-shaped binary features. + """ + + if support is None: + support = self.get_timeline().extent() + start_time, end_time = support + + cropped = self.crop(support, mode="intersection") + + if labels is None: + labels = cropped.labels() + + if isinstance(resolution, SlidingWindow): + resolution = SlidingWindow( + start=start_time, step=resolution.step, duration=resolution.duration + ) + else: + resolution = SlidingWindow( + start=start_time, step=resolution, duration=resolution + ) + + start_frame = resolution.closest_frame(start_time) + if duration is None: + end_frame = resolution.closest_frame(end_time) + num_frames = end_frame - start_frame + else: + num_frames = round(duration / resolution.step) + + data = np.zeros((num_frames, len(labels)), dtype=np.uint8) + for k, label in enumerate(labels): + segments = cropped.label_timeline(label) + for start, stop in resolution.crop( + segments, mode="center", return_ranges=True + ): + data[max(0, start) : min(stop, num_frames), k] += 1 + data = np.minimum(data, 1, out=data) + + return SlidingWindowFeature(data, resolution, labels=labels) + + @classmethod + def from_records( + cls, + records: Iterator[tuple[Segment, TrackName, Label]], + uri: str | None = None, + modality: str | None = None, + ) -> "Annotation": + """Annotation + + Parameters + ---------- + records : iterator of tuples + (segment, track, label) tuples + uri : string, optional + name of annotated resource (e.g. audio or video file) + modality : string, optional + name of annotated modality + + Returns + ------- + annotation : Annotation + New annotation + + """ + annotation = cls(uri=uri, modality=modality) + tracks = defaultdict(dict) + labels = set() + for segment, track, label in records: + tracks[segment][track] = label + labels.add(label) + annotation._tracks = SortedDict(tracks) + annotation._labels = {label: None for label in labels} + annotation._labelNeedsUpdate = {label: True for label in annotation._labels} + annotation._timeline = None + annotation._timelineNeedsUpdate = True + + return annotation + + def _repr_png_(self): + """IPython notebook support + + See also + -------- + :mod:`pyannote.core.notebook` + """ + from .notebook import MATPLOTLIB_IS_AVAILABLE, MATPLOTLIB_WARNING + + if not MATPLOTLIB_IS_AVAILABLE: + warnings.warn(MATPLOTLIB_WARNING.format(klass=self.__class__.__name__)) + return None + + from .notebook import repr_annotation + + return repr_annotation(self) diff --git a/packages/core/src/pyannote/core/feature.py b/packages/core/src/pyannote/core/feature.py new file mode 100644 index 00000000..80ba8843 --- /dev/null +++ b/packages/core/src/pyannote/core/feature.py @@ -0,0 +1,331 @@ +# The MIT License (MIT) + +# Copyright (c) 2014-2019 CNRS + +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: + +# The above copyright notice and this permission notice shall be included in +# all copies or substantial portions of the Software. + +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +# AUTHORS +# Hervé BREDIN - http://herve.niderb.fr + + +""" +######## +Features +######## + +See :class:`pyannote.core.SlidingWindowFeature` for the complete reference. +""" + +import numbers +import warnings +from collections.abc import Iterator +from typing import Union + +import numpy as np + +from pyannote.core.utils.types import Alignment + +from .segment import Segment, SlidingWindow +from .timeline import Timeline + + +class SlidingWindowFeature(np.lib.mixins.NDArrayOperatorsMixin): + """Periodic feature vectors + + Parameters + ---------- + data : (n_frames, n_features) numpy array + sliding_window : SlidingWindow + labels : list, optional + Textual description of each dimension. + """ + + def __init__( + self, + data: np.ndarray, + sliding_window: SlidingWindow, + labels: list[str] | None = None, + ): + self.sliding_window: SlidingWindow = sliding_window + self.data = data + self.labels = labels + self.__i: int = -1 + + def __len__(self): + """Number of feature vectors""" + return self.data.shape[0] + + @property + def extent(self): + return self.sliding_window.range_to_segment(0, len(self)) + + @property + def dimension(self): + """Dimension of feature vectors""" + return self.data.shape[1] + + def getNumber(self): + warnings.warn("This is deprecated in favor of `__len__`", DeprecationWarning) + return self.data.shape[0] + + def getDimension(self): + warnings.warn( + "This is deprecated in favor of `dimension` property", DeprecationWarning + ) + return self.dimension + + def getExtent(self): + warnings.warn( + "This is deprecated in favor of `extent` property", DeprecationWarning + ) + return self.extent + + def __getitem__(self, i: int) -> np.ndarray: + """Get ith feature vector""" + return self.data[i] + + def __iter__(self): + self.__i = -1 + return self + + def __next__(self) -> tuple[Segment, np.ndarray]: + self.__i += 1 + try: + return self.sliding_window[self.__i], self.data[self.__i] + except IndexError: + raise StopIteration() + + def next(self): + return self.__next__() + + def iterfeatures( + self, window: bool | None = False + ) -> Iterator[tuple[np.ndarray, Segment] | np.ndarray]: + """Feature vector iterator + + Parameters + ---------- + window : bool, optional + When True, yield both feature vector and corresponding window. + Default is to only yield feature vector + + """ + n_samples = self.data.shape[0] + for i in range(n_samples): + if window: + yield self.data[i], self.sliding_window[i] + else: + yield self.data[i] + + def crop( + self, + focus: Segment | Timeline, + mode: Alignment = "loose", + fixed: float | None = None, + return_data: bool = True, + ) -> Union[np.ndarray, "SlidingWindowFeature"]: + """Extract frames + + Parameters + ---------- + focus : Segment or Timeline + mode : {'loose', 'strict', 'center'}, optional + In 'strict' mode, only frames fully included in 'focus' support are + returned. In 'loose' mode, any intersecting frames are returned. In + 'center' mode, first and last frames are chosen to be the ones + whose centers are the closest to 'focus' start and end times. + Defaults to 'loose'. + fixed : float, optional + Overrides `Segment` 'focus' duration and ensures that the number of + returned frames is fixed (which might otherwise not be the case + because of rounding errors). + return_data : bool, optional + Return a numpy array (default). For `Segment` 'focus', setting it + to False will return a `SlidingWindowFeature` instance. + + Returns + ------- + data : `numpy.ndarray` or `SlidingWindowFeature` + Frame features. + + See also + -------- + SlidingWindow.crop + + """ + + if (not return_data) and (not isinstance(focus, Segment)): + msg = ( + '"focus" must be a "Segment" instance when "return_data"' + "is set to False." + ) + raise ValueError(msg) + + if (not return_data) and (fixed is not None): + msg = '"fixed" cannot be set when "return_data" is set to False.' + raise ValueError(msg) + + ranges = self.sliding_window.crop( + focus, mode=mode, fixed=fixed, return_ranges=True + ) + + # total number of samples in features + n_samples = self.data.shape[0] + + # 1 for vector features (e.g. MFCC in pyannote.audio) + # 2 for matrix features (e.g. grey-level frames in pyannote.video) + # 3 for 3rd order tensor (e.g. RBG frames in pyannote.video) + n_dimensions = len(self.data.shape) - 1 + + # clip ranges + clipped_ranges, repeat_first, repeat_last = [], 0, 0 + for start, end in ranges: + # count number of requested samples before first sample + repeat_first += min(end, 0) - min(start, 0) + # count number of requested samples after last sample + repeat_last += max(end, n_samples) - max(start, n_samples) + # if all requested samples are out of bounds, skip + if end < 0 or start >= n_samples: + continue + else: + # keep track of non-empty clipped ranges + clipped_ranges += [[max(start, 0), min(end, n_samples)]] + + if clipped_ranges: + data = np.vstack([self.data[start:end, :] for start, end in clipped_ranges]) + else: + # if all ranges are out of bounds, just return empty data + shape = (0,) + self.data.shape[1:] + data = np.empty(shape) + + # corner case when "fixed" duration cropping is requested: + # correct number of samples even with out-of-bounds indices + if fixed is not None: + data = np.vstack( + [ + # repeat first sample as many times as needed + np.tile(self.data[0], (repeat_first,) + (1,) * n_dimensions), + data, + # repeat last sample as many times as needed + np.tile( + self.data[n_samples - 1], (repeat_last,) + (1,) * n_dimensions + ), + ] + ) + + # return data + if return_data: + return data + + # wrap data in a SlidingWindowFeature and return + sliding_window = SlidingWindow( + start=self.sliding_window[clipped_ranges[0][0]].start, + duration=self.sliding_window.duration, + step=self.sliding_window.step, + ) + + return SlidingWindowFeature(data, sliding_window, labels=self.labels) + + def _repr_png_(self): + from .notebook import MATPLOTLIB_IS_AVAILABLE, MATPLOTLIB_WARNING + + if not MATPLOTLIB_IS_AVAILABLE: + warnings.warn(MATPLOTLIB_WARNING.format(klass=self.__class__.__name__)) + return None + + from .notebook import repr_feature + + return repr_feature(self) + + _HANDLED_TYPES = (np.ndarray, numbers.Number) + + def __array__(self) -> np.ndarray: + return self.data + + def __array_ufunc__(self, ufunc, method, *inputs, **kwargs): + out = kwargs.get("out", ()) + for x in inputs + out: + # Only support operations with instances of _HANDLED_TYPES. + # Use SlidingWindowFeature instead of type(self) for isinstance to + # allow subclasses that don't override __array_ufunc__ to + # handle SlidingWindowFeature objects. + if not isinstance(x, self._HANDLED_TYPES + (SlidingWindowFeature,)): + return NotImplemented + + # Defer to the implementation of the ufunc on unwrapped values. + inputs = tuple( + x.data if isinstance(x, SlidingWindowFeature) else x for x in inputs + ) + if out: + kwargs["out"] = tuple( + x.data if isinstance(x, SlidingWindowFeature) else x for x in out + ) + data = getattr(ufunc, method)(*inputs, **kwargs) + + if type(data) is tuple: + # multiple return values + return tuple( + type(self)(x, self.sliding_window, labels=self.labels) for x in data + ) + elif method == "at": + # no return value + return None + else: + # one return value + return type(self)(data, self.sliding_window, labels=self.labels) + + def align(self, to: "SlidingWindowFeature") -> "SlidingWindowFeature": + """Align features by linear temporal interpolation + + Parameters + ---------- + to : SlidingWindowFeature + Features to align with. + + Returns + ------- + aligned : SlidingWindowFeature + Aligned features + """ + + old_start = self.sliding_window.start + old_step = self.sliding_window.step + old_duration = self.sliding_window.duration + old_samples = len(self) + old_t = old_start + 0.5 * old_duration + np.arange(old_samples) * old_step + + new_start = to.sliding_window.start + new_step = to.sliding_window.step + new_duration = to.sliding_window.duration + new_samples = len(to) + new_t = new_start + 0.5 * new_duration + np.arange(new_samples) * new_step + + new_data = np.hstack( + [ + np.interp(new_t, old_t, old_data)[:, np.newaxis] + for old_data in self.data.T + ] + ) + return SlidingWindowFeature(new_data, to.sliding_window, labels=self.labels) + + +if __name__ == "__main__": + import doctest + + doctest.testmod() diff --git a/packages/core/src/pyannote/core/notebook.py b/packages/core/src/pyannote/core/notebook.py new file mode 100644 index 00000000..691d4fe0 --- /dev/null +++ b/packages/core/src/pyannote/core/notebook.py @@ -0,0 +1,460 @@ +# The MIT License (MIT) + +# Copyright (c) 2014-2019 CNRS + +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: + +# The above copyright notice and this permission notice shall be included in +# all copies or substantial portions of the Software. + +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +# AUTHORS +# Hervé BREDIN - http://herve.niderb.fr + +""" +############# +Visualization +############# + +:class:`pyannote.core.Segment`, :class:`pyannote.core.Timeline`, +:class:`pyannote.core.Annotation` and :class:`pyannote.core.SlidingWindowFeature` +instances can be directly visualized in notebooks. + +You will however need to install ``pyannote.core``'s additional dependencies +for notebook representations (namely, matplotlib): + + +.. code-block:: bash + + pip install pyannote.core[notebook] + + +Segments +-------- + +.. code-block:: ipython + + In [1]: from pyannote.core import Segment + + In [2]: segment = Segment(start=5, end=15) + ....: segment + +.. plot:: pyplots/segment.py + + +Timelines +--------- + +.. code-block:: ipython + + In [25]: from pyannote.core import Timeline, Segment + + In [26]: timeline = Timeline() + ....: timeline.add(Segment(1, 5)) + ....: timeline.add(Segment(6, 8)) + ....: timeline.add(Segment(12, 18)) + ....: timeline.add(Segment(7, 20)) + ....: timeline + +.. plot:: pyplots/timeline.py + + +Annotations +----------- + + +.. code-block:: ipython + + In [1]: from pyannote.core import Annotation, Segment + + In [6]: annotation = Annotation() + ...: annotation[Segment(1, 5)] = 'Carol' + ...: annotation[Segment(6, 8)] = 'Bob' + ...: annotation[Segment(12, 18)] = 'Carol' + ...: annotation[Segment(7, 20)] = 'Alice' + ...: annotation + +.. plot:: pyplots/annotation.py + +""" + +from collections.abc import Iterable +from itertools import cycle, groupby, product + +import numpy as np + +from .annotation import Annotation +from .feature import SlidingWindowFeature +from .segment import Segment, SlidingWindow +from .timeline import Timeline +from .utils.types import Label, LabelStyle, Resource + +try: + import matplotlib # noqa: F401 -- probe whether the optional dependency imports +except ImportError: + MATPLOTLIB_IS_AVAILABLE = False +else: + MATPLOTLIB_IS_AVAILABLE = True + +MATPLOTLIB_WARNING = ( + "Couldn't import matplotlib to render the vizualization " + "for object {klass}. To enable, install the required dependencies " + "with 'pip install pyannore.core[notebook]'" +) + + +class Notebook: + def __init__(self): + self.reset() + + def reset(self): + from matplotlib.pyplot import get_cmap + + linewidth = [3, 1] + linestyle = ["solid", "dashed", "dotted"] + + cm = get_cmap("Set1") + colors = [cm(1.0 * i / 8) for i in range(9)] + + self._style_generator = cycle(product(linestyle, linewidth, colors)) + self._style: dict[Label | None, LabelStyle] = { + None: ("solid", 1, (0.0, 0.0, 0.0)) + } + del self.crop + del self.width + + @property + def crop(self): + """The crop property.""" + return self._crop + + @crop.setter + def crop(self, segment: Segment): + self._crop = segment + + @crop.deleter + def crop(self): + self._crop = None + + @property + def width(self): + """The width property""" + return self._width + + @width.setter + def width(self, value: int): + self._width = value + + @width.deleter + def width(self): + self._width = 20 + + def __getitem__(self, label: Label) -> LabelStyle: + """Get line style for a given label""" + if label not in self._style: + self._style[label] = next(self._style_generator) + return self._style[label] + + def setup(self, ax=None, ylim=(0, 1), yaxis=False, time=True): + import matplotlib.pyplot as plt + + if ax is None: + ax = plt.gca() + ax.set_xlim(self.crop) + if time: + ax.set_xlabel("Time") + else: + ax.set_xticklabels([]) + ax.set_ylim(ylim) + ax.axes.get_yaxis().set_visible(yaxis) + return ax + + def draw_segment(self, ax, segment: Segment, y, label=None, boundaries=True): + + # do nothing if segment is empty + if not segment: + return + + linestyle, linewidth, color = self[label] + + # draw segment + ax.hlines( + y, + segment.start, + segment.end, + color, + linewidth=linewidth, + linestyle=linestyle, + label=label, + ) + if boundaries: + ax.vlines( + segment.start, y + 0.05, y - 0.05, color, linewidth=1, linestyle="solid" + ) + ax.vlines( + segment.end, y + 0.05, y - 0.05, color, linewidth=1, linestyle="solid" + ) + + if label is None: + return + + def get_y(self, segments: Iterable[Segment]) -> np.ndarray: + """ + + Parameters + ---------- + segments : Iterable + `Segment` iterable (sorted) + + Returns + ------- + y : np.array + y coordinates of each segment + + """ + + # up_to stores the largest end time + # displayed in each line (at the current iteration) + # (at the beginning, there is only one empty line) + up_to = [-np.inf] + + # y[k] indicates on which line to display kth segment + y = [] + + for segment in segments: + # so far, we do not know which line to use + found = False + # try each line until we find one that is ok + for i, u in enumerate(up_to): + # if segment starts after the previous one + # on the same line, then we add it to the line + if segment.start >= u: + found = True + y.append(i) + up_to[i] = segment.end + break + # in case we went out of lines, create a new one + if not found: + y.append(len(up_to)) + up_to.append(segment.end) + + # from line numbers to actual y coordinates + y = 1.0 - 1.0 / (len(up_to) + 1) * (1 + np.array(y)) + + return y + + def __call__(self, resource: Resource, time: bool = True, legend: bool = True): + + if isinstance(resource, Segment): + self.plot_segment(resource, time=time) + + elif isinstance(resource, Timeline): + self.plot_timeline(resource, time=time) + + elif isinstance(resource, Annotation): + self.plot_annotation(resource, time=time, legend=legend) + + elif isinstance(resource, SlidingWindowFeature): + self.plot_feature(resource, time=time) + + def plot_segment(self, segment, ax=None, time=True): + + if not self.crop: + self.crop = segment + + ax = self.setup(ax=ax, time=time) + self.draw_segment(ax, segment, 0.5) + + def plot_timeline(self, timeline: Timeline, ax=None, time=True): + + if not self.crop and timeline: + self.crop = timeline.extent() + + cropped = timeline.crop(self.crop, mode="loose") + + ax = self.setup(ax=ax, time=time) + + for segment, y in zip(cropped, self.get_y(cropped)): + self.draw_segment(ax, segment, y) + + # ax.set_aspect(3. / self.crop.duration) + + def plot_annotation(self, annotation: Annotation, ax=None, time=True, legend=True): + + if not self.crop: + self.crop = annotation.get_timeline(copy=False).extent() + + cropped = annotation.crop(self.crop, mode="intersection") + segments = [s for s, _ in cropped.itertracks()] + + ax = self.setup(ax=ax, time=time) + + for (segment, track, label), y in zip( + cropped.itertracks(yield_label=True), self.get_y(segments) + ): + self.draw_segment(ax, segment, y, label=label) + + if legend: + H, L = ax.get_legend_handles_labels() + + # corner case when no segment is visible + if not H: + return + + # this gets exactly one legend handle and one legend label per label + # (avoids repeated legends for repeated tracks with same label) + HL = groupby( + sorted(zip(H, L), key=lambda h_l: h_l[1]), key=lambda h_l: h_l[1] + ) + H, L = zip(*[(next(h_l)[0], l) for l, h_l in HL]) + ax.legend( + H, + L, + bbox_to_anchor=(0, 1), + loc=3, + ncol=5, + borderaxespad=0.0, + frameon=False, + ) + + def plot_feature( + self, feature: SlidingWindowFeature, ax=None, time=True, ylim=None + ): + + if not self.crop: + self.crop = feature.extent + + window = feature.sliding_window + n, _dimension = feature.data.shape + ((start, stop),) = window.crop(self.crop, mode="loose", return_ranges=True) + xlim = (window[start].middle, window[stop].middle) + + start = max(0, start) + stop = min(stop, n) + t = window[0].middle + window.step * np.arange(start, stop) + data = feature[start:stop] + + if ylim is None: + m = np.nanmin(data) + M = np.nanmax(data) + ylim = (m - 0.1 * (M - m), M + 0.1 * (M - m)) + + ax = self.setup(ax=ax, yaxis=False, ylim=ylim, time=time) + ax.plot(t, data) + ax.set_xlim(xlim) + + +notebook = Notebook() + + +def repr_segment(segment: Segment): + """Get `png` data for `segment`""" + import matplotlib.pyplot as plt + from IPython.core.pylabtools import print_figure + + figsize = plt.rcParams["figure.figsize"] + plt.rcParams["figure.figsize"] = (notebook.width, 1) + fig, ax = plt.subplots() + notebook.plot_segment(segment, ax=ax) + data = print_figure(fig, "png") + plt.close(fig) + plt.rcParams["figure.figsize"] = figsize + return data + + +def repr_timeline(timeline: Timeline): + """Get `png` data for `timeline`""" + import matplotlib.pyplot as plt + from IPython.core.pylabtools import print_figure + + figsize = plt.rcParams["figure.figsize"] + plt.rcParams["figure.figsize"] = (notebook.width, 1) + fig, ax = plt.subplots() + notebook.plot_timeline(timeline, ax=ax) + data = print_figure(fig, "png") + plt.close(fig) + plt.rcParams["figure.figsize"] = figsize + return data + + +def repr_annotation(annotation: Annotation): + """Get `png` data for `annotation`""" + import matplotlib.pyplot as plt + from IPython.core.pylabtools import print_figure + + figsize = plt.rcParams["figure.figsize"] + plt.rcParams["figure.figsize"] = (notebook.width, 2) + fig, ax = plt.subplots() + notebook.plot_annotation(annotation, ax=ax) + data = print_figure(fig, "png") + plt.close(fig) + plt.rcParams["figure.figsize"] = figsize + return data + + +def repr_feature(feature: SlidingWindowFeature): + """Get `png` data for `feature`""" + import matplotlib.pyplot as plt + from IPython.core.pylabtools import print_figure + + figsize = plt.rcParams["figure.figsize"] + + if feature.data.ndim == 2: + plt.rcParams["figure.figsize"] = (notebook.width, 2) + fig, ax = plt.subplots() + notebook.plot_feature(feature, ax=ax) + data = print_figure(fig, "png") + plt.close(fig) + + elif feature.data.ndim == 3: + num_chunks = len(feature) + + if notebook.crop is None: + notebook.crop = Segment( + start=feature.sliding_window.start, + end=feature.sliding_window[num_chunks - 1].end, + ) + else: + feature = feature.crop(notebook.crop, mode="loose", return_data=False) + + num_overlap = ( + round(feature.sliding_window.duration // feature.sliding_window.step) + 1 + ) + + num_overlap = min(num_chunks, num_overlap) + + plt.rcParams["figure.figsize"] = (notebook.width, 1.5 * num_overlap) + + fig, axes = plt.subplots(nrows=num_overlap, ncols=1, squeeze=False) + axes = axes.flatten() + mini, maxi = np.nanmin(feature.data), np.nanmax(feature.data) + ylim = (mini - 0.2 * (maxi - mini), maxi + 0.2 * (maxi - mini)) + for c, (window, data) in enumerate(feature): + ax = axes[c % num_overlap] + step = duration = window.duration / len(data) + frames = SlidingWindow(start=window.start, step=step, duration=duration) + window_feature = SlidingWindowFeature(data, frames, labels=feature.labels) + notebook.plot_feature( + window_feature, + ax=ax, + time=c % num_overlap == (num_overlap - 1), + ylim=ylim, + ) + ax.set_prop_cycle(None) + data = print_figure(fig, "png") + plt.close(fig) + + plt.rcParams["figure.figsize"] = figsize + return data diff --git a/packages/core/src/pyannote/core/segment.py b/packages/core/src/pyannote/core/segment.py new file mode 100644 index 00000000..3ccb904e --- /dev/null +++ b/packages/core/src/pyannote/core/segment.py @@ -0,0 +1,922 @@ +# The MIT License (MIT) + +# Copyright (c) 2014-2021 CNRS + +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: + +# The above copyright notice and this permission notice shall be included in +# all copies or substantial portions of the Software. + +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +# AUTHORS +# Hervé BREDIN - http://herve.niderb.fr + +""" +####### +Segment +####### + +.. plot:: pyplots/segment.py + +:class:`pyannote.core.Segment` instances describe temporal fragments (*e.g.* of an audio file). The segment depicted above can be defined like that: + +.. code-block:: ipython + + In [1]: from pyannote.core import Segment + + In [2]: segment = Segment(start=5, end=15) + + In [3]: print(segment) + +It is nothing more than 2-tuples augmented with several useful methods and properties: + +.. code-block:: ipython + + In [4]: start, end = segment + + In [5]: start + + In [6]: segment.end + + In [7]: segment.duration # duration (read-only) + + In [8]: segment.middle # middle (read-only) + + In [9]: segment & Segment(3, 12) # intersection + + In [10]: segment | Segment(3, 12) # union + + In [11]: segment.overlaps(3) # does segment overlap time t=3? + + +Use `Segment.set_precision(ndigits)` to automatically round start and end timestamps to `ndigits` precision after the decimal point. +To ensure consistency between `Segment` instances, it is recommended to call this method only once, right after importing `pyannote.core.Segment`. + +.. code-block:: ipython + + In [12]: Segment(1/1000, 330/1000) == Segment(1/1000, 90/1000+240/1000) + Out[12]: False + + In [13]: Segment.set_precision(ndigits=4) + + In [14]: Segment(1/1000, 330/1000) == Segment(1/1000, 90/1000+240/1000) + Out[14]: True + +See :class:`pyannote.core.Segment` for the complete reference. +""" + +import warnings +from collections.abc import Iterable, Iterator +from dataclasses import dataclass +from typing import TYPE_CHECKING, Union + +if TYPE_CHECKING: + from .timeline import Timeline + +import numpy as np + +from .utils.types import Alignment + + +# setting 'frozen' to True makes it hashable and immutable +@dataclass(frozen=True, order=True) +class Segment: + """ + Time interval + + Parameters + ---------- + start : float + interval start time, in seconds. + end : float + interval end time, in seconds. + + + Segments can be compared and sorted using the standard operators: + + >>> Segment(0, 1) == Segment(0, 1.) + True + >>> Segment(0, 1) != Segment(3, 4) + True + >>> Segment(0, 1) < Segment(2, 3) + True + >>> Segment(0, 1) < Segment(0, 2) + True + >>> Segment(1, 2) < Segment(0, 3) + False + + Note + ---- + A segment is smaller than another segment if one of these two conditions is verified: + + - `segment.start < other_segment.start` + - `segment.start == other_segment.start` and `segment.end < other_segment.end` + + """ + + start: float = 0.0 + end: float = 0.0 + + @staticmethod + def set_precision(ndigits: int | None = None): + """Automatically round start and end timestamps to `ndigits` precision after the decimal point + + To ensure consistency between `Segment` instances, it is recommended to call this method only + once, right after importing `pyannote.core.Segment`. + + Usage + ----- + >>> from pyannote.core import Segment + >>> Segment.set_precision(2) + >>> Segment(1/3, 2/3) + + """ + global AUTO_ROUND_TIME + global SEGMENT_PRECISION + + if ndigits is None: + # backward compatibility + AUTO_ROUND_TIME = False + # 1 μs (one microsecond) + SEGMENT_PRECISION = 1e-6 + else: + AUTO_ROUND_TIME = True + SEGMENT_PRECISION = 10 ** (-ndigits) + + def __bool__(self): + """Emptiness + + >>> if segment: + ... # segment is not empty. + ... else: + ... # segment is empty. + + Note + ---- + A segment is considered empty if its end time is smaller than its + start time, or its duration is smaller than 1μs. + """ + return bool((self.end - self.start) > SEGMENT_PRECISION) + + def __post_init__(self): + """Round start and end up to SEGMENT_PRECISION precision (when required)""" + if AUTO_ROUND_TIME: + object.__setattr__( + self, + "start", + int(self.start / SEGMENT_PRECISION + 0.5) * SEGMENT_PRECISION, + ) + object.__setattr__( + self, "end", int(self.end / SEGMENT_PRECISION + 0.5) * SEGMENT_PRECISION + ) + + @property + def duration(self) -> float: + """Segment duration (read-only)""" + return self.end - self.start if self else 0.0 + + @property + def middle(self) -> float: + """Segment mid-time (read-only)""" + return 0.5 * (self.start + self.end) + + def __iter__(self) -> Iterator[float]: + """Unpack segment boundaries + >>> segment = Segment(start, end) + >>> start, end = segment + """ + yield self.start + yield self.end + + def copy(self) -> "Segment": + """Get a copy of the segment + + Returns + ------- + copy : Segment + Copy of the segment. + """ + return Segment(start=self.start, end=self.end) + + # ------------------------------------------------------- # + # Inclusion (in), intersection (&), union (|) and gap (^) # + # ------------------------------------------------------- # + + def __contains__(self, other: "Segment"): + """Inclusion + + >>> segment = Segment(start=0, end=10) + >>> Segment(start=3, end=10) in segment: + True + >>> Segment(start=5, end=15) in segment: + False + """ + return (self.start <= other.start) and (self.end >= other.end) + + def __and__(self, other): + """Intersection + + >>> segment = Segment(0, 10) + >>> other_segment = Segment(5, 15) + >>> segment & other_segment + + + Note + ---- + When the intersection is empty, an empty segment is returned: + + >>> segment = Segment(0, 10) + >>> other_segment = Segment(15, 20) + >>> intersection = segment & other_segment + >>> if not intersection: + ... # intersection is empty. + """ + start = max(self.start, other.start) + end = min(self.end, other.end) + return Segment(start=start, end=end) + + def intersects(self, other: "Segment") -> bool: + """Check whether two segments intersect each other + + Parameters + ---------- + other : Segment + Other segment + + Returns + ------- + intersect : bool + True if segments intersect, False otherwise + """ + + return ( + (self.start < other.start and other.start < self.end - SEGMENT_PRECISION) + or (self.start > other.start and self.start < other.end - SEGMENT_PRECISION) + or (self.start == other.start) + ) + + def overlaps(self, t: float) -> bool: + """Check if segment overlaps a given time + + Parameters + ---------- + t : float + Time, in seconds. + + Returns + ------- + overlap: bool + True if segment overlaps time t, False otherwise. + """ + return self.start <= t and self.end >= t + + def __or__(self, other: "Segment") -> "Segment": + """Union + + >>> segment = Segment(0, 10) + >>> other_segment = Segment(5, 15) + >>> segment | other_segment + + + Note + ---- + When a gap exists between the segment, their union covers the gap as well: + + >>> segment = Segment(0, 10) + >>> other_segment = Segment(15, 20) + >>> segment | other_segment + "Segment": + """Gap + + >>> segment = Segment(0, 10) + >>> other_segment = Segment(15, 20) + >>> segment ^ other_segment + >> segment = Segment(0, 10) + >>> empty_segment = Segment(11, 11) + >>> segment ^ empty_segment + ValueError: The gap between a segment and an empty segment is not defined. + """ + + # if segment is empty, xor is not defined + if (not self) or (not other): + raise ValueError( + "The gap between a segment and an empty segment is not defined." + ) + + start = min(self.end, other.end) + end = max(self.start, other.start) + return Segment(start=start, end=end) + + def _str_helper(self, seconds: float) -> str: + from datetime import timedelta + + negative = seconds < 0 + seconds = abs(seconds) + td = timedelta(seconds=seconds) + seconds = td.seconds + 86400 * td.days + microseconds = td.microseconds + hours, remainder = divmod(seconds, 3600) + minutes, seconds = divmod(remainder, 60) + sign = "-" if negative else " " + return ( + f"{sign}{hours:02d}:{minutes:02d}:{seconds:02d}.{microseconds // 1000:03d}" + ) + + def __str__(self): + """Human-readable representation + + >>> print(Segment(1337, 1337 + 0.42)) + [ 00:22:17.000 --> 00:22:17.420] + + Note + ---- + Empty segments are printed as "[]" + """ + if self: + return f"[{self._str_helper(self.start)} --> {self._str_helper(self.end)}]" + return "[]" + + def __repr__(self): + """Computer-readable representation + + >>> Segment(1337, 1337 + 0.42) + + """ + return f"" + + def _repr_png_(self): + """IPython notebook support + + See also + -------- + :mod:`pyannote.core.notebook` + """ + from .notebook import MATPLOTLIB_IS_AVAILABLE, MATPLOTLIB_WARNING + + if not MATPLOTLIB_IS_AVAILABLE: + warnings.warn(MATPLOTLIB_WARNING.format(klass=self.__class__.__name__)) + return None + + from .notebook import repr_segment + + try: + return repr_segment(self) + except ImportError: + warnings.warn( + f"Couldn't import matplotlib to render the vizualization for object {self}. To enable, install the required dependencies with 'pip install pyannore.core[notebook]'" + ) + return None + + +class SlidingWindow: + """Sliding window + + Parameters + ---------- + duration : float > 0, optional + Window duration, in seconds. Default is 30 ms. + step : float > 0, optional + Step between two consecutive position, in seconds. Default is 10 ms. + start : float, optional + First start position of window, in seconds. Default is 0. + end : float > `start`, optional + Default is infinity (ie. window keeps sliding forever) + + Examples + -------- + + >>> sw = SlidingWindow(duration, step, start) + >>> frame_range = (a, b) + >>> frame_range == sw.toFrameRange(sw.toSegment(*frame_range)) + ... True + + >>> segment = Segment(A, B) + >>> new_segment = sw.toSegment(*sw.toFrameRange(segment)) + >>> abs(segment) - abs(segment & new_segment) < .5 * sw.step + + >>> sw = SlidingWindow(end=0.1) + >>> print(next(sw)) + [ 00:00:00.000 --> 00:00:00.030] + >>> print(next(sw)) + [ 00:00:00.010 --> 00:00:00.040] + """ + + def __init__(self, duration=0.030, step=0.010, start=0.000, end=None): + + # duration must be a float > 0 + if duration <= 0: + raise ValueError("'duration' must be a float > 0.") + self.__duration = duration + + # step must be a float > 0 + if step <= 0: + raise ValueError("'step' must be a float > 0.") + self.__step: float = step + + # start must be a float. + self.__start: float = start + + # if end is not provided, set it to infinity + if end is None: + self.__end: float = np.inf + else: + # end must be greater than start + if end <= start: + raise ValueError("'end' must be greater than 'start'.") + self.__end: float = end + + # current index of iterator + self.__i: int = -1 + + @property + def start(self) -> float: + """Sliding window start time in seconds.""" + return self.__start + + @property + def end(self) -> float: + """Sliding window end time in seconds.""" + return self.__end + + @property + def step(self) -> float: + """Sliding window step in seconds.""" + return self.__step + + @property + def duration(self) -> float: + """Sliding window duration in seconds.""" + return self.__duration + + def closest_frame(self, t: float) -> int: + """Closest frame to timestamp. + + Parameters + ---------- + t : float + Timestamp, in seconds. + + Returns + ------- + index : int + Index of frame whose middle is the closest to `timestamp` + + """ + return int(np.rint((t - self.__start - 0.5 * self.__duration) / self.__step)) + + def samples(self, from_duration: float, mode: Alignment = "strict") -> int: + """Number of frames + + Parameters + ---------- + from_duration : float + Duration in seconds. + mode : {'strict', 'loose', 'center'} + In 'strict' mode, computes the maximum number of consecutive frames + that can be fitted into a segment with duration `from_duration`. + In 'loose' mode, computes the maximum number of consecutive frames + intersecting a segment with duration `from_duration`. + In 'center' mode, computes the average number of consecutive frames + where the first one is centered on the start time and the last one + is centered on the end time of a segment with duration + `from_duration`. + + """ + if mode == "strict": + return int(np.floor((from_duration - self.duration) / self.step)) + 1 + + elif mode == "loose": + return int(np.floor((from_duration + self.duration) / self.step)) + + elif mode == "center": + return int(np.rint(from_duration / self.step)) + + def crop( + self, + focus: Union[Segment, "Timeline"], + mode: Alignment = "loose", + fixed: float | None = None, + return_ranges: bool | None = False, + ) -> np.ndarray | list[list[int]]: + """Crop sliding window + + Parameters + ---------- + focus : `Segment` or `Timeline` + mode : {'strict', 'loose', 'center'}, optional + In 'strict' mode, only indices of segments fully included in + 'focus' support are returned. In 'loose' mode, indices of any + intersecting segments are returned. In 'center' mode, first and + last positions are chosen to be the positions whose centers are the + closest to 'focus' start and end times. Defaults to 'loose'. + fixed : float, optional + Overrides `Segment` 'focus' duration and ensures that the number of + returned frames is fixed (which might otherwise not be the case + because of rounding erros). + return_ranges : bool, optional + Return as list of ranges. Defaults to indices numpy array. + + Returns + ------- + indices : np.array (or list of ranges) + Array of unique indices of matching segments + """ + + from .timeline import Timeline + + if not isinstance(focus, (Segment, Timeline)): + msg = '"focus" must be a `Segment` or `Timeline` instance.' + raise TypeError(msg) + + if isinstance(focus, Timeline): + if fixed is not None: + msg = "'fixed' is not supported with `Timeline` 'focus'." + raise ValueError(msg) + + if return_ranges: + ranges = [] + + for i, s in enumerate(focus.support()): + rng = self.crop(s, mode=mode, fixed=fixed, return_ranges=True) + + # if first or disjoint segment, add it + if i == 0 or rng[0][0] > ranges[-1][1]: + ranges += rng + + # if overlapping segment, update last range + else: + ranges[-1][1] = rng[0][1] + + return ranges + + # concatenate all indices + indices = np.hstack( + [ + self.crop(s, mode=mode, fixed=fixed, return_ranges=False) + for s in focus.support() + ] + ) + + # remove duplicate indices + return np.unique(indices) + + # 'focus' is a `Segment` instance + + if mode == "loose": + # find smallest integer i such that + # self.start + i x self.step + self.duration >= focus.start + i_ = (focus.start - self.duration - self.start) / self.step + i = int(np.ceil(i_)) + + if fixed is None: + # find largest integer j such that + # self.start + j x self.step <= focus.end + j_ = (focus.end - self.start) / self.step + j = int(np.floor(j_)) + rng = (i, j + 1) + + else: + n = self.samples(fixed, mode="loose") + rng = (i, i + n) + + elif mode == "strict": + # find smallest integer i such that + # self.start + i x self.step >= focus.start + i_ = (focus.start - self.start) / self.step + i = int(np.ceil(i_)) + + if fixed is None: + # find largest integer j such that + # self.start + j x self.step + self.duration <= focus.end + j_ = (focus.end - self.duration - self.start) / self.step + j = int(np.floor(j_)) + rng = (i, j + 1) + + else: + n = self.samples(fixed, mode="strict") + rng = (i, i + n) + + elif mode == "center": + # find window position whose center is the closest to focus.start + i = self.closest_frame(focus.start) + + if fixed is None: + # find window position whose center is the closest to focus.end + j = self.closest_frame(focus.end) + rng = (i, j + 1) + else: + n = self.samples(fixed, mode="center") + rng = (i, i + n) + + else: + msg = "'mode' must be one of {'loose', 'strict', 'center'}." + raise ValueError(msg) + + if return_ranges: + return [list(rng)] + + return np.array(range(*rng), dtype=np.int64) + + def segmentToRange(self, segment: Segment) -> tuple[int, int]: + warnings.warn("Deprecated in favor of `segment_to_range`", DeprecationWarning) + return self.segment_to_range(segment) + + def segment_to_range(self, segment: Segment) -> tuple[int, int]: + """Convert segment to 0-indexed frame range + + Parameters + ---------- + segment : Segment + + Returns + ------- + i0 : int + Index of first frame + n : int + Number of frames + + Examples + -------- + + >>> window = SlidingWindow() + >>> print window.segment_to_range(Segment(10, 15)) + i0, n + + """ + # find closest frame to segment start + i0 = self.closest_frame(segment.start) + + # number of steps to cover segment duration + n = int(segment.duration / self.step) + 1 + + return i0, n + + def rangeToSegment(self, i0: int, n: int) -> Segment: + warnings.warn( + "This is deprecated in favor of `range_to_segment`", DeprecationWarning + ) + return self.range_to_segment(i0, n) + + def range_to_segment(self, i0: int, n: int) -> Segment: + """Convert 0-indexed frame range to segment + + Each frame represents a unique segment of duration 'step', centered on + the middle of the frame. + + The very first frame (i0 = 0) is the exception. It is extended to the + sliding window start time. + + Parameters + ---------- + i0 : int + Index of first frame + n : int + Number of frames + + Returns + ------- + segment : Segment + + Examples + -------- + + >>> window = SlidingWindow() + >>> print window.range_to_segment(3, 2) + [ --> ] + + """ + + # frame start time + # start = self.start + i0 * self.step + # frame middle time + # start += .5 * self.duration + # subframe start time + # start -= .5 * self.step + start = self.__start + (i0 - 0.5) * self.__step + 0.5 * self.__duration + duration = n * self.__step + end = start + duration + + # extend segment to the beginning of the timeline + if i0 == 0: + start = self.start + + return Segment(start, end) + + def samplesToDuration(self, nSamples: int) -> float: + warnings.warn( + "This is deprecated in favor of `samples_to_duration`", DeprecationWarning + ) + return self.samples_to_duration(nSamples) + + def samples_to_duration(self, n_samples: int) -> float: + """Returns duration of samples""" + return self.range_to_segment(0, n_samples).duration + + def durationToSamples(self, duration: float) -> int: + warnings.warn( + "This is deprecated in favor of `duration_to_samples`", DeprecationWarning + ) + return self.duration_to_samples(duration) + + def duration_to_samples(self, duration: float) -> int: + """Returns samples in duration""" + return self.segment_to_range(Segment(0, duration))[1] + + def __getitem__(self, i: int) -> Segment: + """ + Parameters + ---------- + i : int + Index of sliding window position + + Returns + ------- + segment : :class:`Segment` + Sliding window at ith position + + """ + + # window start time at ith position + start = self.__start + i * self.__step + + # in case segment starts after the end, + # return an empty segment + if start >= self.__end: + return None + + return Segment(start=start, end=start + self.__duration) + + def next(self) -> Segment: + return self.__next__() + + def __next__(self) -> Segment: + self.__i += 1 + window = self[self.__i] + + if window: + return window + else: + raise StopIteration() + + def __iter__(self) -> "SlidingWindow": + """Sliding window iterator + + Use expression 'for segment in sliding_window' + + Examples + -------- + + >>> window = SlidingWindow(end=0.1) + >>> for segment in window: + ... print(segment) + [ 00:00:00.000 --> 00:00:00.030] + [ 00:00:00.010 --> 00:00:00.040] + [ 00:00:00.020 --> 00:00:00.050] + [ 00:00:00.030 --> 00:00:00.060] + [ 00:00:00.040 --> 00:00:00.070] + [ 00:00:00.050 --> 00:00:00.080] + [ 00:00:00.060 --> 00:00:00.090] + [ 00:00:00.070 --> 00:00:00.100] + [ 00:00:00.080 --> 00:00:00.110] + [ 00:00:00.090 --> 00:00:00.120] + """ + + # reset iterator index + self.__i = -1 + return self + + def __len__(self) -> int: + """Number of positions + + Equivalent to len([segment for segment in window]) + + Returns + ------- + length : int + Number of positions taken by the sliding window + (from start times to end times) + + """ + if np.isinf(self.__end): + raise ValueError("infinite sliding window.") + + # start looking for last position + # based on frame closest to the end + i = self.closest_frame(self.__end) + + while self[i]: + i += 1 + length = i + + return length + + def copy(self) -> "SlidingWindow": + """Duplicate sliding window""" + duration = self.duration + step = self.step + start = self.start + end = self.end + sliding_window = self.__class__( + duration=duration, step=step, start=start, end=end + ) + return sliding_window + + def __call__( + self, support: Union[Segment, "Timeline"], align_last: bool = False + ) -> Iterable[Segment]: + """Slide window over support + + Parameter + --------- + support : Segment or Timeline + Support on which to slide the window. + align_last : bool, optional + Yield a final segment so that it aligns exactly with end of support. + + Yields + ------ + chunk : Segment + + Example + ------- + >>> window = SlidingWindow(duration=2., step=1.) + >>> for chunk in window(Segment(3, 7.5)): + ... print(tuple(chunk)) + (3.0, 5.0) + (4.0, 6.0) + (5.0, 7.0) + >>> for chunk in window(Segment(3, 7.5), align_last=True): + ... print(tuple(chunk)) + (3.0, 5.0) + (4.0, 6.0) + (5.0, 7.0) + (5.5, 7.5) + """ + + from pyannote.core import Timeline + + if isinstance(support, Timeline): + segments = support + + elif isinstance(support, Segment): + segments = Timeline(segments=[support]) + + else: + msg = ( + f'"support" must be either a Segment or a Timeline ' + f"instance (is {type(support)})" + ) + raise TypeError(msg) + + for segment in segments: + if segment.duration < self.duration: + continue + + window = SlidingWindow( + duration=self.duration, + step=self.step, + start=segment.start, + end=segment.end, + ) + + for s in window: + # ugly hack to account for floating point imprecision + if s in segment: + yield s + last = s + + if align_last and last.end < segment.end: + yield Segment(start=segment.end - self.duration, end=segment.end) diff --git a/packages/core/src/pyannote/core/timeline.py b/packages/core/src/pyannote/core/timeline.py new file mode 100644 index 00000000..0e4586eb --- /dev/null +++ b/packages/core/src/pyannote/core/timeline.py @@ -0,0 +1,1129 @@ +# The MIT License (MIT) + +# Copyright (c) 2014-2020 CNRS + +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: + +# The above copyright notice and this permission notice shall be included in +# all copies or substantial portions of the Software. + +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +# AUTHORS +# Hervé BREDIN - http://herve.niderb.fr +# Grant JENKS - http://www.grantjenks.com/ +# Paul LERNER + +""" +######## +Timeline +######## + +.. plot:: pyplots/timeline.py + +:class:`pyannote.core.Timeline` instances are ordered sets of non-empty +segments: + + - ordered, because segments are sorted by start time (and end time in case of tie) + - set, because one cannot add twice the same segment + - non-empty, because one cannot add empty segments (*i.e.* start >= end) + +There are two ways to define the timeline depicted above: + +.. code-block:: ipython + + In [25]: from pyannote.core import Timeline, Segment + + In [26]: timeline = Timeline() + ....: timeline.add(Segment(1, 5)) + ....: timeline.add(Segment(6, 8)) + ....: timeline.add(Segment(12, 18)) + ....: timeline.add(Segment(7, 20)) + ....: + + In [27]: segments = [Segment(1, 5), Segment(6, 8), Segment(12, 18), Segment(7, 20)] + ....: timeline = Timeline(segments=segments, uri='my_audio_file') # faster + ....: + + In [9]: for segment in timeline: + ...: print(segment) + ...: + [ 00:00:01.000 --> 00:00:05.000] + [ 00:00:06.000 --> 00:00:08.000] + [ 00:00:07.000 --> 00:00:20.000] + [ 00:00:12.000 --> 00:00:18.000] + + +.. note:: + + The optional *uri* keyword argument can be used to remember which document it describes. + +Several convenient methods are available. Here are a few examples: + +.. code-block:: ipython + + In [3]: timeline.extent() # extent + Out[3]: + + In [5]: timeline.support() # support + Out[5]: , ])> + + In [6]: timeline.duration() # support duration + Out[6]: 18 + + +See :class:`pyannote.core.Timeline` for the complete reference. +""" + +import warnings +from collections.abc import Callable, Iterable, Iterator +from typing import ( + TYPE_CHECKING, + Self, + TextIO, + Union, +) + +from sortedcontainers import SortedList + +from . import PYANNOTE_SEGMENT +from .segment import Segment +from .utils.types import CropMode, Label, Support + +# this is a moderately ugly way to import `Annotation` to the namespace +# without causing some circular imports : +# https://stackoverflow.com/questions/39740632/python-type-hinting-without-cyclic-imports +if TYPE_CHECKING: + import pandas as pd + + from .annotation import Annotation + + +# ===================================================================== +# Timeline class +# ===================================================================== + + +class Timeline: + """ + Ordered set of segments. + + A timeline can be seen as an ordered set of non-empty segments (Segment). + Segments can overlap -- though adding an already exisiting segment to a + timeline does nothing. + + Parameters + ---------- + segments : Segment iterator, optional + initial set of (non-empty) segments + uri : string, optional + name of segmented resource + + Returns + ------- + timeline : Timeline + New timeline + """ + + @classmethod + def from_df(cls, df: "pd.DataFrame", uri: str | None = None) -> "Timeline": + segments = list(df[PYANNOTE_SEGMENT]) + timeline = cls(segments=segments, uri=uri) + return timeline + + def __init__( + self, segments: Iterable[Segment] | None = None, uri: str | None = None + ): + if segments is None: + segments = () + + # set of segments (used for checking inclusion) + # Store only non-empty Segments. + segments_set = {segment for segment in segments if segment} + + self.segments_set_ = segments_set + + # sorted list of segments (used for sorted iteration) + self.segments_list_ = SortedList(segments_set) + + # sorted list of (possibly redundant) segment boundaries + boundaries = (boundary for segment in segments_set for boundary in segment) + self.segments_boundaries_ = SortedList(boundaries) + + # path to (or any identifier of) segmented resource + self.uri: str = uri + + def __len__(self): + """Number of segments + + >>> len(timeline) # timeline contains three segments + 3 + """ + return len(self.segments_set_) + + def __nonzero__(self): + return self.__bool__() + + def __bool__(self): + """Emptiness + + >>> if timeline: + ... # timeline is not empty + ... else: + ... # timeline is empty + """ + return len(self.segments_set_) > 0 + + def __iter__(self) -> Iterator[Segment]: + """Iterate over segments (in chronological order) + + >>> for segment in timeline: + ... # do something with the segment + + See also + -------- + :class:`pyannote.core.Segment` describes how segments are sorted. + """ + return iter(self.segments_list_) + + def __getitem__(self, k: int) -> Segment: + """Get segment by index (in chronological order) + + >>> first_segment = timeline[0] + >>> penultimate_segment = timeline[-2] + """ + return self.segments_list_[k] + + def __eq__(self, other: "Timeline"): + """Equality + + Two timelines are equal if and only if their segments are equal. + + >>> timeline1 = Timeline([Segment(0, 1), Segment(2, 3)]) + >>> timeline2 = Timeline([Segment(2, 3), Segment(0, 1)]) + >>> timeline3 = Timeline([Segment(2, 3)]) + >>> timeline1 == timeline2 + True + >>> timeline1 == timeline3 + False + """ + return self.segments_set_ == other.segments_set_ + + def __ne__(self, other: "Timeline"): + """Inequality""" + return self.segments_set_ != other.segments_set_ + + def index(self, segment: Segment) -> int: + """Get index of (existing) segment + + Parameters + ---------- + segment : Segment + Segment that is being looked for. + + Returns + ------- + position : int + Index of `segment` in timeline + + Raises + ------ + ValueError if `segment` is not present. + """ + return self.segments_list_.index(segment) + + def add(self, segment: Segment) -> "Timeline": + """Add a segment (in place) + + Parameters + ---------- + segment : Segment + Segment that is being added + + Returns + ------- + self : Timeline + Updated timeline. + + Note + ---- + If the timeline already contains this segment, it will not be added + again, as a timeline is meant to be a **set** of segments (not a list). + + If the segment is empty, it will not be added either, as a timeline + only contains non-empty segments. + """ + + segments_set_ = self.segments_set_ + if segment in segments_set_ or not segment: + return self + + segments_set_.add(segment) + + self.segments_list_.add(segment) + + segments_boundaries_ = self.segments_boundaries_ + segments_boundaries_.add(segment.start) + segments_boundaries_.add(segment.end) + + return self + + def remove(self, segment: Segment) -> "Timeline": + """Remove a segment (in place) + + Parameters + ---------- + segment : Segment + Segment that is being removed + + Returns + ------- + self : Timeline + Updated timeline. + + Note + ---- + If the timeline does not contain this segment, this does nothing + """ + + segments_set_ = self.segments_set_ + if segment not in segments_set_: + return self + + segments_set_.remove(segment) + + self.segments_list_.remove(segment) + + segments_boundaries_ = self.segments_boundaries_ + segments_boundaries_.remove(segment.start) + segments_boundaries_.remove(segment.end) + + return self + + def discard(self, segment: Segment) -> "Timeline": + """Same as `remove` + + See also + -------- + :func:`pyannote.core.Timeline.remove` + """ + return self.remove(segment) + + def __ior__(self, timeline: "Timeline") -> Self: + return self.update(timeline) + + def update(self, timeline: Segment) -> "Timeline": + """Add every segments of an existing timeline (in place) + + Parameters + ---------- + timeline : Timeline + Timeline whose segments are being added + + Returns + ------- + self : Timeline + Updated timeline + + Note + ---- + Only segments that do not already exist will be added, as a timeline is + meant to be a **set** of segments (not a list). + + """ + + segments_set = self.segments_set_ + + segments_set |= timeline.segments_set_ + + # sorted list of segments (used for sorted iteration) + self.segments_list_ = SortedList(segments_set) + + # sorted list of (possibly redundant) segment boundaries + boundaries = (boundary for segment in segments_set for boundary in segment) + self.segments_boundaries_ = SortedList(boundaries) + + return self + + def __or__(self, timeline: "Timeline") -> "Timeline": + return self.union(timeline) + + def union(self, timeline: "Timeline") -> "Timeline": + """Create new timeline made of union of segments + + Parameters + ---------- + timeline : Timeline + Timeline whose segments are being added + + Returns + ------- + union : Timeline + New timeline containing the union of both timelines. + + Note + ---- + This does the same as timeline.update(...) except it returns a new + timeline, and the original one is not modified. + """ + segments = self.segments_set_ | timeline.segments_set_ + return Timeline(segments=segments, uri=self.uri) + + def co_iter(self, other: "Timeline") -> Iterator[tuple[Segment, Segment]]: + """Iterate over pairs of intersecting segments + + >>> timeline1 = Timeline([Segment(0, 2), Segment(1, 2), Segment(3, 4)]) + >>> timeline2 = Timeline([Segment(1, 3), Segment(3, 5)]) + >>> for segment1, segment2 in timeline1.co_iter(timeline2): + ... print(segment1, segment2) + (, ) + (, ) + (, ) + + Parameters + ---------- + other : Timeline + Second timeline + + Returns + ------- + iterable : (Segment, Segment) iterable + Yields pairs of intersecting segments in chronological order. + """ + + for segment in self.segments_list_: + # iterate over segments that starts before 'segment' ends + temp = Segment(start=segment.end, end=segment.end) + for other_segment in other.segments_list_.irange(maximum=temp): + if segment.intersects(other_segment): + yield segment, other_segment + + def crop_iter( + self, + support: Support, + mode: CropMode = "intersection", + returns_mapping: bool = False, + ) -> Iterator[tuple[Segment, Segment] | Segment]: + """Like `crop` but returns a segment iterator instead + + See also + -------- + :func:`pyannote.core.Timeline.crop` + """ + + if mode not in {"loose", "strict", "intersection"}: + raise ValueError( + "Mode must be one of 'loose', 'strict', or 'intersection'." + ) + + if not isinstance(support, (Segment, Timeline)): + raise TypeError("Support must be a Segment or a Timeline.") + + if isinstance(support, Segment): + # corner case where "support" is empty + if support: + segments = [support] + else: + segments = [] + + support = Timeline(segments=segments, uri=self.uri) + yield from self.crop_iter( + support, mode=mode, returns_mapping=returns_mapping + ) + return + + # if 'support' is a `Timeline`, we use its support + support = support.support() + + # loose mode + if mode == "loose": + for segment, _ in self.co_iter(support): + yield segment + return + + # strict mode + if mode == "strict": + for segment, other_segment in self.co_iter(support): + if segment in other_segment: + yield segment + return + + # intersection mode + for segment, other_segment in self.co_iter(support): + mapped_to = segment & other_segment + if not mapped_to: + continue + if returns_mapping: + yield segment, mapped_to + else: + yield mapped_to + + def crop( + self, + support: Support, + mode: CropMode = "intersection", + returns_mapping: bool = False, + ) -> Union["Timeline", tuple["Timeline", dict[Segment, Segment]]]: + """Crop timeline to new support + + Parameters + ---------- + support : Segment or Timeline + If `support` is a `Timeline`, its support is used. + mode : {'strict', 'loose', 'intersection'}, optional + Controls how segments that are not fully included in `support` are + handled. 'strict' mode only keeps fully included segments. 'loose' + mode keeps any intersecting segment. 'intersection' mode keeps any + intersecting segment but replace them by their actual intersection. + returns_mapping : bool, optional + In 'intersection' mode, return a dictionary whose keys are segments + of the cropped timeline, and values are list of the original + segments that were cropped. Defaults to False. + + Returns + ------- + cropped : Timeline + Cropped timeline + mapping : dict + When 'returns_mapping' is True, dictionary whose keys are segments + of 'cropped', and values are lists of corresponding original + segments. + + Examples + -------- + + >>> timeline = Timeline([Segment(0, 2), Segment(1, 2), Segment(3, 4)]) + >>> timeline.crop(Segment(1, 3)) + ])> + + >>> timeline.crop(Segment(1, 3), mode='loose') + , ])> + + >>> timeline.crop(Segment(1, 3), mode='strict') + ])> + + >>> cropped, mapping = timeline.crop(Segment(1, 3), returns_mapping=True) + >>> print(mapping) + {: [, ]} + + """ + + if mode == "intersection" and returns_mapping: + segments, mapping = [], {} + for segment, mapped_to in self.crop_iter( + support, mode="intersection", returns_mapping=True + ): + segments.append(mapped_to) + mapping[mapped_to] = mapping.get(mapped_to, []) + [segment] + return Timeline(segments=segments, uri=self.uri), mapping + + return Timeline(segments=self.crop_iter(support, mode=mode), uri=self.uri) + + def overlapping(self, t: float) -> list[Segment]: + """Get list of segments overlapping `t` + + Parameters + ---------- + t : float + Timestamp, in seconds. + + Returns + ------- + segments : list + List of all segments of timeline containing time t + """ + return list(self.overlapping_iter(t)) + + def overlapping_iter(self, t: float) -> Iterator[Segment]: + """Like `overlapping` but returns a segment iterator instead + + See also + -------- + :func:`pyannote.core.Timeline.overlapping` + """ + boundary = Segment(start=t, end=t) + for segment in self.segments_list_.irange(maximum=boundary): + if segment.overlaps(t): + yield segment + + def get_overlap(self) -> "Timeline": + """Get overlapping parts of the timeline. + + A simple illustration: + + .. code-block:: text + + timeline + |------| |------| |----| + |--| |-----| |----------| + + timeline.get_overlap() + |--| |---| |----| + + Returns + ------- + overlap : `pyannote.core.Timeline` + Timeline of the overlaps. + """ + overlaps_tl = Timeline(uri=self.uri) + for s1, s2 in self.co_iter(self): + if s1 == s2: + continue + overlaps_tl.add(s1 & s2) + return overlaps_tl.support() + + def extrude(self, removed: Support, mode: CropMode = "intersection") -> "Timeline": + """Remove segments that overlap `removed` support. + + Parameters + ---------- + removed : Segment or Timeline + If `support` is a `Timeline`, its support is used. + mode : {'strict', 'loose', 'intersection'}, optional + Controls how segments that are not fully included in `removed` are + handled. 'strict' mode only removes fully included segments. 'loose' + mode removes any intersecting segment. 'intersection' mode removes + the overlapping part of any intersecting segment. + + Returns + ------- + extruded : Timeline + Extruded timeline + + Examples + -------- + + >>> timeline = Timeline([Segment(0, 2), Segment(1, 2), Segment(3, 5)]) + >>> timeline.extrude(Segment(1, 2)) + , ])> + + >>> timeline.extrude(Segment(1, 3), mode='loose') + ])> + + >>> timeline.extrude(Segment(1, 3), mode='strict') + , ])> + + """ + if isinstance(removed, Segment): + removed = Timeline([removed]) + + extent_tl = Timeline([self.extent()], uri=self.uri) + truncating_support = removed.gaps(support=extent_tl) + # loose for truncate means strict for crop and vice-versa + if mode == "loose": + mode = "strict" + elif mode == "strict": + mode = "loose" + return self.crop(truncating_support, mode=mode) + + def __str__(self): + """Human-readable representation + + >>> timeline = Timeline(segments=[Segment(0, 10), Segment(1, 13.37)]) + >>> print(timeline) + [[ 00:00:00.000 --> 00:00:10.000] + [ 00:00:01.000 --> 00:00:13.370]] + + """ + + n = len(self.segments_list_) + string = "[" + for i, segment in enumerate(self.segments_list_): + string += str(segment) + string += "\n " if i + 1 < n else "" + string += "]" + return string + + def __repr__(self): + """Computer-readable representation + + >>> Timeline(segments=[Segment(0, 10), Segment(1, 13.37)]) + , ])> + + """ + + return f"" + + def __contains__(self, included: Union[Segment, "Timeline"]): + """Inclusion + + Check whether every segment of `included` does exist in timeline. + + Parameters + ---------- + included : Segment or Timeline + Segment or timeline being checked for inclusion + + Returns + ------- + contains : bool + True if every segment in `included` exists in timeline, + False otherwise + + Examples + -------- + >>> timeline1 = Timeline(segments=[Segment(0, 10), Segment(1, 13.37)]) + >>> timeline2 = Timeline(segments=[Segment(0, 10)]) + >>> timeline1 in timeline2 + False + >>> timeline2 in timeline1 + >>> Segment(1, 13.37) in timeline1 + True + + """ + + if isinstance(included, Segment): + return included in self.segments_set_ + + elif isinstance(included, Timeline): + return self.segments_set_.issuperset(included.segments_set_) + + else: + raise TypeError( + "Checking for inclusion only supports Segment and Timeline instances" + ) + + def empty(self) -> "Timeline": + """Return an empty copy + + Returns + ------- + empty : Timeline + Empty timeline using the same 'uri' attribute. + + """ + return Timeline(uri=self.uri) + + def covers(self, other: "Timeline") -> bool: + """Check whether other timeline is fully covered by the timeline + + Parameter + --------- + other : Timeline + Second timeline + + Returns + ------- + covers : bool + True if timeline covers "other" timeline entirely. False if at least + one segment of "other" is not fully covered by timeline + """ + + # compute gaps within "other" extent + # this is where we should look for possible faulty segments + gaps = self.gaps(support=other.extent()) + + # if at least one gap intersects with a segment from "other", + # "self" does not cover "other" entirely --> return False + for _ in gaps.co_iter(other): + return False + + # if no gap intersects with a segment from "other", + # "self" covers "other" entirely --> return True + return True + + def copy( + self, segment_func: Callable[[Segment], Segment] | None = None + ) -> "Timeline": + """Get a copy of the timeline + + If `segment_func` is provided, it is applied to each segment first. + + Parameters + ---------- + segment_func : callable, optional + Callable that takes a segment as input, and returns a segment. + Defaults to identity function (segment_func(segment) = segment) + + Returns + ------- + timeline : Timeline + Copy of the timeline + + """ + + # if segment_func is not provided + # just add every segment + if segment_func is None: + return Timeline(segments=self.segments_list_, uri=self.uri) + + # if is provided + # apply it to each segment before adding them + return Timeline( + segments=[segment_func(s) for s in self.segments_list_], uri=self.uri + ) + + def extent(self) -> Segment: + """Extent + + The extent of a timeline is the segment of minimum duration that + contains every segments of the timeline. It is unique, by definition. + The extent of an empty timeline is an empty segment. + + A picture is worth a thousand words:: + + timeline + |------| |------| |----| + |--| |-----| |----------| + + timeline.extent() + |--------------------------------| + + Returns + ------- + extent : Segment + Timeline extent + + Examples + -------- + >>> timeline = Timeline(segments=[Segment(0, 1), Segment(9, 10)]) + >>> timeline.extent() + + + """ + if self.segments_set_: + segments_boundaries_ = self.segments_boundaries_ + start = segments_boundaries_[0] + end = segments_boundaries_[-1] + return Segment(start=start, end=end) + + return Segment(start=0.0, end=0.0) + + def support_iter(self, collar: float = 0.0) -> Iterator[Segment]: + """Like `support` but returns a segment generator instead + + See also + -------- + :func:`pyannote.core.Timeline.support` + """ + + # The support of an empty timeline is an empty timeline. + if not self: + return + + # Principle: + # * gather all segments with no gap between them + # * add one segment per resulting group (their union |) + # Note: + # Since segments are kept sorted internally, + # there is no need to perform an exhaustive segment clustering. + # We just have to consider them in their natural order. + + # Initialize new support segment + # as very first segment of the timeline + new_segment = self.segments_list_[0] + + for segment in self: + # If there is no gap between new support segment and next segment + # OR there is a gap with duration < collar seconds, + possible_gap = segment ^ new_segment + if not possible_gap or possible_gap.duration < collar: + # Extend new support segment using next segment + new_segment |= segment + + # If there actually is a gap and the gap duration >= collar + # seconds, + else: + yield new_segment + + # Initialize new support segment as next segment + # (right after the gap) + new_segment = segment + + # Add new segment to the timeline support + yield new_segment + + def support(self, collar: float = 0.0) -> "Timeline": + """Timeline support + + The support of a timeline is the timeline with the minimum number of + segments with exactly the same time span as the original timeline. It + is (by definition) unique and does not contain any overlapping + segments. + + A picture is worth a thousand words:: + + collar + |---| + + timeline + |------| |------| |----| + |--| |-----| |----------| + + timeline.support() + |------| |--------| |----------| + + timeline.support(collar) + |------------------| |----------| + + Parameters + ---------- + collar : float, optional + Merge separated by less than `collar` seconds. This is why there + are only two segments in the final timeline in the above figure. + Defaults to 0. + + Returns + ------- + support : Timeline + Timeline support + """ + return Timeline(segments=self.support_iter(collar), uri=self.uri) + + def duration(self) -> float: + """Timeline duration + + The timeline duration is the sum of the durations of the segments + in the timeline support. + + Returns + ------- + duration : float + Duration of timeline support, in seconds. + """ + + # The timeline duration is the sum of the durations + # of the segments in the timeline support. + return sum(s.duration for s in self.support_iter()) + + def gaps_iter(self, support: Support | None = None) -> Iterator[Segment]: + """Like `gaps` but returns a segment generator instead + + See also + -------- + :func:`pyannote.core.Timeline.gaps` + + """ + + if support is None: + support = self.extent() + + if not isinstance(support, (Segment, Timeline)): + raise TypeError( + "unsupported operand type(s) for -':" + f"{type(support).__name__} and Timeline." + ) + + # segment support + if isinstance(support, Segment): + # `end` is meant to store the end time of former segment + # initialize it with beginning of provided segment `support` + end = support.start + + # support on the intersection of timeline and provided segment + for segment in self.crop(support, mode="intersection").support(): + # add gap between each pair of consecutive segments + # if there is no gap, segment is empty, therefore not added + gap = Segment(start=end, end=segment.start) + if gap: + yield gap + + # keep track of the end of former segment + end = segment.end + + # add final gap (if not empty) + gap = Segment(start=end, end=support.end) + if gap: + yield gap + + # timeline support + elif isinstance(support, Timeline): + # yield gaps for every segment in support of provided timeline + for segment in support.support(): + for gap in self.gaps_iter(support=segment): + yield gap + + def gaps(self, support: Support | None = None) -> "Timeline": + """Gaps + + A picture is worth a thousand words:: + + timeline + |------| |------| |----| + |--| |-----| |----------| + + timeline.gaps() + |--| |--| + + Parameters + ---------- + support : None, Segment or Timeline + Support in which gaps are looked for. Defaults to timeline extent + + Returns + ------- + gaps : Timeline + Timeline made of all gaps from original timeline, and delimited + by provided support + + See also + -------- + :func:`pyannote.core.Timeline.extent` + + """ + return Timeline(segments=self.gaps_iter(support=support), uri=self.uri) + + def segmentation(self) -> "Timeline": + """Segmentation + + Create the unique timeline with same support and same set of segment + boundaries as original timeline, but with no overlapping segments. + + A picture is worth a thousand words:: + + timeline + |------| |------| |----| + |--| |-----| |----------| + + timeline.segmentation() + |-|--|-| |-|---|--| |--|----|--| + + Returns + ------- + timeline : Timeline + (unique) timeline with same support and same set of segment + boundaries as original timeline, but with no overlapping segments. + """ + # COMPLEXITY: O(n) + support = self.support() + + # COMPLEXITY: O(n.log n) + # get all boundaries (sorted) + # |------| |------| |----| + # |--| |-----| |----------| + # becomes + # | | | | | | | | | | | | + timestamps = set() + for start, end in self: + timestamps.add(start) + timestamps.add(end) + timestamps = sorted(timestamps) + + # create new partition timeline + # | | | | | | | | | | | | + # becomes + # |-|--|-| |-|---|--| |--|----|--| + + if len(timestamps) == 0: + return Timeline(uri=self.uri) + + segments = [] + start = timestamps[0] + for end in timestamps[1:]: + # only add segments that are covered by original timeline + segment = Segment(start=start, end=end) + if segment and support.overlapping(segment.middle): + segments.append(segment) + # next segment... + start = end + + return Timeline(segments=segments, uri=self.uri) + + def to_annotation( + self, + generator: str | Iterable[Label] | None = "string", + modality: str | None = None, + ) -> "Annotation": + """Turn timeline into an annotation + + Each segment is labeled by a unique label. + + Parameters + ---------- + generator : 'string', 'int', or iterable, optional + If 'string' (default) generate string labels. If 'int', generate + integer labels. If iterable, use it to generate labels. + modality : str, optional + + Returns + ------- + annotation : Annotation + Annotation + """ + + from .annotation import Annotation + + annotation = Annotation(uri=self.uri, modality=modality) + if generator == "string": + from .utils.generators import string_generator + + generator = string_generator() + elif generator == "int": + from .utils.generators import int_generator + + generator = int_generator() + + for segment in self: + annotation[segment] = next(generator) + + return annotation + + def _iter_uem(self) -> Iterator[str]: + """Generate lines for a UEM file for this timeline + + Returns + ------- + iterator: Iterator[str] + An iterator over UEM text lines + """ + uri = self.uri if self.uri else "" + if isinstance(uri, str) and " " in uri: + msg = ( + f"Space-separated UEM file format does not allow file URIs " + f'containing spaces (got: "{uri}").' + ) + raise ValueError(msg) + for segment in self: + yield f"{uri} 1 {segment.start:.3f} {segment.end:.3f}\n" + + def to_uem(self) -> str: + """Serialize timeline as a string using UEM format + + Returns + ------- + serialized: str + UEM string + """ + return "".join([line for line in self._iter_uem()]) + + def write_uem(self, file: TextIO): + """Dump timeline to file using UEM format + + Parameters + ---------- + file : file object + + Usage + ----- + >>> with open('file.uem', 'w') as file: + ... timeline.write_uem(file) + """ + file.writelines(self._iter_uem()) + + def _repr_png_(self): + """IPython notebook support + + See also + -------- + :mod:`pyannote.core.notebook` + """ + from .notebook import MATPLOTLIB_IS_AVAILABLE, MATPLOTLIB_WARNING + + if not MATPLOTLIB_IS_AVAILABLE: + warnings.warn(MATPLOTLIB_WARNING.format(klass=self.__class__.__name__)) + return None + + from .notebook import repr_timeline + + return repr_timeline(self) diff --git a/packages/core/src/pyannote/core/utils/__init__.py b/packages/core/src/pyannote/core/utils/__init__.py new file mode 100644 index 00000000..12988155 --- /dev/null +++ b/packages/core/src/pyannote/core/utils/__init__.py @@ -0,0 +1,24 @@ +# The MIT License (MIT) + +# Copyright (c) 2018 CNRS + +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: + +# The above copyright notice and this permission notice shall be included in +# all copies or substantial portions of the Software. + +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +# AUTHORS +# Hervé BREDIN - http://herve.niderb.fr diff --git a/packages/core/src/pyannote/core/utils/cluster.py b/packages/core/src/pyannote/core/utils/cluster.py new file mode 100644 index 00000000..cf22af26 --- /dev/null +++ b/packages/core/src/pyannote/core/utils/cluster.py @@ -0,0 +1,120 @@ +# The MIT License (MIT) + +# Copyright (c) 2018 CNRS + +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: + +# The above copyright notice and this permission notice shall be included in +# all copies or substantial portions of the Software. + +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +# AUTHORS +# Hervé BREDIN - http://herve.niderb.fr + +from collections import Counter + +import numpy as np +from scipy.spatial.distance import squareform + +from .distance import pdist + + +def chinese_whispers_clustering( + X, t, method="distance", metric="euclidean", max_iter=1000, init=None +): + """Chinese whispers clustering + + Parameters + ---------- + X : `np.ndarray` + (n_samples, n_dimensions) feature vectors. + t : + method : `str` + Method use to build neighboring graph. Defaults to 'distance'. + No other method is available yet. + metric : `str` + The distance metric to use. See `pdist` function for a list of valid + distance metrics. Defaults to 'euclidean'. + max_iter : `int` + Maximum number of iterations. Defaults to 1000. + init : `np.ndarray` + (n_samples, ) array. Initial cluster number. + Defauts to each item in its own cluster. + + Returns + ------- + T : `np.ndarray` + (n_samples, ) array. T[i] is the cluster number to which + original observation i belongs. + + Reference + --------- + Chris Biemann. "Chinese Whispers - an Efficient Graph Clustering Algorithm + and its Application to Natural Language Processing Problems". Workshop on + TextGraphs, at HLT-NAACL 2006. + + """ + + # TODO. add support for 'precomputed' metric + + if method == "distance": + distance = pdist(X, metric=metric) + neighbors = squareform(distance < t) + + # mark item with no neighbor as their own neighbor + has_no_neighbor = np.sum(neighbors, axis=1) == 0 + for i in range(len(X)): + neighbors[i, i] = has_no_neighbor[i] + elif method == "knn": + msg = "only 'distance' method is supported for now." + raise NotImplementedError(msg) + # neighbors = np.argpartition(squareform(distance), t, axis=1)[:,:t] + else: + msg = "only 'distance' method is supported for now." + raise NotImplementedError(msg) + + if init is None: + # initialize one cluster per item + clusters = np.arange(len(X)) + else: + # or use provided initialization + clusters = np.array(init).reshape(-1) + + # list of indices used to iterate over all items + indices = np.arange(len(X)) + + for _ in range(max_iter): + # keep track of current state + prev_clusters = np.copy(clusters) + + # loop on all items in randomized order + # TODO: option to set random seed for reproducibility + np.random.shuffle(indices) + for i in indices: + # count number of neighbors in each cluster + counts = Counter(clusters[neighbors[i]]) + # assign item to most common neighbor cluster + clusters[i] = counts.most_common(n=1)[0][0] + + # ratio of items that have changed clusters + changed = np.mean(clusters != prev_clusters) + + # stop early if not much has changed since last iteration + if changed > 1e-4: + break + + # relabel clusters between 1 and K + _, clusters = np.unique(clusters, return_inverse=True) + return clusters + 1 diff --git a/packages/core/src/pyannote/core/utils/distance.py b/packages/core/src/pyannote/core/utils/distance.py new file mode 100644 index 00000000..335212e3 --- /dev/null +++ b/packages/core/src/pyannote/core/utils/distance.py @@ -0,0 +1,237 @@ +# The MIT License (MIT) + +# Copyright (c) 2018 CNRS + +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: + +# The above copyright notice and this permission notice shall be included in +# all copies or substantial portions of the Software. + +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +# AUTHORS +# Hervé BREDIN - http://herve.niderb.fr + +import numpy as np +import scipy.cluster.hierarchy +import scipy.spatial.distance + + +def l2_normalize(X: np.ndarray): + """L2 normalize vectors + + Parameters + ---------- + X : `np.ndarray` + (n_samples, n_dimensions) vectors. + + Returns + ------- + normalized : `np.ndarray` + (n_samples, n_dimensions) L2-normalized vectors + + """ + + norm = np.sqrt(np.sum(X**2, axis=1)) + norm[norm == 0] = 1.0 + return (X.T / norm).T + + +def dist_range(metric="euclidean", normalize=False): + """Return range of possible distance between two vectors + + Parameters + ---------- + metric : `str`, optional + Metric. Defaults to 'euclidean' + normalize : `bool`, optional + Set to True if vectors are L2-normalized. Defaults to False. + + Returns + ------- + min_dist, max_dist : `float` + Range of possible distance. + """ + + if metric == "euclidean": + if normalize: + return (0.0, 2.0) + return (0.0, np.inf) + + if metric == "sqeuclidean": + if normalize: + return (0.0, 4.0) + return (0.0, np.inf) + + if metric == "cosine": + return (0.0, 2.0) + + if metric == "angular": + return (0.0, np.pi) + + msg = f"dist_range does not support {metric} metric." + raise NotImplementedError(msg) + + +def _pdist_func_1D(X, func): + """Helper function for pdist""" + + (n_items,) = X.shape + + if n_items < 2: + return np.array([]) + + distances = [] + + for i in range(n_items - 1): + distance = func(X[i], X[i + 1 :]) + distances.append(distance) + + return np.hstack(distances) + + +def pdist(fX, metric="euclidean", **kwargs): + """Same as scipy.spatial.distance with support for additional metrics + + * 'angular': pairwise angular distance + * 'equal': pairwise equality check (only for 1-dimensional fX) + * 'minimum': pairwise minimum (only for 1-dimensional fX) + * 'maximum': pairwise maximum (only for 1-dimensional fX) + * 'average': pairwise average (only for 1-dimensional fX) + """ + + if metric == "angular": + cosine = scipy.spatial.distance.pdist(fX, metric="cosine", **kwargs) + return np.arccos(np.clip(1.0 - cosine, -1.0, 1.0)) + + elif metric == "equal": + assert fX.ndim == 1, f"'{metric}' metric only supports 1-dimensional fX." + return _pdist_func_1D(fX, lambda x, X: x == X) + + elif metric == "minimum": + assert fX.ndim == 1, f"'{metric}' metric only supports 1-dimensional fX." + return _pdist_func_1D(fX, np.minimum) + + elif metric == "maximum": + assert fX.ndim == 1, f"'{metric}' metric only supports 1-dimensional fX." + return _pdist_func_1D(fX, np.maximum) + + elif metric == "average": + assert fX.ndim == 1, f"'{metric}' metric only supports 1-dimensional fX." + return _pdist_func_1D(fX, lambda x, X: 0.5 * (x + X)) + + else: + return scipy.spatial.distance.pdist(fX, metric=metric, **kwargs) + + +def _cdist_func_1D(X_trn, X_tst, func): + """Helper function for cdist""" + return np.vstack(func(x_trn, X_tst) for x_trn in iter(X_trn)) + + +def cdist(fX_trn, fX_tst, metric="euclidean", **kwargs): + """Same as scipy.spatial.distance.cdist with support for additional metrics + + * 'angular': pairwise angular distance + * 'equal': pairwise equality check (only for 1-dimensional fX) + * 'minimum': pairwise minimum (only for 1-dimensional fX) + * 'maximum': pairwise maximum (only for 1-dimensional fX) + * 'average': pairwise average (only for 1-dimensional fX) + """ + + if metric == "angular": + cosine = scipy.spatial.distance.cdist(fX_trn, fX_tst, metric="cosine", **kwargs) + return np.arccos(np.clip(1.0 - cosine, -1.0, 1.0)) + + elif metric == "equal": + assert fX_trn.ndim == 1 and fX_tst.ndim == 1, ( + f"'{metric}' metric only supports 1-dimensional fX_trn and fX_tst." + ) + return _cdist_func_1D(fX_trn, fX_tst, lambda x_trn, X_tst: x_trn == X_tst) + + elif metric == "minimum": + assert fX_trn.ndim == 1 and fX_tst.ndim == 1, ( + f"'{metric}' metric only supports 1-dimensional fX_trn and fX_tst." + ) + return _cdist_func_1D(fX_trn, fX_tst, np.minimum) + + elif metric == "maximum": + assert fX_trn.ndim == 1 and fX_tst.ndim == 1, ( + f"'{metric}' metric only supports 1-dimensional fX_trn and fX_tst." + ) + return _cdist_func_1D(fX_trn, fX_tst, np.maximum) + + elif metric == "average": + assert fX_trn.ndim == 1 and fX_tst.ndim == 1, ( + f"'{metric}' metric only supports 1-dimensional fX_trn and fX_tst." + ) + return _cdist_func_1D( + fX_trn, fX_tst, lambda x_trn, X_tst: 0.5 * (x_trn + X_tst) + ) + + else: + return scipy.spatial.distance.cdist(fX_trn, fX_tst, metric=metric, **kwargs) + + +def to_condensed(n, i, j): + """Compute index in condensed pdist matrix + + V + 0 | . 0 1 2 3 + -> 1 | . . 4 5 6 <- ==> 0 1 2 3 4 5 6 7 8 9 + 2 | . . . 7 8 ^ + 3 | . . . . 9 + 4 | . . . . . + ---------- + 0 1 2 3 4 + + Parameters + ---------- + n : int + Number of inputs in squared pdist matrix + i, j : `int` or `numpy.ndarray` + Indices in squared pdist matrix + + Returns + ------- + k : `int` or `numpy.ndarray` + Index in condensed pdist matrix + """ + i, j = np.array(i), np.array(j) + if np.any(i == j): + raise ValueError("i and j should be different.") + i, j = np.minimum(i, j), np.maximum(i, j) + return np.int64(i * n - i * i / 2 - 3 * i / 2 + j - 1) + + +def to_squared(n, k): + """Compute indices in squared matrix + + Parameters + ---------- + n : int + Number of inputs in squared pdist matrix + k : `int` or `numpy.ndarray` + Index in condensed pdist matrix + + Returns + ------- + i, j : `int` or `numpy.ndarray` + Indices in squared pdist matrix + + """ + k = np.array(k) + i = np.int64(n - np.sqrt(-8 * k + 4 * n**2 - 4 * n + 1) / 2 - 1 / 2) + j = np.int64(i**2 / 2 - i * n + 3 * i / 2 + k + 1) + return i, j diff --git a/packages/core/src/pyannote/core/utils/generators.py b/packages/core/src/pyannote/core/utils/generators.py new file mode 100644 index 00000000..d33849d7 --- /dev/null +++ b/packages/core/src/pyannote/core/utils/generators.py @@ -0,0 +1,84 @@ +# The MIT License (MIT) + +# Copyright (c) 2014-2018 CNRS + +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: + +# The above copyright notice and this permission notice shall be included in +# all copies or substantial portions of the Software. + +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +# AUTHORS +# Hervé BREDIN - http://herve.niderb.fr + +import itertools +from collections.abc import Iterable, Iterator +from string import ascii_uppercase + + +def pairwise(iterable: Iterable): + """s -> (s0,s1), (s1,s2), (s2, s3), ...""" + a, b = itertools.tee(iterable) + next(b, None) + return zip(a, b) + + +def string_generator(skip: list | set | None = None) -> Iterator[str]: + """Label generator + + Parameters + ---------- + skip : list or set + List of labels that must be skipped. + This option is useful in case you want to make sure generated labels + are different from a pre-existing set of labels. + + Usage + ----- + t = string_generator() + next(t) -> 'A' # start with 1-letter labels + ... # from A to Z + next(t) -> 'Z' + next(t) -> 'AA' # then 2-letters labels + next(t) -> 'AB' # from AA to ZZ + ... + next(t) -> 'ZY' + next(t) -> 'ZZ' + next(t) -> 'AAA' # then 3-letters labels + ... # (you get the idea) + """ + if skip is None: + skip = [] + + # label length + r = 1 + + # infinite loop + while True: + # generate labels with current length + for c in itertools.product(ascii_uppercase, repeat=r): + if c in skip: + continue + yield "".join(c) + + # increment label length when all possibilities are exhausted + r = r + 1 + + +def int_generator() -> Iterator[int]: + i = 0 + while True: + yield i + i = i + 1 diff --git a/packages/core/src/pyannote/core/utils/helper.py b/packages/core/src/pyannote/core/utils/helper.py new file mode 100644 index 00000000..fe3e79df --- /dev/null +++ b/packages/core/src/pyannote/core/utils/helper.py @@ -0,0 +1,64 @@ +# The MIT License (MIT) + +# Copyright (c) 2018 CNRS + +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: + +# The above copyright notice and this permission notice shall be included in +# all copies or substantial portions of the Software. + +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +# AUTHORS +# Hervé BREDIN - http://herve.niderb.fr + +from importlib import import_module + + +def get_class_by_name(class_name: str, default_module_name: str | None = None) -> type: + """Load class by its name + + Parameters + ---------- + class_name : `str` + default_module_name : `str`, optional + When provided and `class_name` does not contain the absolute path + + Returns + ------- + Klass : `type` + Class. + + Example + ------- + >>> ClopiNet = get_class_by_name( + ... 'pyannote.audio.embedding.models.ClopiNet') + >>> ClopiNet = get_class_by_name( + ... 'ClopiNet', default_module_name='pyannote.audio.embedding.models') + """ + tokens = class_name.split(".") + + if len(tokens) == 1: + if default_module_name is None: + msg = ( + f'Could not infer module name from class name "{class_name}".' + f"Please provide default module name." + ) + raise ValueError(msg) + module_name = default_module_name + else: + module_name = ".".join(tokens[:-1]) + class_name = tokens[-1] + + return getattr(import_module(module_name), class_name) diff --git a/packages/core/src/pyannote/core/utils/hierarchy.py b/packages/core/src/pyannote/core/utils/hierarchy.py new file mode 100644 index 00000000..e7cf21e5 --- /dev/null +++ b/packages/core/src/pyannote/core/utils/hierarchy.py @@ -0,0 +1,455 @@ +# The MIT License (MIT) + +# Copyright (c) 2018 CNRS + +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: + +# The above copyright notice and this permission notice shall be included in +# all copies or substantial portions of the Software. + +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +# AUTHORS +# Hervé BREDIN - http://herve.niderb.fr + +""" +============================================================== +Hierarchical clustering (:mod:`pyannote.core.utils.hierarchy`) +============================================================== + +""" + +from collections import Counter +from collections.abc import Callable +from inspect import signature + +import numpy as np +import scipy.cluster.hierarchy +from scipy.sparse import csr_matrix +from scipy.sparse.csgraph import connected_components +from scipy.spatial.distance import squareform + +from .distance import cdist, l2_normalize, pdist, to_condensed, to_squared + + +def linkage(X, method="single", metric="euclidean", **kwargs): + """Same as scipy.cluster.hierarchy.linkage with more metrics and methods""" + + if method == "pool": + return pool(X, metric=metric, **kwargs) + + # corner case when using non-euclidean distances with methods + # designed for the euclidean distance + if metric != "euclidean" and method in ["centroid", "median", "ward"]: + # Those 3 methods only work with 'euclidean' distance. + # Therefore, one has to unit-normalized embeddings before + # comparison in case they were optimized for 'cosine' (or 'angular') + # distance. + X = l2_normalize(X) + metric = "euclidean" + + distance = pdist(X, metric=metric) + return scipy.cluster.hierarchy.linkage( + distance, method=method, metric=metric, **kwargs + ) + + +def _average_pooling_func( + u: int, + v: int, + S: np.ndarray = None, + C: np.ndarray = None, + **kwargs, +) -> np.ndarray: + """Compute average of newly merged cluster + + Parameters + ---------- + u : int + Cluster index. + v : int + Cluster index. + C : (2 x n_observations - 1, dimension) np.ndarray + Cluster average. + S : (2 x n_observations - 1, ) np.ndarray + Cluster size. + + Returns + ------- + Cuv : (dimension, ) np.ndarray + Average of newly formed cluster. + """ + return (C[u] * S[u] + C[v] * S[v]) / (S[u] + S[v]) + + +def _centroid_pooling_func( + u: int, + v: int, + X: np.ndarray = None, + d: np.ndarray = None, + K: np.ndarray = None, + **kwargs, +) -> np.ndarray: + """Compute centroid of newly merged cluster + + Parameters + ---------- + u : int + Cluster index. + v : int + Cluster index. + X : (n_observations, dimension) np.ndarray + Observations. + d : (n_observations, n_obversations) np.ndarray + Distance between observations. + K : (n_observations, ) np.ndarray, optional + Cluster assignment. + + Returns + ------- + Cuv : (dimension, ) np.ndarray + Centroid of newly formed cluster. + """ + u_or_v = np.where(np.isin(K, [u, v]))[0] + i = np.argmin(np.mean(d[u_or_v][:, u_or_v], axis=0)) + return X[u_or_v[i]] + + +def propagate_constraints( + cannot_link: list[tuple[int, int]], must_link: list[tuple[int, int]] +): + + # expand list of "cannot link" constraints thanks to the following rule + # (u != v) & (v == w) ==> u != w + + cannot_link = {tuple(sorted(uv)) for uv in cannot_link} + while True: + new_cannot_link = [] + for x, y in must_link: + for u, v in cannot_link: + ij = tuple(sorted({u, v}.symmetric_difference({x, y}))) + if not ij: + msg = ( + f"Found a conflict between 'must_link' and " + f"'cannot_link' constraints for pair ({u}, {v})." + ) + raise ValueError(msg) + if len(ij) == 2 and ij not in cannot_link: + new_cannot_link.append(ij) + if new_cannot_link: + cannot_link.update(new_cannot_link) + else: + break + + return list(cannot_link) + + +def pool( + X: np.ndarray, + metric: str = "euclidean", + pooling_func: str | Callable = "average", + cannot_link: list[tuple[int, int]] | None = None, + must_link: list[tuple[int, int]] | None = None, + must_link_method: str = "both", +): + """'pool' linkage + + Parameters + ---------- + X : np.ndarray + (n_samples, dimension) obversations. + metric : {"euclidean", "cosine", "angular"}, optional + Distance metric. Defaults to "euclidean" + pooling_func: callable, optional + Defaults to "average". + cannot_link : list of pairs, optional + Pairs of indices of observations that cannot be linked. For instance, + [(1, 2), (5, 6)] means that first and second observations cannot end up + in the same cluster, as well as 5th and 6th obversations. + must_link : list of pairs, optional + Pairs of indices of observations that must be linked. For instance, + [(1, 2), (5, 6)] means that first and second observations must end up + in the same cluster, as well as 5th and 6th obversations. + must_link_method : {"merge", "propagate", "both"}, optional + Method used for taking "must link" constraints into account. + * use "merge" to initialize clusters by merging "must link" observations + before any other regular clustering iterations. + * use "propagate" to infer additional "cannot link" constraints by + applying the following propagation rule: + if u and v cannot be linked and v and w must be linked, + then u and w cannot be linked. + * use "both" to apply both methods. + Defaults to "both". + """ + + if pooling_func == "average": + pooling_func = _average_pooling_func + + elif pooling_func == "centroid": + pooling_func = _centroid_pooling_func + + elif isinstance(pooling_func, str): + msg = ( + f"{pooling_func} pooling is not supported. Choose between " + f"'average' and 'centroid', or provide your own function." + ) + raise ValueError(msg) + + if cannot_link is None: + cannot_link = [] + + if must_link is None: + must_link = [] + + # obtain number of original observations + n, dimension = X.shape + + # compute similarity matrix + d = pdist(X, metric=metric) + + # K[j] contains the index of the cluster to which + # the jth observation is currently assigned + K = np.arange(n) + + # S[k] contains the current size of kth cluster + S = np.zeros(2 * n - 1, dtype=np.int16) + S[:n] = 1 + + # C[k] contains the centroid of kth cluster + C = np.zeros((2 * n - 1, dimension)) + # at the beginning, each observation is assigned to its own cluster + C[:n, :] = X + + # clustering tree (aka dendrogram) + # Z[i, 0] and Z[i, 1] are merged at ith iteration + # Z[i, 2] is the distance between Z[i, 0] and Z[i, 1] + # Z[i, 3] is the total number of original observation in the newly formed cluster + Z = np.zeros((n - 1, 4)) + + # convert condensed pdist matrix for the `n` original observation to a + # condensed pdist matrix for the `2n-1` clusters (including the `n` + # original observations) that will exist at some point during the process. + D = np.inf * np.ones((2 * n - 1) * (2 * n - 2) // 2) + D[to_condensed(2 * n - 1, *to_squared(n, np.arange(n * (n - 1) // 2)))] = d + + if "d" in signature(pooling_func).parameters: + d = squareform(d) + + def merge(u, v, iteration, constraint=False): + """Merge two clusters + + Parameters + ---------- + u, v : int + Indices of clusters to merge. + iteration : int + Current clustering iteration. + constraint : bool + Set to True to indicate that this merge is coming from a 'must_link' + constraint. This will artificially set Z[iteration, 2] to 0.0. + + Returns + ------- + uv : int + Indices of resulting cluster. + + Raises + ------ + "ValueError" in case of conflict between "must_link" and "cannot_link" + constraints. + + """ + + k = to_condensed(2 * n - 1, u, v) + + if constraint and D[k] == np.inf: + w = u if u < n else v + msg = f"Found a conflict between 'must_link' and 'cannot_link' constraints for observation {w}." + raise ValueError(msg) + + # keep track of ... + # ... which clusters are merged at this iteration + # Place the larger child first; preserve input order for equal sizes. + Z[iteration, 0] = v if S[v] > S[u] else u + Z[iteration, 1] = u if Z[iteration, 0] == v else v + + # ... their distance + Z[iteration, 2] = 0.0 if constraint else D[k] + + # ... the size of the newly formed cluster + Z[iteration, 3] = S[u] + S[v] + S[n + iteration] = S[u] + S[v] + + # compute "representation" of newly formed cluster + C[n + iteration] = pooling_func(u, v, X=X, d=d, K=K, S=S, C=C) + + # merged clusters are now empty... + S[u] = 0 + S[v] = 0 + + # move observations of merged clusters into the newly formed cluster + K[K == u] = n + iteration + K[K == v] = n + iteration + + # compute distance to newly formed cluster + # (only for clusters that still exists, i.e. those that are not empty) + empty = S[: n + iteration] == 0 + k = to_condensed(2 * n - 1, n + iteration, np.arange(n + iteration)[~empty]) + D[k] = cdist( + C[np.newaxis, n + iteration, :], + C[: n + iteration, :][~empty, :], + metric=metric, + ) + + # condensed indices of all (u, _) and (v, _) pairs + _u = to_condensed(2 * n - 1, u, np.arange(u)) + u_ = to_condensed(2 * n - 1, u, np.arange(u + 1, n + iteration)) + _v = to_condensed(2 * n - 1, v, np.arange(v)) + v_ = to_condensed(2 * n - 1, v, np.arange(v + 1, n + iteration)) + + # propagate "cannot link" constraints to newly formed cluster + if cannot_link: + x, _ = to_squared(2 * n - 1, _u[D[_u] == np.inf]) + D[to_condensed(2 * n - 1, n + iteration, x)] = np.inf + _, x = to_squared(2 * n - 1, u_[D[u_] == np.inf]) + D[to_condensed(2 * n - 1, n + iteration, x)] = np.inf + x, _ = to_squared(2 * n - 1, _v[D[_v] == np.inf]) + D[to_condensed(2 * n - 1, n + iteration, x)] = np.inf + _, x = to_squared(2 * n - 1, v_[D[v_] == np.inf]) + D[to_condensed(2 * n - 1, n + iteration, x)] = np.inf + + # distance to merged clusters u and v no longer exist + D[_u] = np.inf + D[u_] = np.inf + D[_v] = np.inf + D[v_] = np.inf + + k = to_condensed(2 * n - 1, n + iteration, np.arange(n + iteration)[empty]) + D[k] = np.inf + + return n + iteration + + iteration = 0 + + if cannot_link: + if must_link_method in ["propagate", "both"]: + cannot_link = propagate_constraints(cannot_link, must_link) + + # take "cannot link" constraints into account by artifically setting the + # distance between corresponding observations to infinity. + u, v = zip(*cannot_link) + D[to_condensed(2 * n - 1, u, v)] = np.inf + + # take "must link" constraints into account by merging corresponding + # observations regardless of their actual similarity. this might lead to + # weird clustering results when merged observations are very dissimilar. + if must_link_method in ["merge", "both"] and must_link: + # find connected components in "must link" graph + graph = np.zeros((n, n), dtype=np.int8) + for u, v in must_link: + graph[u, v] = 1 + _, K_init = connected_components( + csr_matrix(graph), directed=False, return_labels=True + ) + + # merge observations within each connected components + for k, count in Counter(K_init).items(): + if count < 2: + continue + u, *others = np.where(K_init == k)[0] + for v in others: + u = merge(u, v, iteration, constraint=True) + iteration += 1 + + # iterate until one cluster remains + start_iteration = iteration + for iteration in range(start_iteration, n - 1): + # find two most similar clusters + k = np.argmin(D) + + # when cannot_link constraints prevents any further merging, + # choose an arbitrary (u, v) pair among remaining clusters + if D[k] == np.inf: + u, v, *_ = np.where(S > 0)[0] + else: + u, v = to_squared(2 * n - 1, k) + + _ = merge(u, v, iteration) + + # return dendrogram + return Z + + +def fcluster_auto(X, Z, metric="euclidean"): + """Forms flat clusters using within-class sum of square elbow criterion + + Parameters + ---------- + X : `np.ndarray` + (n_samples, n_dimensions) feature vectors. + Z : `np.ndarray` + The hierarchical clustering encoded with the matrix returned by the + `linkage` function. + metric : `str` + The distance metric to use. See `pdist` function for a list of valid + distance metrics. + + Returns + ------- + T : ndarray + An array of length n. T[i] is the flat cluster number to which + original observation i belongs. + + Reference + --------- + H. Delgado, X. Anguerra, C. Fredouille, J. Serrano. "Fast Single- and + Cross-Show Speaker Diarization Using Binary Key Speaker Modeling". + IEEE Transactions on Audio Speech and Language Processing + """ + + # within-class sum of squares + wcss = [] + for threshold in Z[:, 2]: + y_t = scipy.cluster.hierarchy.fcluster(Z, threshold, criterion="distance") + D = [] + for k in np.unique(y_t): + Xk = X[y_t == k] + Ck = np.mean(Xk, axis=0, keepdims=True) + D.append( + cdist(Ck, Xk, metric=metric).reshape( + -1, + ) + ) + wcss.append(np.mean(np.hstack(D) ** 2)) + wcss = np.array(wcss) + + # elbow criterion + n = len(X) + + # after first step, there n-1 clusters (x1) + x1, y1 = n - 1, wcss[0] + # after last step, there is 1 cluster (x2) + x2, y2 = 1, wcss[-1] + + # equation of line passing at both points + # ax + by + c = 0 + a = (y2 - y1) / (x2 - x1) + b = 1 + c = (x2 * y1 - x1 * y2) / (x1 - x2) + + # elbow is at maximum distance to this line + distance = np.abs(a * np.arange(1, n) + b * wcss + c) / np.sqrt(a**2 + b**2) + threshold = Z[np.argmax(distance), 2] + + return scipy.cluster.hierarchy.fcluster(Z, threshold, criterion="distance") diff --git a/packages/core/src/pyannote/core/utils/numpy.py b/packages/core/src/pyannote/core/utils/numpy.py new file mode 100644 index 00000000..9906669b --- /dev/null +++ b/packages/core/src/pyannote/core/utils/numpy.py @@ -0,0 +1,192 @@ +# The MIT License (MIT) + +# Copyright (c) 2018 CNRS + +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: + +# The above copyright notice and this permission notice shall be included in +# all copies or substantial portions of the Software. + +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +# AUTHORS +# Hervé BREDIN - http://herve.niderb.fr + + +import numpy as np + +from ..annotation import Annotation +from ..feature import SlidingWindowFeature +from ..segment import Segment, SlidingWindow +from ..timeline import Timeline +from .generators import string_generator + + +def one_hot_encoding( + annotation: Annotation, + support: Segment | Timeline, + window: SlidingWindow | SlidingWindowFeature, + labels: list[str] | None = None, + mode: str = "center", +) -> SlidingWindowFeature: + """Convert annotation to one-hot-encoded numpy array + + Parameters + ---------- + annotation : `pyannote.core.Annotation` + support : `pyannote.core.Timeline` or `pyannote.core.Segment` + window : `SlidingWindow` + Use this `window`. + labels : list, optional + Predefined list of labels. Defaults to using labels in `annotation`. + + Returns + ------- + y : SlidingWindowFeature + (N, K) array where y[t, k] > 0 when labels[k] is active at timestep t. + y[t, k] = -1 means we have no idea. + + See also + -------- + See `one_hot_decoding` to convert `y` back to a `pyannote.core.Annotation` + instance + """ + + if not isinstance(window, SlidingWindow): + if hasattr(window, "sliding_window"): + window = window.sliding_window + else: + msg = ( + "`window` must be an instance of `SlidingWindow` " + "or have an attribute called 'sliding_window'." + ) + raise TypeError(msg) + + if isinstance(support, Segment): + extent = support + support = Timeline([support]) + else: + extent = support.extent() + + window = SlidingWindow( + start=extent.start, step=window.step, duration=window.duration + ) + + n_samples = window.samples(extent.duration, mode=mode) + + # defaults to `labels` contained by `annotation` + labels = annotation.labels() if labels is None else labels + indices = {label: i for i, label in enumerate(labels)} + + # one-hot encoding + # -1 = unknown / +1 = active / 0 = inactive + y = -np.ones((n_samples, len(labels)), dtype=np.int8) + for i, j in window.crop(support, mode=mode, return_ranges=True): + i = max(0, min(n_samples, i)) + j = max(0, min(n_samples, j)) + y[i:j, :] = 0 + + for label in annotation.labels(): + try: + k = indices[label] + except KeyError: + msg = f'List of `labels` does not contain label "{label}".' + print(indices.keys()) + raise ValueError(msg) + + for i, j in window.crop( + annotation.label_timeline(label), mode=mode, return_ranges=True + ): + i = max(0, min(n_samples, i)) + j = max(0, min(n_samples, j)) + y[i:j, k] += 1 + + y = np.minimum(y, 1, out=y) + + return SlidingWindowFeature(y, window, labels=labels) + + +def one_hot_decoding(y, window, labels=None): + """Convert one-hot-encoded numpy array to annotation + + Parameters + ---------- + y : (N, K) or (N, ) `numpy.ndarray` + When y has shape (N, K), y[t, k] > 0 means kth label is active at + timestep t. When y has shape (N, ), y[t] = 0 means no label is active + at timestep t, y[t] = k means (k-1)th label is active. + window : `SlidingWindow` + Use this `window`. + labels : list, optional + Predefined list of labels. Defaults to labels generated by + `pyannote.core.utils.generators.string_generator`. + + Returns + ------- + annotation : `pyannote.core.Annotation` + + See also + -------- + `one_hot_encoding` + """ + + if not isinstance(window, SlidingWindow): + if hasattr(window, "sliding_window"): + window = window.sliding_window + else: + msg = ( + "`window` must be an instance of `SlidingWindow` " + "or have an attribute called 'sliding_window'." + ) + raise TypeError(msg) + + # if y has shape (N, ), convert it to (N, K) shape + if len(y.shape) < 2: + (N,) = y.shape + + # estimate the number of classes + if labels is not None: + K = len(labels) + else: + K = np.max(y) + + # convert to (N, K) shape + # y[t, k] = 1 means kth class is active + y_ = np.zeros((N, K), dtype=np.int64) + for t, k in enumerate(y): + if k > 0: + y_[t, k - 1] = 1 + y = y_ + + N, K = y.shape + + # generate label names when not provided + if labels is None: + labels = string_generator() + labels = [next(labels) for _ in range(K)] + + annotation = Annotation() + + y_off = np.zeros((1, K), dtype=np.int64) + y = np.vstack((y_off, y, y_off)) + diff = np.diff(y, axis=0) + for k, label in enumerate(labels): + for t in np.where(diff[:, k] != 0)[0]: + if diff[t, k] > 0: + onset_t = window[t].middle + else: + segment = Segment(onset_t, window[t].middle) + annotation[segment, k] = label + + return annotation diff --git a/packages/core/src/pyannote/core/utils/random.py b/packages/core/src/pyannote/core/utils/random.py new file mode 100644 index 00000000..f15c0279 --- /dev/null +++ b/packages/core/src/pyannote/core/utils/random.py @@ -0,0 +1,115 @@ +# The MIT License (MIT) + +# Copyright (c) 2020 CNRS + +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: + +# The above copyright notice and this permission notice shall be included in +# all copies or substantial portions of the Software. + +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +# AUTHORS +# Hervé BREDIN - http://herve.niderb.fr + + +from collections.abc import Iterable, Iterator + +import numpy as np + +from pyannote.core import Segment + + +def random_segment( + segments: Iterable[Segment], weighted: bool = False +) -> Iterator[Segment]: + """Generate segment with probability proportional to its duration + + Parameters + ---------- + segments : Segment iterable + Segments. + weighted : bool, optional + When True, yield segments with probability proportional to their + duration. Defaults to yield segments with uniform probability. + + Yields + ------ + segment : `Segment` + """ + + p = None + if weighted: + total = float(sum(s.duration for s in segments)) + p = [s.duration / total for s in segments] + + n_segments = len(segments) + while True: + i = np.random.choice(n_segments, p=p) + yield segments[i] + + +def random_subsegment( + segment: Segment, duration: float, min_duration: float | None = None +) -> Iterator[Segment]: + """Pick a subsegment at random + + Parameters + ---------- + segment : Segment + duration : float + Duration of random subsegment + min_duration : float, optional + When provided, choose segment duration at random between `min_duration` + and `duration` (instead of fixed `duration`). + + Yields + ------ + segment : `Segment` + + Usage + ----- + >>> for subsegment in random_subsegment(segment, duration): + >>> ... # do something with subsegment + >>> ... pass + + >>> generator = random_subsegment(segment, duration) + >>> subsegment = next(generator) + """ + if min_duration is None: + if duration > segment.duration: + msg = ( + f"`duration` (= {duration:g}) should be smaller " + f"than `segment` duration (= {segment.duration:g})." + ) + raise ValueError(msg) + + while True: + # draw start time from [segment.start, segment.end - duration] + t = segment.start + np.random.random() * (segment.duration - duration) + yield Segment(t, t + duration) + + else: + # make sure max duration is smaller than actual segment duration + max_duration = min(segment.duration, duration) + + while True: + # draw duration from [min_duration, max_duration] interval + rnd_duration = min_duration + np.random.random() * ( + max_duration - min_duration + ) + + # draw start from [segment.start, segment.end - rnd_duration] interval + t = segment.start + np.random.random() * (segment.duration - rnd_duration) + yield Segment(t, t + rnd_duration) diff --git a/packages/core/src/pyannote/core/utils/types.py b/packages/core/src/pyannote/core/utils/types.py new file mode 100644 index 00000000..7651fae7 --- /dev/null +++ b/packages/core/src/pyannote/core/utils/types.py @@ -0,0 +1,19 @@ +from collections.abc import Hashable, Iterator +from typing import TYPE_CHECKING, Literal, Union + +if TYPE_CHECKING: + from ..annotation import Annotation + from ..feature import SlidingWindowFeature + from ..segment import Segment + from ..timeline import Timeline + +Label = Hashable +Support = Union["Segment", "Timeline"] +LabelGeneratorMode = Literal["int", "string"] +LabelGenerator = LabelGeneratorMode | Iterator[Label] +TrackName = str | int +Key = Union["Segment", tuple["Segment", TrackName]] +Resource = Union["Segment", "Timeline", "SlidingWindowFeature", "Annotation"] +CropMode = Literal["intersection", "loose", "strict"] +Alignment = Literal["center", "loose", "strict"] +LabelStyle = tuple[str, int, tuple[float, float, float]] diff --git a/packages/core/tests/__init__.py b/packages/core/tests/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/packages/core/tests/test_annotations.py b/packages/core/tests/test_annotations.py new file mode 100644 index 00000000..28aa28b7 --- /dev/null +++ b/packages/core/tests/test_annotations.py @@ -0,0 +1,242 @@ +import pandas as pd +import pytest + +from pyannote.core import ( + PYANNOTE_LABEL, + PYANNOTE_SEGMENT, + PYANNOTE_TRACK, + Annotation, + Segment, + Timeline, +) + + +@pytest.fixture +def annotation(): + annotation = Annotation( + uri="TheBigBangTheory.Season01.Episode01", modality="speaker" + ) + annotation[Segment(3, 5), "_"] = "Penny" + annotation[Segment(5.5, 7), "_"] = "Leonard" + annotation[Segment(8, 10), "_"] = "Penny" + annotation[Segment(8, 10), "anything"] = "Sheldon" + + return annotation + + +def test_crop(annotation): + expected = Annotation(uri="TheBigBangTheory.Season01.Episode01", modality="speaker") + expected[Segment(5.5, 7), "_"] = "Leonard" + expected[Segment(8, 9), "_"] = "Penny" + expected[Segment(8, 9), "anything"] = "Sheldon" + actual = annotation.crop(Segment(5, 9)) + assert actual == expected, str(actual) + + +def test_crop_loose(annotation): + expected = Annotation(uri="TheBigBangTheory.Season01.Episode01", modality="speaker") + expected[Segment(5.5, 7), "_"] = "Leonard" + expected[Segment(8, 10), "_"] = "Penny" + expected[Segment(8, 10), "anything"] = "Sheldon" + actual = annotation.crop(Segment(5, 9), mode="loose") + assert actual == expected, str(actual) + + +def test_crop_strict(annotation): + expected = Annotation(uri="TheBigBangTheory.Season01.Episode01", modality="speaker") + expected[Segment(5.5, 7), "_"] = "Leonard" + actual = annotation.crop(Segment(5, 9), mode="strict") + assert actual == expected, str(actual) + + +def test_copy(annotation): + copy = annotation.copy() + assert copy == annotation + + +def test_creation(annotation): + assert list(annotation.itersegments()) == [ + Segment(3, 5), + Segment(5.5, 7), + Segment(8, 10), + ] + + assert list(annotation.itertracks()) == [ + (Segment(3, 5), "_"), + (Segment(5.5, 7), "_"), + (Segment(8, 10), "_"), + (Segment(8, 10), "anything"), + ] + + assert list(annotation.itertracks(yield_label=True)) == [ + (Segment(3, 5), "_", "Penny"), + (Segment(5.5, 7), "_", "Leonard"), + (Segment(8, 10), "_", "Penny"), + (Segment(8, 10), "anything", "Sheldon"), + ] + + +def test_segments(annotation): + assert annotation.get_timeline(copy=False) == Timeline( + [Segment(3, 5), Segment(5.5, 7), Segment(8, 10)], + uri="TheBigBangTheory.Season01.Episode01", + ) + + +def test_segments_copy(annotation): + assert annotation.get_timeline(copy=True) == Timeline( + [Segment(3, 5), Segment(5.5, 7), Segment(8, 10)], + uri="TheBigBangTheory.Season01.Episode01", + ) + + +def test_tracks(annotation): + assert not annotation.has_track(Segment(8, 10), "---") + assert annotation.get_tracks(Segment(8, 10)) == {"_", "anything"} + + assert list(annotation.rename_tracks().itertracks()) == [ + (Segment(3, 5), "A"), + (Segment(5.5, 7), "B"), + (Segment(8, 10), "C"), + (Segment(8, 10), "D"), + ] + + +def test_labels(annotation): + assert annotation.labels() == ["Leonard", "Penny", "Sheldon"] + assert annotation.get_labels(Segment(8, 10)) == {"Penny", "Sheldon"} + + expected_res = Annotation( + uri="TheBigBangTheory.Season01.Episode01", modality="speaker" + ) + expected_res[Segment(3, 5), "_"] = "Kaley Cuoco" + expected_res[ + Segment(5.5, 7), + "_", + ] = "Johnny Galecki" + expected_res[Segment(8, 10), "_"] = "Kaley Cuoco" + expected_res[Segment(8, 10), "anything"] = "Jim Parsons" + + mapping = { + "Penny": "Kaley Cuoco", + "Sheldon": "Jim Parsons", + "Leonard": "Johnny Galecki", + } + assert annotation.rename_labels(mapping) == expected_res + + +def test_analyze(annotation): + assert annotation.label_duration("Penny") == 4 + assert annotation.chart() == [("Penny", 4), ("Sheldon", 2), ("Leonard", 1.5)] + assert annotation.argmax() == "Penny" + + +def test_rename_labels(annotation): + actual = annotation.rename_labels() + expected = Annotation(uri="TheBigBangTheory.Season01.Episode01", modality="speaker") + expected[Segment(3, 5), "_"] = "B" + expected[ + Segment(5.5, 7), + "_", + ] = "A" + expected[Segment(8, 10), "_"] = "B" + expected[Segment(8, 10), "anything"] = "C" + assert actual == expected + + +def test_relabel_tracks(annotation): + actual = annotation.relabel_tracks() + expected = Annotation(uri="TheBigBangTheory.Season01.Episode01", modality="speaker") + expected[Segment(3, 5), "_"] = "A" + expected[ + Segment(5.5, 7), + "_", + ] = "B" + expected[Segment(8, 10), "_"] = "C" + expected[Segment(8, 10), "anything"] = "D" + assert actual == expected + + +def test_support(annotation): + actual = annotation.support(collar=3.5) + expected = Annotation(uri="TheBigBangTheory.Season01.Episode01", modality="speaker") + expected[Segment(3, 10), "B"] = "Penny" + expected[Segment(5.5, 7), "A"] = "Leonard" + expected[Segment(8, 10), "C"] = "Sheldon" + assert actual == expected + + +def test_from_records(annotation): + # Check that we can reconstruct an annotation from the + # output of itertracks. + records = annotation.itertracks(yield_label=True) + actual = Annotation.from_records(records) + expected = annotation + assert actual == expected + + +def test_from_df(annotation): + # Check that we can reconstruct an annotation from a Pandas + # dataframe containing its tracks. + column_names = [PYANNOTE_SEGMENT, PYANNOTE_TRACK, PYANNOTE_LABEL] + df = pd.DataFrame.from_records(annotation.itertracks(True), columns=column_names) + actual = Annotation.from_df(df) + expected = annotation + assert actual == expected + + +def test_extrude(): + annotation = Annotation() + annotation[Segment(0, 10)] = "A" + annotation[Segment(15, 20)] = "A" + annotation[Segment(20, 35)] = "B" + annotation[Segment(15, 25)] = "C" + annotation[Segment(30, 35)] = "C" + + extrusion_tl = Timeline([Segment(5, 12), Segment(14, 25)]) + + intersection_expected = Annotation() + intersection_expected[Segment(0, 5)] = "A" + intersection_expected[Segment(25, 35)] = "B" + intersection_expected[Segment(30, 35)] = "C" + + assert ( + annotation.extrude(extrusion_tl, mode="intersection") == intersection_expected + ) + + loose_expected = Annotation() + loose_expected[Segment(30, 35)] = "C" + + assert annotation.extrude(extrusion_tl, mode="loose") == loose_expected + + strict_expected = Annotation() + strict_expected[Segment(0, 10)] = "A" + strict_expected[Segment(20, 35)] = "B" + strict_expected[Segment(30, 35)] = "C" + + assert annotation.extrude(extrusion_tl, mode="strict") == strict_expected + + +def test_get_overlap(): + annotation = Annotation() + annotation[Segment(0, 5)] = "A" + annotation[Segment(10, 15)] = "A" + annotation[Segment(20, 25)] = "A" + + annotation[Segment(0, 10)] = "B" + annotation[Segment(15, 25)] = "B" + + annotation[Segment(5, 10)] = "C" + annotation[Segment(20, 30)] = "C" + + assert annotation.get_overlap() == Timeline([Segment(0, 10), Segment(20, 25)]) + + assert annotation.get_overlap(["A", "B"]) == Timeline( + [Segment(0, 5), Segment(20, 25)] + ) + + assert annotation.get_overlap(["A", "C"]) == Timeline([Segment(20, 25)]) + + assert annotation.get_overlap(["B", "C"]) == Timeline( + [Segment(5, 10), Segment(20, 25)] + ) diff --git a/packages/core/tests/test_features.py b/packages/core/tests/test_features.py new file mode 100644 index 00000000..dc9b9833 --- /dev/null +++ b/packages/core/tests/test_features.py @@ -0,0 +1,86 @@ +import numpy as np +import pytest + +from pyannote.core import Segment, SlidingWindow, SlidingWindowFeature + + +@pytest.fixture +def features(): + data = np.arange(20).reshape(2, 10).T + window = SlidingWindow(start=0.0, step=1.0, duration=2.0) + return SlidingWindowFeature(data, window) + + +@pytest.fixture +def one_feature(): + return SlidingWindowFeature(np.array([[[0, 0, 0]], [[1, 1, 1]]]), SlidingWindow()) + + +@pytest.fixture +def segment(): + return Segment(3.3, 6.7) + + +def test_crop_loose(features, segment): + actual = features.crop(segment, mode="loose") + expected = np.array([[2, 3, 4, 5, 6], [12, 13, 14, 15, 16]]).T + np.testing.assert_array_equal(expected, actual) + + +def test_crop_strict(features, segment): + actual = features.crop(segment, mode="strict") + expected = np.array( + [ + [ + 4, + ], + [ + 14, + ], + ] + ).T + np.testing.assert_array_equal(expected, actual) + + +def test_crop_center(features, segment): + actual = features.crop(segment, mode="center") + expected = np.array([[2, 3, 4, 5, 6], [12, 13, 14, 15, 16]]).T + np.testing.assert_array_equal(expected, actual) + + +def test_crop_fixed(features, segment): + actual = features.crop(segment, mode="center", fixed=4.0) + expected = np.array([[2, 3, 4, 5], [12, 13, 14, 15]]).T + np.testing.assert_array_equal(expected, actual) + + +def test_crop_out_of_bounds(features): + segment = Segment(-6, -1) + actual = features.crop(segment, mode="strict") + expected = np.empty((0, 2)) + np.testing.assert_array_equal(expected, actual) + + +def test_crop_fixed_out_of_bounds(features): + segment = Segment(-2, 6.7) + actual = features.crop(segment, mode="center", fixed=8.7) + expected = np.array( + [[0, 0, 0, 0, 1, 2, 3, 4, 5], [10, 10, 10, 10, 11, 12, 13, 14, 15]] + ).T + np.testing.assert_array_equal(expected, actual) + + +def test_repr_png(features): + pytest.importorskip("IPython") + pytest.importorskip("matplotlib") + expected = b"\x89PNG" + actual = features._repr_png_()[:4] + assert expected == actual + + +def test_repr_png_one_feature(one_feature): + pytest.importorskip("IPython") + pytest.importorskip("matplotlib") + expected = b"\x89PNG" + actual = one_feature._repr_png_()[:4] + assert expected == actual diff --git a/packages/core/tests/test_hierarchy.py b/packages/core/tests/test_hierarchy.py new file mode 100644 index 00000000..9d13a305 --- /dev/null +++ b/packages/core/tests/test_hierarchy.py @@ -0,0 +1,41 @@ +import numpy as np +import pytest +from scipy.cluster.hierarchy import is_valid_linkage + +from pyannote.core.utils.hierarchy import pool + + +@pytest.mark.parametrize("pooling_func", ["average", "centroid"]) +def test_pool_unconstrained(pooling_func): + tree = pool(np.array([[0.0], [1.0], [10.0]]), pooling_func=pooling_func) + assert is_valid_linkage(tree) + np.testing.assert_array_equal(tree[:, 3], [2, 3]) + assert set(tree[0, :2]) == {0, 1} + assert set(tree[1, :2]) == {2, 3} + np.testing.assert_allclose( + tree[:, 2], [1, 9.5 if pooling_func == "average" else 10] + ) + + +def test_pool_orders_larger_child_first_during_must_link_merges(): + tree = pool( + np.array([[0.0], [1.0], [2.0], [20.0]]), + must_link=[(0, 1), (1, 2)], + ) + assert is_valid_linkage(tree) + # The second merge combines cluster 4 (two points) with point 2. + # The final merge combines cluster 5 (three points) with point 3. + np.testing.assert_array_equal(tree[1:, :2], [[4, 2], [5, 3]]) + np.testing.assert_allclose(tree[:, 2:], [[0, 2], [0, 3], [19, 4]]) + + +def test_pool_cannot_link_remains_separate_until_infinite_distance(): + tree = pool(np.array([[0.0], [1.0], [10.0]]), cannot_link=[(0, 1)]) + assert set(tree[0, :2]) == {1, 2} + assert np.isinf(tree[-1, 2]) + assert tree[-1, 3] == 3 + + +def test_pool_conflicting_constraints(): + with pytest.raises(ValueError, match="conflict"): + pool(np.array([[0.0], [1.0]]), must_link=[(0, 1)], cannot_link=[(0, 1)]) diff --git a/packages/core/tests/test_segment.py b/packages/core/tests/test_segment.py new file mode 100644 index 00000000..aa9f5a6d --- /dev/null +++ b/packages/core/tests/test_segment.py @@ -0,0 +1,55 @@ +from pyannote.core import Segment +from tests.utils import preserve_segment_state + + +def test_creation(): + + s = 1.0 + e = 9.0 + segment = Segment(start=s, end=e) + + assert str(segment) == "[ 00:00:01.000 --> 00:00:09.000]" + assert segment.end == 9 + assert segment.duration == 8 + assert segment.middle == 5 + + +def test_intersection(): + + segment = Segment(start=1, end=9) + other_segment = Segment(4, 13) + + assert segment.intersects(other_segment) + assert segment & other_segment == Segment(4, 9) + + other_segment = Segment(13, 20) + + assert not segment.intersects(other_segment) + + +def test_inclusion(): + + segment = Segment(start=1, end=9) + other_segment = Segment(5, 9) + + print(other_segment in segment) + assert other_segment in segment + assert not segment.overlaps(23) + + +def test_other_operation(): + + segment = Segment(start=1, end=9) + other_segment = Segment(10, 30) + assert segment | other_segment == Segment(1, 30) + + other_segment = Segment(14, 15) + assert segment ^ other_segment == Segment(9, 14) + + +@preserve_segment_state +def test_segment_precision_mode(): + Segment.set_precision(None) + assert Segment(90 / 1000, 90 / 1000 + 240 / 1000) != Segment(90 / 1000, 330 / 1000) + Segment.set_precision(4) + assert Segment(90 / 1000, 90 / 1000 + 240 / 1000) == Segment(90 / 1000, 330 / 1000) diff --git a/packages/core/tests/test_timeline.py b/packages/core/tests/test_timeline.py new file mode 100644 index 00000000..e07a805a --- /dev/null +++ b/packages/core/tests/test_timeline.py @@ -0,0 +1,271 @@ +# The MIT License (MIT) + +# Copyright (c) 2016-2017 CNRS + +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: + +# The above copyright notice and this permission notice shall be included in +# all copies or substantial portions of the Software. + +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +# AUTHORS +# Hervé BREDIN - http://herve.niderb.fr + +import pytest + +from pyannote.core import Annotation, Segment, Timeline +from tests.utils import preserve_segment_state + + +@pytest.fixture +def timeline(): + t = Timeline(uri="MyAudioFile") + t.add(Segment(6, 8)) + t.add(Segment(0.5, 3)) + t.add(Segment(8.5, 10)) + t.add(Segment(1, 4)) + t.add(Segment(5, 7)) + t.add(Segment(7, 8)) + + return t + + +def test_to_annotation(timeline): + expected = Annotation(uri="MyAudioFile", modality="MyModality") + expected[Segment(6, 8)] = "D" + expected[Segment(0.5, 3)] = "A" + expected[Segment(8.5, 10)] = "F" + expected[Segment(1, 4)] = "B" + expected[Segment(5, 7)] = "C" + expected[Segment(7, 8)] = "E" + assert expected == timeline.to_annotation(modality="MyModality") + + +def test_iteration(timeline): + assert list(timeline) == [ + Segment(0.5, 3), + Segment(1, 4), + Segment(5, 7), + Segment(6, 8), + Segment(7, 8), + Segment(8.5, 10), + ] + + +def test_remove(timeline): + timeline.remove(Segment(1, 4)) + timeline.remove(Segment(5, 7)) + assert list(timeline) == [ + Segment(0.5, 3), + Segment(6, 8), + Segment(7, 8), + Segment(8.5, 10), + ] + + +def test_getter(timeline): + assert len(timeline) == 6 + assert str(timeline[1]) == "[ 00:00:01.000 --> 00:00:04.000]" + + +def test_getter_negative(timeline): + assert timeline[-2] == Segment(7, 8) + + +def test_remove_and_extent(): + t = Timeline(uri="MyAudioFile") + t.add(Segment(6, 8)) + t.add(Segment(7, 9)) + t.add(Segment(6, 9)) + + t.remove(Segment(6, 9)) + assert t.extent() == Segment(6, 9) + + +def test_extent(timeline): + assert timeline.extent() == Segment(0.5, 10) + + +def test_support(timeline): + # No collar (default). + assert list(timeline.support()) == [ + Segment(0.5, 4), + Segment(5, 8), + Segment(8.5, 10), + ] + + # Collar of 600 ms. + assert list(timeline.support(0.600)) == [Segment(0.5, 4), Segment(5, 10)] + + +def test_gaps(timeline): + assert list(timeline.gaps()) == [Segment(4, 5), Segment(8, 8.5)] + + +@preserve_segment_state +def test_empty_gaps(): + empty_timeline = Timeline(uri="MyEmptyGaps") + assert list(empty_timeline.gaps()) == [] + Segment.set_precision(3) + assert list(empty_timeline.gaps()) == [] + + +def test_crop(timeline): + selection = Segment(3, 7) + + expected_answer = Timeline(uri="MyAudioFile") + expected_answer.add(Segment(3, 4)) + expected_answer.add(Segment(5, 7)) + expected_answer.add(Segment(6, 7)) + + assert timeline.crop(selection, mode="intersection") == expected_answer + + expected_answer = Timeline(uri="MyAudioFile") + expected_answer.add(Segment(5, 7)) + assert timeline.crop(selection, mode="strict") == expected_answer + + expected_answer = Timeline(uri="pouet") + expected_answer.add(Segment(1, 4)) + expected_answer.add(Segment(5, 7)) + expected_answer.add(Segment(6, 8)) + + assert timeline.crop(selection, mode="loose") == expected_answer + + +def test_crop_mapping(): + timeline = Timeline([Segment(0, 2), Segment(1, 2), Segment(3, 4)]) + cropped, mapping = timeline.crop(Segment(1, 2), returns_mapping=True) + + expected_cropped = Timeline([Segment(1, 2)]) + assert cropped == expected_cropped + + expected_mapping = {Segment(1, 2): [Segment(0, 2), Segment(1, 2)]} + assert mapping == expected_mapping + + +def test_union(): + first_timeline = Timeline([Segment(0, 1), Segment(2, 3), Segment(4, 5)]) + second_timeline = Timeline([Segment(1.5, 4.5)]) + + assert first_timeline.union(second_timeline) == Timeline( + [Segment(0, 1), Segment(1.5, 4.5), Segment(2, 3), Segment(4, 5)] + ) + + assert second_timeline.crop(first_timeline) == Timeline( + [Segment(2, 3), Segment(4, 4.5)] + ) + + assert list(first_timeline.co_iter(second_timeline)) == [ + (Segment(2, 3), Segment(1.5, 4.5)), + (Segment(4, 5), Segment(1.5, 4.5)), + ] + + +def test_union_extent(): + first_timeline = Timeline([Segment(0, 1), Segment(2, 3), Segment(4, 5)]) + second_timeline = Timeline([Segment(1.5, 6)]) + + union_timeline = first_timeline.union(second_timeline) + assert union_timeline.extent() == Segment(0, 6) + + +def test_update_extent(): + timeline = Timeline([Segment(0, 1), Segment(2, 3), Segment(4, 5)]) + other_timeline = Timeline([Segment(1.5, 6)]) + timeline.update(other_timeline) + assert timeline.extent() == Segment(0, 6) + + +def test_timeline_overlaps(): + overlapped_tl = Timeline(uri="La menuiserie mec") + overlapped_tl.add(Segment(0, 10)) + overlapped_tl.add(Segment(5, 10)) + overlapped_tl.add(Segment(15, 20)) + overlapped_tl.add(Segment(18, 23)) + + expected_overlap = Timeline() + expected_overlap.add(Segment(5, 10)) + expected_overlap.add(Segment(18, 20)) + + assert expected_overlap == overlapped_tl.get_overlap() + + +def test_extrude(): + removed = Segment(2, 5) + + timeline = Timeline(uri="KINGJU") + timeline.add(Segment(0, 3)) + timeline.add(Segment(2, 5)) + timeline.add(Segment(6, 7)) + + expected_answer = Timeline() + expected_answer.add(Segment(0, 2)) + expected_answer.add(Segment(6, 7)) + + assert timeline.extrude(removed, mode="intersection") == expected_answer + + expected_answer = Timeline(uri="MCSALO") + expected_answer.add(Segment(0, 3)) + expected_answer.add(Segment(6, 7)) + assert timeline.extrude(removed, mode="strict") == expected_answer + + expected_answer = Timeline(uri="CADILLAC") + expected_answer.add(Segment(6, 7)) + + assert timeline.extrude(removed, mode="loose") == expected_answer + + +def test_initialized_with_empty_segments(): + # The first timeline includes empty segments. + first_timeline = Timeline( + [Segment(1, 5), Segment(6, 6), Segment(7, 7), Segment(8, 10)] + ) + + # The second has no empty segments. + second_timeline = Timeline([Segment(1, 5), Segment(8, 10)]) + + assert first_timeline == second_timeline + + +def test_added_empty_segments(): + # The first timeline includes empty segments. + first_timeline = Timeline() + first_timeline.add(Segment(1, 5)) + first_timeline.add(Segment(6, 6)) + first_timeline.add(Segment(7, 7)) + first_timeline.add(Segment(8, 10)) + + # The second has no empty segments. + second_timeline = Timeline() + second_timeline.add(Segment(1, 5)) + second_timeline.add(Segment(8, 10)) + + assert first_timeline == second_timeline + + +def test_consistent_timelines_with_empty_segments(): + # The first timeline is initialized with Segments, some empty. + first_timeline = Timeline( + [Segment(1, 5), Segment(6, 6), Segment(7, 7), Segment(8, 10)] + ) + + # The second timeline adds one Segment at a time, including empty ones. + second_timeline = Timeline() + second_timeline.add(Segment(1, 5)) + second_timeline.add(Segment(6, 6)) + second_timeline.add(Segment(7, 7)) + second_timeline.add(Segment(8, 10)) + + assert first_timeline == second_timeline diff --git a/packages/core/tests/utils.py b/packages/core/tests/utils.py new file mode 100644 index 00000000..1d24d74d --- /dev/null +++ b/packages/core/tests/utils.py @@ -0,0 +1,16 @@ +from functools import wraps + +from pyannote.core import segment + + +def preserve_segment_state(f): + @wraps(f) + def wrapper(*args, **kwargs): + prev_round_time = segment.AUTO_ROUND_TIME + try: + ret = f(*args, **kwargs) + finally: + segment.AUTO_ROUND_TIME = prev_round_time + return ret + + return wrapper diff --git a/packages/core/uv.lock b/packages/core/uv.lock new file mode 100644 index 00000000..21649dc7 --- /dev/null +++ b/packages/core/uv.lock @@ -0,0 +1,1403 @@ +version = 1 +revision = 3 +requires-python = ">=3.11" +resolution-markers = [ + "python_full_version >= '3.12'", + "python_full_version < '3.12'", +] + +[[package]] +name = "alabaster" +version = "1.0.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/a6/f8/d9c74d0daf3f742840fd818d69cfae176fa332022fd44e3469487d5a9420/alabaster-1.0.0.tar.gz", hash = "sha256:c00dca57bca26fa62a6d7d0a9fcce65f3e026e9bfe33e9c538fd3fbb2144fd9e", size = 24210, upload-time = "2024-07-26T18:15:03.762Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7e/b3/6b4067be973ae96ba0d615946e314c5ae35f9f993eca561b356540bb0c2b/alabaster-1.0.0-py3-none-any.whl", hash = "sha256:fc6786402dc3fcb2de3cabd5fe455a2db534b371124f1f21de8731783dec828b", size = 13929, upload-time = "2024-07-26T18:15:02.05Z" }, +] + +[[package]] +name = "appnope" +version = "0.1.4" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/35/5d/752690df9ef5b76e169e68d6a129fa6d08a7100ca7f754c89495db3c6019/appnope-0.1.4.tar.gz", hash = "sha256:1de3860566df9caf38f01f86f65e0e13e379af54f9e4bee1e66b48f2efffd1ee", size = 4170, upload-time = "2024-02-06T09:43:11.258Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/81/29/5ecc3a15d5a33e31b26c11426c45c501e439cb865d0bff96315d86443b78/appnope-0.1.4-py2.py3-none-any.whl", hash = "sha256:502575ee11cd7a28c0205f379b525beefebab9d161b7c964670864014ed7213c", size = 4321, upload-time = "2024-02-06T09:43:09.663Z" }, +] + +[[package]] +name = "asttokens" +version = "3.0.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/4a/e7/82da0a03e7ba5141f05cce0d302e6eed121ae055e0456ca228bf693984bc/asttokens-3.0.0.tar.gz", hash = "sha256:0dcd8baa8d62b0c1d118b399b2ddba3c4aff271d0d7a9e0d4c1681c79035bbc7", size = 61978, upload-time = "2024-11-30T04:30:14.439Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/25/8a/c46dcc25341b5bce5472c718902eb3d38600a903b14fa6aeecef3f21a46f/asttokens-3.0.0-py3-none-any.whl", hash = "sha256:e3078351a059199dd5138cb1c706e6430c05eff2ff136af5eb4790f9d28932e2", size = 26918, upload-time = "2024-11-30T04:30:10.946Z" }, +] + +[[package]] +name = "babel" +version = "2.17.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/7d/6b/d52e42361e1aa00709585ecc30b3f9684b3ab62530771402248b1b1d6240/babel-2.17.0.tar.gz", hash = "sha256:0c54cffb19f690cdcc52a3b50bcbf71e07a808d1c80d549f2459b9d2cf0afb9d", size = 9951852, upload-time = "2025-02-01T15:17:41.026Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b7/b8/3fe70c75fe32afc4bb507f75563d39bc5642255d1d94f1f23604725780bf/babel-2.17.0-py3-none-any.whl", hash = "sha256:4d0b53093fdfb4b21c92b5213dba5a1b23885afa8383709427046b21c366e5f2", size = 10182537, upload-time = "2025-02-01T15:17:37.39Z" }, +] + +[[package]] +name = "certifi" +version = "2025.1.31" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/1c/ab/c9f1e32b7b1bf505bf26f0ef697775960db7932abeb7b516de930ba2705f/certifi-2025.1.31.tar.gz", hash = "sha256:3d5da6925056f6f18f119200434a4780a94263f10d1c21d032a6f6b2baa20651", size = 167577, upload-time = "2025-01-31T02:16:47.166Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/38/fc/bce832fd4fd99766c04d1ee0eead6b0ec6486fb100ae5e74c1d91292b982/certifi-2025.1.31-py3-none-any.whl", hash = "sha256:ca78db4565a652026a4db2bcdf68f2fb589ea80d0be70e03929ed730746b84fe", size = 166393, upload-time = "2025-01-31T02:16:45.015Z" }, +] + +[[package]] +name = "cffi" +version = "1.17.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pycparser" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/fc/97/c783634659c2920c3fc70419e3af40972dbaf758daa229a7d6ea6135c90d/cffi-1.17.1.tar.gz", hash = "sha256:1c39c6016c32bc48dd54561950ebd6836e1670f2ae46128f67cf49e789c52824", size = 516621, upload-time = "2024-09-04T20:45:21.852Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/6b/f4/927e3a8899e52a27fa57a48607ff7dc91a9ebe97399b357b85a0c7892e00/cffi-1.17.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:a45e3c6913c5b87b3ff120dcdc03f6131fa0065027d0ed7ee6190736a74cd401", size = 182264, upload-time = "2024-09-04T20:43:51.124Z" }, + { url = "https://files.pythonhosted.org/packages/6c/f5/6c3a8efe5f503175aaddcbea6ad0d2c96dad6f5abb205750d1b3df44ef29/cffi-1.17.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:30c5e0cb5ae493c04c8b42916e52ca38079f1b235c2f8ae5f4527b963c401caf", size = 178651, upload-time = "2024-09-04T20:43:52.872Z" }, + { url = "https://files.pythonhosted.org/packages/94/dd/a3f0118e688d1b1a57553da23b16bdade96d2f9bcda4d32e7d2838047ff7/cffi-1.17.1-cp311-cp311-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f75c7ab1f9e4aca5414ed4d8e5c0e303a34f4421f8a0d47a4d019ceff0ab6af4", size = 445259, upload-time = "2024-09-04T20:43:56.123Z" }, + { url = "https://files.pythonhosted.org/packages/2e/ea/70ce63780f096e16ce8588efe039d3c4f91deb1dc01e9c73a287939c79a6/cffi-1.17.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a1ed2dd2972641495a3ec98445e09766f077aee98a1c896dcb4ad0d303628e41", size = 469200, upload-time = "2024-09-04T20:43:57.891Z" }, + { url = "https://files.pythonhosted.org/packages/1c/a0/a4fa9f4f781bda074c3ddd57a572b060fa0df7655d2a4247bbe277200146/cffi-1.17.1-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:46bf43160c1a35f7ec506d254e5c890f3c03648a4dbac12d624e4490a7046cd1", size = 477235, upload-time = "2024-09-04T20:44:00.18Z" }, + { url = "https://files.pythonhosted.org/packages/62/12/ce8710b5b8affbcdd5c6e367217c242524ad17a02fe5beec3ee339f69f85/cffi-1.17.1-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a24ed04c8ffd54b0729c07cee15a81d964e6fee0e3d4d342a27b020d22959dc6", size = 459721, upload-time = "2024-09-04T20:44:01.585Z" }, + { url = "https://files.pythonhosted.org/packages/ff/6b/d45873c5e0242196f042d555526f92aa9e0c32355a1be1ff8c27f077fd37/cffi-1.17.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:610faea79c43e44c71e1ec53a554553fa22321b65fae24889706c0a84d4ad86d", size = 467242, upload-time = "2024-09-04T20:44:03.467Z" }, + { url = "https://files.pythonhosted.org/packages/1a/52/d9a0e523a572fbccf2955f5abe883cfa8bcc570d7faeee06336fbd50c9fc/cffi-1.17.1-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:a9b15d491f3ad5d692e11f6b71f7857e7835eb677955c00cc0aefcd0669adaf6", size = 477999, upload-time = "2024-09-04T20:44:05.023Z" }, + { url = "https://files.pythonhosted.org/packages/44/74/f2a2460684a1a2d00ca799ad880d54652841a780c4c97b87754f660c7603/cffi-1.17.1-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:de2ea4b5833625383e464549fec1bc395c1bdeeb5f25c4a3a82b5a8c756ec22f", size = 454242, upload-time = "2024-09-04T20:44:06.444Z" }, + { url = "https://files.pythonhosted.org/packages/f8/4a/34599cac7dfcd888ff54e801afe06a19c17787dfd94495ab0c8d35fe99fb/cffi-1.17.1-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:fc48c783f9c87e60831201f2cce7f3b2e4846bf4d8728eabe54d60700b318a0b", size = 478604, upload-time = "2024-09-04T20:44:08.206Z" }, + { url = "https://files.pythonhosted.org/packages/34/33/e1b8a1ba29025adbdcda5fb3a36f94c03d771c1b7b12f726ff7fef2ebe36/cffi-1.17.1-cp311-cp311-win32.whl", hash = "sha256:85a950a4ac9c359340d5963966e3e0a94a676bd6245a4b55bc43949eee26a655", size = 171727, upload-time = "2024-09-04T20:44:09.481Z" }, + { url = "https://files.pythonhosted.org/packages/3d/97/50228be003bb2802627d28ec0627837ac0bf35c90cf769812056f235b2d1/cffi-1.17.1-cp311-cp311-win_amd64.whl", hash = "sha256:caaf0640ef5f5517f49bc275eca1406b0ffa6aa184892812030f04c2abf589a0", size = 181400, upload-time = "2024-09-04T20:44:10.873Z" }, + { url = "https://files.pythonhosted.org/packages/5a/84/e94227139ee5fb4d600a7a4927f322e1d4aea6fdc50bd3fca8493caba23f/cffi-1.17.1-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:805b4371bf7197c329fcb3ead37e710d1bca9da5d583f5073b799d5c5bd1eee4", size = 183178, upload-time = "2024-09-04T20:44:12.232Z" }, + { url = "https://files.pythonhosted.org/packages/da/ee/fb72c2b48656111c4ef27f0f91da355e130a923473bf5ee75c5643d00cca/cffi-1.17.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:733e99bc2df47476e3848417c5a4540522f234dfd4ef3ab7fafdf555b082ec0c", size = 178840, upload-time = "2024-09-04T20:44:13.739Z" }, + { url = "https://files.pythonhosted.org/packages/cc/b6/db007700f67d151abadf508cbfd6a1884f57eab90b1bb985c4c8c02b0f28/cffi-1.17.1-cp312-cp312-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1257bdabf294dceb59f5e70c64a3e2f462c30c7ad68092d01bbbfb1c16b1ba36", size = 454803, upload-time = "2024-09-04T20:44:15.231Z" }, + { url = "https://files.pythonhosted.org/packages/1a/df/f8d151540d8c200eb1c6fba8cd0dfd40904f1b0682ea705c36e6c2e97ab3/cffi-1.17.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:da95af8214998d77a98cc14e3a3bd00aa191526343078b530ceb0bd710fb48a5", size = 478850, upload-time = "2024-09-04T20:44:17.188Z" }, + { url = "https://files.pythonhosted.org/packages/28/c0/b31116332a547fd2677ae5b78a2ef662dfc8023d67f41b2a83f7c2aa78b1/cffi-1.17.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d63afe322132c194cf832bfec0dc69a99fb9bb6bbd550f161a49e9e855cc78ff", size = 485729, upload-time = "2024-09-04T20:44:18.688Z" }, + { url = "https://files.pythonhosted.org/packages/91/2b/9a1ddfa5c7f13cab007a2c9cc295b70fbbda7cb10a286aa6810338e60ea1/cffi-1.17.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f79fc4fc25f1c8698ff97788206bb3c2598949bfe0fef03d299eb1b5356ada99", size = 471256, upload-time = "2024-09-04T20:44:20.248Z" }, + { url = "https://files.pythonhosted.org/packages/b2/d5/da47df7004cb17e4955df6a43d14b3b4ae77737dff8bf7f8f333196717bf/cffi-1.17.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b62ce867176a75d03a665bad002af8e6d54644fad99a3c70905c543130e39d93", size = 479424, upload-time = "2024-09-04T20:44:21.673Z" }, + { url = "https://files.pythonhosted.org/packages/0b/ac/2a28bcf513e93a219c8a4e8e125534f4f6db03e3179ba1c45e949b76212c/cffi-1.17.1-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:386c8bf53c502fff58903061338ce4f4950cbdcb23e2902d86c0f722b786bbe3", size = 484568, upload-time = "2024-09-04T20:44:23.245Z" }, + { url = "https://files.pythonhosted.org/packages/d4/38/ca8a4f639065f14ae0f1d9751e70447a261f1a30fa7547a828ae08142465/cffi-1.17.1-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:4ceb10419a9adf4460ea14cfd6bc43d08701f0835e979bf821052f1805850fe8", size = 488736, upload-time = "2024-09-04T20:44:24.757Z" }, + { url = "https://files.pythonhosted.org/packages/86/c5/28b2d6f799ec0bdecf44dced2ec5ed43e0eb63097b0f58c293583b406582/cffi-1.17.1-cp312-cp312-win32.whl", hash = "sha256:a08d7e755f8ed21095a310a693525137cfe756ce62d066e53f502a83dc550f65", size = 172448, upload-time = "2024-09-04T20:44:26.208Z" }, + { url = "https://files.pythonhosted.org/packages/50/b9/db34c4755a7bd1cb2d1603ac3863f22bcecbd1ba29e5ee841a4bc510b294/cffi-1.17.1-cp312-cp312-win_amd64.whl", hash = "sha256:51392eae71afec0d0c8fb1a53b204dbb3bcabcb3c9b807eedf3e1e6ccf2de903", size = 181976, upload-time = "2024-09-04T20:44:27.578Z" }, + { url = "https://files.pythonhosted.org/packages/8d/f8/dd6c246b148639254dad4d6803eb6a54e8c85c6e11ec9df2cffa87571dbe/cffi-1.17.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:f3a2b4222ce6b60e2e8b337bb9596923045681d71e5a082783484d845390938e", size = 182989, upload-time = "2024-09-04T20:44:28.956Z" }, + { url = "https://files.pythonhosted.org/packages/8b/f1/672d303ddf17c24fc83afd712316fda78dc6fce1cd53011b839483e1ecc8/cffi-1.17.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:0984a4925a435b1da406122d4d7968dd861c1385afe3b45ba82b750f229811e2", size = 178802, upload-time = "2024-09-04T20:44:30.289Z" }, + { url = "https://files.pythonhosted.org/packages/0e/2d/eab2e858a91fdff70533cab61dcff4a1f55ec60425832ddfdc9cd36bc8af/cffi-1.17.1-cp313-cp313-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:d01b12eeeb4427d3110de311e1774046ad344f5b1a7403101878976ecd7a10f3", size = 454792, upload-time = "2024-09-04T20:44:32.01Z" }, + { url = "https://files.pythonhosted.org/packages/75/b2/fbaec7c4455c604e29388d55599b99ebcc250a60050610fadde58932b7ee/cffi-1.17.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:706510fe141c86a69c8ddc029c7910003a17353970cff3b904ff0686a5927683", size = 478893, upload-time = "2024-09-04T20:44:33.606Z" }, + { url = "https://files.pythonhosted.org/packages/4f/b7/6e4a2162178bf1935c336d4da8a9352cccab4d3a5d7914065490f08c0690/cffi-1.17.1-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:de55b766c7aa2e2a3092c51e0483d700341182f08e67c63630d5b6f200bb28e5", size = 485810, upload-time = "2024-09-04T20:44:35.191Z" }, + { url = "https://files.pythonhosted.org/packages/c7/8a/1d0e4a9c26e54746dc08c2c6c037889124d4f59dffd853a659fa545f1b40/cffi-1.17.1-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:c59d6e989d07460165cc5ad3c61f9fd8f1b4796eacbd81cee78957842b834af4", size = 471200, upload-time = "2024-09-04T20:44:36.743Z" }, + { url = "https://files.pythonhosted.org/packages/26/9f/1aab65a6c0db35f43c4d1b4f580e8df53914310afc10ae0397d29d697af4/cffi-1.17.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:dd398dbc6773384a17fe0d3e7eeb8d1a21c2200473ee6806bb5e6a8e62bb73dd", size = 479447, upload-time = "2024-09-04T20:44:38.492Z" }, + { url = "https://files.pythonhosted.org/packages/5f/e4/fb8b3dd8dc0e98edf1135ff067ae070bb32ef9d509d6cb0f538cd6f7483f/cffi-1.17.1-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:3edc8d958eb099c634dace3c7e16560ae474aa3803a5df240542b305d14e14ed", size = 484358, upload-time = "2024-09-04T20:44:40.046Z" }, + { url = "https://files.pythonhosted.org/packages/f1/47/d7145bf2dc04684935d57d67dff9d6d795b2ba2796806bb109864be3a151/cffi-1.17.1-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:72e72408cad3d5419375fc87d289076ee319835bdfa2caad331e377589aebba9", size = 488469, upload-time = "2024-09-04T20:44:41.616Z" }, + { url = "https://files.pythonhosted.org/packages/bf/ee/f94057fa6426481d663b88637a9a10e859e492c73d0384514a17d78ee205/cffi-1.17.1-cp313-cp313-win32.whl", hash = "sha256:e03eab0a8677fa80d646b5ddece1cbeaf556c313dcfac435ba11f107ba117b5d", size = 172475, upload-time = "2024-09-04T20:44:43.733Z" }, + { url = "https://files.pythonhosted.org/packages/7c/fc/6a8cb64e5f0324877d503c854da15d76c1e50eb722e320b15345c4d0c6de/cffi-1.17.1-cp313-cp313-win_amd64.whl", hash = "sha256:f6a16c31041f09ead72d69f583767292f750d24913dadacf5756b966aacb3f1a", size = 182009, upload-time = "2024-09-04T20:44:45.309Z" }, +] + +[[package]] +name = "charset-normalizer" +version = "3.4.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/16/b0/572805e227f01586461c80e0fd25d65a2115599cc9dad142fee4b747c357/charset_normalizer-3.4.1.tar.gz", hash = "sha256:44251f18cd68a75b56585dd00dae26183e102cd5e0f9f1466e6df5da2ed64ea3", size = 123188, upload-time = "2024-12-24T18:12:35.43Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/72/80/41ef5d5a7935d2d3a773e3eaebf0a9350542f2cab4eac59a7a4741fbbbbe/charset_normalizer-3.4.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:8bfa33f4f2672964266e940dd22a195989ba31669bd84629f05fab3ef4e2d125", size = 194995, upload-time = "2024-12-24T18:10:12.838Z" }, + { url = "https://files.pythonhosted.org/packages/7a/28/0b9fefa7b8b080ec492110af6d88aa3dea91c464b17d53474b6e9ba5d2c5/charset_normalizer-3.4.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:28bf57629c75e810b6ae989f03c0828d64d6b26a5e205535585f96093e405ed1", size = 139471, upload-time = "2024-12-24T18:10:14.101Z" }, + { url = "https://files.pythonhosted.org/packages/71/64/d24ab1a997efb06402e3fc07317e94da358e2585165930d9d59ad45fcae2/charset_normalizer-3.4.1-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f08ff5e948271dc7e18a35641d2f11a4cd8dfd5634f55228b691e62b37125eb3", size = 149831, upload-time = "2024-12-24T18:10:15.512Z" }, + { url = "https://files.pythonhosted.org/packages/37/ed/be39e5258e198655240db5e19e0b11379163ad7070962d6b0c87ed2c4d39/charset_normalizer-3.4.1-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:234ac59ea147c59ee4da87a0c0f098e9c8d169f4dc2a159ef720f1a61bbe27cd", size = 142335, upload-time = "2024-12-24T18:10:18.369Z" }, + { url = "https://files.pythonhosted.org/packages/88/83/489e9504711fa05d8dde1574996408026bdbdbd938f23be67deebb5eca92/charset_normalizer-3.4.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fd4ec41f914fa74ad1b8304bbc634b3de73d2a0889bd32076342a573e0779e00", size = 143862, upload-time = "2024-12-24T18:10:19.743Z" }, + { url = "https://files.pythonhosted.org/packages/c6/c7/32da20821cf387b759ad24627a9aca289d2822de929b8a41b6241767b461/charset_normalizer-3.4.1-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:eea6ee1db730b3483adf394ea72f808b6e18cf3cb6454b4d86e04fa8c4327a12", size = 145673, upload-time = "2024-12-24T18:10:21.139Z" }, + { url = "https://files.pythonhosted.org/packages/68/85/f4288e96039abdd5aeb5c546fa20a37b50da71b5cf01e75e87f16cd43304/charset_normalizer-3.4.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:c96836c97b1238e9c9e3fe90844c947d5afbf4f4c92762679acfe19927d81d77", size = 140211, upload-time = "2024-12-24T18:10:22.382Z" }, + { url = "https://files.pythonhosted.org/packages/28/a3/a42e70d03cbdabc18997baf4f0227c73591a08041c149e710045c281f97b/charset_normalizer-3.4.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:4d86f7aff21ee58f26dcf5ae81a9addbd914115cdebcbb2217e4f0ed8982e146", size = 148039, upload-time = "2024-12-24T18:10:24.802Z" }, + { url = "https://files.pythonhosted.org/packages/85/e4/65699e8ab3014ecbe6f5c71d1a55d810fb716bbfd74f6283d5c2aa87febf/charset_normalizer-3.4.1-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:09b5e6733cbd160dcc09589227187e242a30a49ca5cefa5a7edd3f9d19ed53fd", size = 151939, upload-time = "2024-12-24T18:10:26.124Z" }, + { url = "https://files.pythonhosted.org/packages/b1/82/8e9fe624cc5374193de6860aba3ea8070f584c8565ee77c168ec13274bd2/charset_normalizer-3.4.1-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:5777ee0881f9499ed0f71cc82cf873d9a0ca8af166dfa0af8ec4e675b7df48e6", size = 149075, upload-time = "2024-12-24T18:10:30.027Z" }, + { url = "https://files.pythonhosted.org/packages/3d/7b/82865ba54c765560c8433f65e8acb9217cb839a9e32b42af4aa8e945870f/charset_normalizer-3.4.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:237bdbe6159cff53b4f24f397d43c6336c6b0b42affbe857970cefbb620911c8", size = 144340, upload-time = "2024-12-24T18:10:32.679Z" }, + { url = "https://files.pythonhosted.org/packages/b5/b6/9674a4b7d4d99a0d2df9b215da766ee682718f88055751e1e5e753c82db0/charset_normalizer-3.4.1-cp311-cp311-win32.whl", hash = "sha256:8417cb1f36cc0bc7eaba8ccb0e04d55f0ee52df06df3ad55259b9a323555fc8b", size = 95205, upload-time = "2024-12-24T18:10:34.724Z" }, + { url = "https://files.pythonhosted.org/packages/1e/ab/45b180e175de4402dcf7547e4fb617283bae54ce35c27930a6f35b6bef15/charset_normalizer-3.4.1-cp311-cp311-win_amd64.whl", hash = "sha256:d7f50a1f8c450f3925cb367d011448c39239bb3eb4117c36a6d354794de4ce76", size = 102441, upload-time = "2024-12-24T18:10:37.574Z" }, + { url = "https://files.pythonhosted.org/packages/0a/9a/dd1e1cdceb841925b7798369a09279bd1cf183cef0f9ddf15a3a6502ee45/charset_normalizer-3.4.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:73d94b58ec7fecbc7366247d3b0b10a21681004153238750bb67bd9012414545", size = 196105, upload-time = "2024-12-24T18:10:38.83Z" }, + { url = "https://files.pythonhosted.org/packages/d3/8c/90bfabf8c4809ecb648f39794cf2a84ff2e7d2a6cf159fe68d9a26160467/charset_normalizer-3.4.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:dad3e487649f498dd991eeb901125411559b22e8d7ab25d3aeb1af367df5efd7", size = 140404, upload-time = "2024-12-24T18:10:44.272Z" }, + { url = "https://files.pythonhosted.org/packages/ad/8f/e410d57c721945ea3b4f1a04b74f70ce8fa800d393d72899f0a40526401f/charset_normalizer-3.4.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:c30197aa96e8eed02200a83fba2657b4c3acd0f0aa4bdc9f6c1af8e8962e0757", size = 150423, upload-time = "2024-12-24T18:10:45.492Z" }, + { url = "https://files.pythonhosted.org/packages/f0/b8/e6825e25deb691ff98cf5c9072ee0605dc2acfca98af70c2d1b1bc75190d/charset_normalizer-3.4.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2369eea1ee4a7610a860d88f268eb39b95cb588acd7235e02fd5a5601773d4fa", size = 143184, upload-time = "2024-12-24T18:10:47.898Z" }, + { url = "https://files.pythonhosted.org/packages/3e/a2/513f6cbe752421f16d969e32f3583762bfd583848b763913ddab8d9bfd4f/charset_normalizer-3.4.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bc2722592d8998c870fa4e290c2eec2c1569b87fe58618e67d38b4665dfa680d", size = 145268, upload-time = "2024-12-24T18:10:50.589Z" }, + { url = "https://files.pythonhosted.org/packages/74/94/8a5277664f27c3c438546f3eb53b33f5b19568eb7424736bdc440a88a31f/charset_normalizer-3.4.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ffc9202a29ab3920fa812879e95a9e78b2465fd10be7fcbd042899695d75e616", size = 147601, upload-time = "2024-12-24T18:10:52.541Z" }, + { url = "https://files.pythonhosted.org/packages/7c/5f/6d352c51ee763623a98e31194823518e09bfa48be2a7e8383cf691bbb3d0/charset_normalizer-3.4.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:804a4d582ba6e5b747c625bf1255e6b1507465494a40a2130978bda7b932c90b", size = 141098, upload-time = "2024-12-24T18:10:53.789Z" }, + { url = "https://files.pythonhosted.org/packages/78/d4/f5704cb629ba5ab16d1d3d741396aec6dc3ca2b67757c45b0599bb010478/charset_normalizer-3.4.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:0f55e69f030f7163dffe9fd0752b32f070566451afe180f99dbeeb81f511ad8d", size = 149520, upload-time = "2024-12-24T18:10:55.048Z" }, + { url = "https://files.pythonhosted.org/packages/c5/96/64120b1d02b81785f222b976c0fb79a35875457fa9bb40827678e54d1bc8/charset_normalizer-3.4.1-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:c4c3e6da02df6fa1410a7680bd3f63d4f710232d3139089536310d027950696a", size = 152852, upload-time = "2024-12-24T18:10:57.647Z" }, + { url = "https://files.pythonhosted.org/packages/84/c9/98e3732278a99f47d487fd3468bc60b882920cef29d1fa6ca460a1fdf4e6/charset_normalizer-3.4.1-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:5df196eb874dae23dcfb968c83d4f8fdccb333330fe1fc278ac5ceeb101003a9", size = 150488, upload-time = "2024-12-24T18:10:59.43Z" }, + { url = "https://files.pythonhosted.org/packages/13/0e/9c8d4cb99c98c1007cc11eda969ebfe837bbbd0acdb4736d228ccaabcd22/charset_normalizer-3.4.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:e358e64305fe12299a08e08978f51fc21fac060dcfcddd95453eabe5b93ed0e1", size = 146192, upload-time = "2024-12-24T18:11:00.676Z" }, + { url = "https://files.pythonhosted.org/packages/b2/21/2b6b5b860781a0b49427309cb8670785aa543fb2178de875b87b9cc97746/charset_normalizer-3.4.1-cp312-cp312-win32.whl", hash = "sha256:9b23ca7ef998bc739bf6ffc077c2116917eabcc901f88da1b9856b210ef63f35", size = 95550, upload-time = "2024-12-24T18:11:01.952Z" }, + { url = "https://files.pythonhosted.org/packages/21/5b/1b390b03b1d16c7e382b561c5329f83cc06623916aab983e8ab9239c7d5c/charset_normalizer-3.4.1-cp312-cp312-win_amd64.whl", hash = "sha256:6ff8a4a60c227ad87030d76e99cd1698345d4491638dfa6673027c48b3cd395f", size = 102785, upload-time = "2024-12-24T18:11:03.142Z" }, + { url = "https://files.pythonhosted.org/packages/38/94/ce8e6f63d18049672c76d07d119304e1e2d7c6098f0841b51c666e9f44a0/charset_normalizer-3.4.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:aabfa34badd18f1da5ec1bc2715cadc8dca465868a4e73a0173466b688f29dda", size = 195698, upload-time = "2024-12-24T18:11:05.834Z" }, + { url = "https://files.pythonhosted.org/packages/24/2e/dfdd9770664aae179a96561cc6952ff08f9a8cd09a908f259a9dfa063568/charset_normalizer-3.4.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:22e14b5d70560b8dd51ec22863f370d1e595ac3d024cb8ad7d308b4cd95f8313", size = 140162, upload-time = "2024-12-24T18:11:07.064Z" }, + { url = "https://files.pythonhosted.org/packages/24/4e/f646b9093cff8fc86f2d60af2de4dc17c759de9d554f130b140ea4738ca6/charset_normalizer-3.4.1-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:8436c508b408b82d87dc5f62496973a1805cd46727c34440b0d29d8a2f50a6c9", size = 150263, upload-time = "2024-12-24T18:11:08.374Z" }, + { url = "https://files.pythonhosted.org/packages/5e/67/2937f8d548c3ef6e2f9aab0f6e21001056f692d43282b165e7c56023e6dd/charset_normalizer-3.4.1-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2d074908e1aecee37a7635990b2c6d504cd4766c7bc9fc86d63f9c09af3fa11b", size = 142966, upload-time = "2024-12-24T18:11:09.831Z" }, + { url = "https://files.pythonhosted.org/packages/52/ed/b7f4f07de100bdb95c1756d3a4d17b90c1a3c53715c1a476f8738058e0fa/charset_normalizer-3.4.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:955f8851919303c92343d2f66165294848d57e9bba6cf6e3625485a70a038d11", size = 144992, upload-time = "2024-12-24T18:11:12.03Z" }, + { url = "https://files.pythonhosted.org/packages/96/2c/d49710a6dbcd3776265f4c923bb73ebe83933dfbaa841c5da850fe0fd20b/charset_normalizer-3.4.1-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:44ecbf16649486d4aebafeaa7ec4c9fed8b88101f4dd612dcaf65d5e815f837f", size = 147162, upload-time = "2024-12-24T18:11:13.372Z" }, + { url = "https://files.pythonhosted.org/packages/b4/41/35ff1f9a6bd380303dea55e44c4933b4cc3c4850988927d4082ada230273/charset_normalizer-3.4.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:0924e81d3d5e70f8126529951dac65c1010cdf117bb75eb02dd12339b57749dd", size = 140972, upload-time = "2024-12-24T18:11:14.628Z" }, + { url = "https://files.pythonhosted.org/packages/fb/43/c6a0b685fe6910d08ba971f62cd9c3e862a85770395ba5d9cad4fede33ab/charset_normalizer-3.4.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:2967f74ad52c3b98de4c3b32e1a44e32975e008a9cd2a8cc8966d6a5218c5cb2", size = 149095, upload-time = "2024-12-24T18:11:17.672Z" }, + { url = "https://files.pythonhosted.org/packages/4c/ff/a9a504662452e2d2878512115638966e75633519ec11f25fca3d2049a94a/charset_normalizer-3.4.1-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:c75cb2a3e389853835e84a2d8fb2b81a10645b503eca9bcb98df6b5a43eb8886", size = 152668, upload-time = "2024-12-24T18:11:18.989Z" }, + { url = "https://files.pythonhosted.org/packages/6c/71/189996b6d9a4b932564701628af5cee6716733e9165af1d5e1b285c530ed/charset_normalizer-3.4.1-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:09b26ae6b1abf0d27570633b2b078a2a20419c99d66fb2823173d73f188ce601", size = 150073, upload-time = "2024-12-24T18:11:21.507Z" }, + { url = "https://files.pythonhosted.org/packages/e4/93/946a86ce20790e11312c87c75ba68d5f6ad2208cfb52b2d6a2c32840d922/charset_normalizer-3.4.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:fa88b843d6e211393a37219e6a1c1df99d35e8fd90446f1118f4216e307e48cd", size = 145732, upload-time = "2024-12-24T18:11:22.774Z" }, + { url = "https://files.pythonhosted.org/packages/cd/e5/131d2fb1b0dddafc37be4f3a2fa79aa4c037368be9423061dccadfd90091/charset_normalizer-3.4.1-cp313-cp313-win32.whl", hash = "sha256:eb8178fe3dba6450a3e024e95ac49ed3400e506fd4e9e5c32d30adda88cbd407", size = 95391, upload-time = "2024-12-24T18:11:24.139Z" }, + { url = "https://files.pythonhosted.org/packages/27/f2/4f9a69cc7712b9b5ad8fdb87039fd89abba997ad5cbe690d1835d40405b0/charset_normalizer-3.4.1-cp313-cp313-win_amd64.whl", hash = "sha256:b1ac5992a838106edb89654e0aebfc24f5848ae2547d22c2c3f66454daa11971", size = 102702, upload-time = "2024-12-24T18:11:26.535Z" }, + { url = "https://files.pythonhosted.org/packages/0e/f6/65ecc6878a89bb1c23a086ea335ad4bf21a588990c3f535a227b9eea9108/charset_normalizer-3.4.1-py3-none-any.whl", hash = "sha256:d98b1668f06378c6dbefec3b92299716b931cd4e6061f3c875a71ced1780ab85", size = 49767, upload-time = "2024-12-24T18:12:32.852Z" }, +] + +[[package]] +name = "colorama" +version = "0.4.6" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/d8/53/6f443c9a4a8358a93a6792e2acffb9d9d5cb0a5cfd8802644b7b1c9a02e4/colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44", size = 27697, upload-time = "2022-10-25T02:36:22.414Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335, upload-time = "2022-10-25T02:36:20.889Z" }, +] + +[[package]] +name = "comm" +version = "0.2.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/e9/a8/fb783cb0abe2b5fded9f55e5703015cdf1c9c85b3669087c538dd15a6a86/comm-0.2.2.tar.gz", hash = "sha256:3fd7a84065306e07bea1773df6eb8282de51ba82f77c72f9c85716ab11fe980e", size = 6210, upload-time = "2024-03-12T16:53:41.133Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e6/75/49e5bfe642f71f272236b5b2d2691cf915a7283cc0ceda56357b61daa538/comm-0.2.2-py3-none-any.whl", hash = "sha256:e6fb86cb70ff661ee8c9c14e7d36d6de3b4066f1441be4063df9c5009f0a64d3", size = 7180, upload-time = "2024-03-12T16:53:39.226Z" }, +] + +[[package]] +name = "contourpy" +version = "1.3.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "numpy" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/25/c2/fc7193cc5383637ff390a712e88e4ded0452c9fbcf84abe3de5ea3df1866/contourpy-1.3.1.tar.gz", hash = "sha256:dfd97abd83335045a913e3bcc4a09c0ceadbe66580cf573fe961f4a825efa699", size = 13465753, upload-time = "2024-11-12T11:00:59.118Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/12/bb/11250d2906ee2e8b466b5f93e6b19d525f3e0254ac8b445b56e618527718/contourpy-1.3.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:3e8b974d8db2c5610fb4e76307e265de0edb655ae8169e8b21f41807ccbeec4b", size = 269555, upload-time = "2024-11-12T10:53:14.707Z" }, + { url = "https://files.pythonhosted.org/packages/67/71/1e6e95aee21a500415f5d2dbf037bf4567529b6a4e986594d7026ec5ae90/contourpy-1.3.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:20914c8c973f41456337652a6eeca26d2148aa96dd7ac323b74516988bea89fc", size = 254549, upload-time = "2024-11-12T10:53:19.42Z" }, + { url = "https://files.pythonhosted.org/packages/31/2c/b88986e8d79ac45efe9d8801ae341525f38e087449b6c2f2e6050468a42c/contourpy-1.3.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:19d40d37c1c3a4961b4619dd9d77b12124a453cc3d02bb31a07d58ef684d3d86", size = 313000, upload-time = "2024-11-12T10:53:23.944Z" }, + { url = "https://files.pythonhosted.org/packages/c4/18/65280989b151fcf33a8352f992eff71e61b968bef7432fbfde3a364f0730/contourpy-1.3.1-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:113231fe3825ebf6f15eaa8bc1f5b0ddc19d42b733345eae0934cb291beb88b6", size = 352925, upload-time = "2024-11-12T10:53:29.719Z" }, + { url = "https://files.pythonhosted.org/packages/f5/c7/5fd0146c93220dbfe1a2e0f98969293b86ca9bc041d6c90c0e065f4619ad/contourpy-1.3.1-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:4dbbc03a40f916a8420e420d63e96a1258d3d1b58cbdfd8d1f07b49fcbd38e85", size = 323693, upload-time = "2024-11-12T10:53:35.046Z" }, + { url = "https://files.pythonhosted.org/packages/85/fc/7fa5d17daf77306840a4e84668a48ddff09e6bc09ba4e37e85ffc8e4faa3/contourpy-1.3.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3a04ecd68acbd77fa2d39723ceca4c3197cb2969633836ced1bea14e219d077c", size = 326184, upload-time = "2024-11-12T10:53:40.261Z" }, + { url = "https://files.pythonhosted.org/packages/ef/e7/104065c8270c7397c9571620d3ab880558957216f2b5ebb7e040f85eeb22/contourpy-1.3.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:c414fc1ed8ee1dbd5da626cf3710c6013d3d27456651d156711fa24f24bd1291", size = 1268031, upload-time = "2024-11-12T10:53:55.876Z" }, + { url = "https://files.pythonhosted.org/packages/e2/4a/c788d0bdbf32c8113c2354493ed291f924d4793c4a2e85b69e737a21a658/contourpy-1.3.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:31c1b55c1f34f80557d3830d3dd93ba722ce7e33a0b472cba0ec3b6535684d8f", size = 1325995, upload-time = "2024-11-12T10:54:11.572Z" }, + { url = "https://files.pythonhosted.org/packages/a6/e6/a2f351a90d955f8b0564caf1ebe4b1451a3f01f83e5e3a414055a5b8bccb/contourpy-1.3.1-cp311-cp311-win32.whl", hash = "sha256:f611e628ef06670df83fce17805c344710ca5cde01edfdc72751311da8585375", size = 174396, upload-time = "2024-11-12T10:54:15.358Z" }, + { url = "https://files.pythonhosted.org/packages/a8/7e/cd93cab453720a5d6cb75588cc17dcdc08fc3484b9de98b885924ff61900/contourpy-1.3.1-cp311-cp311-win_amd64.whl", hash = "sha256:b2bdca22a27e35f16794cf585832e542123296b4687f9fd96822db6bae17bfc9", size = 219787, upload-time = "2024-11-12T10:54:18.836Z" }, + { url = "https://files.pythonhosted.org/packages/37/6b/175f60227d3e7f5f1549fcb374592be311293132207e451c3d7c654c25fb/contourpy-1.3.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:0ffa84be8e0bd33410b17189f7164c3589c229ce5db85798076a3fa136d0e509", size = 271494, upload-time = "2024-11-12T10:54:23.6Z" }, + { url = "https://files.pythonhosted.org/packages/6b/6a/7833cfae2c1e63d1d8875a50fd23371394f540ce809d7383550681a1fa64/contourpy-1.3.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:805617228ba7e2cbbfb6c503858e626ab528ac2a32a04a2fe88ffaf6b02c32bc", size = 255444, upload-time = "2024-11-12T10:54:28.267Z" }, + { url = "https://files.pythonhosted.org/packages/7f/b3/7859efce66eaca5c14ba7619791b084ed02d868d76b928ff56890d2d059d/contourpy-1.3.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ade08d343436a94e633db932e7e8407fe7de8083967962b46bdfc1b0ced39454", size = 307628, upload-time = "2024-11-12T10:54:33.418Z" }, + { url = "https://files.pythonhosted.org/packages/48/b2/011415f5e3f0a50b1e285a0bf78eb5d92a4df000553570f0851b6e309076/contourpy-1.3.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:47734d7073fb4590b4a40122b35917cd77be5722d80683b249dac1de266aac80", size = 347271, upload-time = "2024-11-12T10:54:38.816Z" }, + { url = "https://files.pythonhosted.org/packages/84/7d/ef19b1db0f45b151ac78c65127235239a8cf21a59d1ce8507ce03e89a30b/contourpy-1.3.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2ba94a401342fc0f8b948e57d977557fbf4d515f03c67682dd5c6191cb2d16ec", size = 318906, upload-time = "2024-11-12T10:54:44.132Z" }, + { url = "https://files.pythonhosted.org/packages/ba/99/6794142b90b853a9155316c8f470d2e4821fe6f086b03e372aca848227dd/contourpy-1.3.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:efa874e87e4a647fd2e4f514d5e91c7d493697127beb95e77d2f7561f6905bd9", size = 323622, upload-time = "2024-11-12T10:54:48.788Z" }, + { url = "https://files.pythonhosted.org/packages/3c/0f/37d2c84a900cd8eb54e105f4fa9aebd275e14e266736778bb5dccbf3bbbb/contourpy-1.3.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:1bf98051f1045b15c87868dbaea84f92408337d4f81d0e449ee41920ea121d3b", size = 1266699, upload-time = "2024-11-12T10:55:04.016Z" }, + { url = "https://files.pythonhosted.org/packages/3a/8a/deb5e11dc7d9cc8f0f9c8b29d4f062203f3af230ba83c30a6b161a6effc9/contourpy-1.3.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:61332c87493b00091423e747ea78200659dc09bdf7fd69edd5e98cef5d3e9a8d", size = 1326395, upload-time = "2024-11-12T10:55:20.547Z" }, + { url = "https://files.pythonhosted.org/packages/1a/35/7e267ae7c13aaf12322ccc493531f1e7f2eb8fba2927b9d7a05ff615df7a/contourpy-1.3.1-cp312-cp312-win32.whl", hash = "sha256:e914a8cb05ce5c809dd0fe350cfbb4e881bde5e2a38dc04e3afe1b3e58bd158e", size = 175354, upload-time = "2024-11-12T10:55:24.377Z" }, + { url = "https://files.pythonhosted.org/packages/a1/35/c2de8823211d07e8a79ab018ef03960716c5dff6f4d5bff5af87fd682992/contourpy-1.3.1-cp312-cp312-win_amd64.whl", hash = "sha256:08d9d449a61cf53033612cb368f3a1b26cd7835d9b8cd326647efe43bca7568d", size = 220971, upload-time = "2024-11-12T10:55:27.971Z" }, + { url = "https://files.pythonhosted.org/packages/9a/e7/de62050dce687c5e96f946a93546910bc67e483fe05324439e329ff36105/contourpy-1.3.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:a761d9ccfc5e2ecd1bf05534eda382aa14c3e4f9205ba5b1684ecfe400716ef2", size = 271548, upload-time = "2024-11-12T10:55:32.228Z" }, + { url = "https://files.pythonhosted.org/packages/78/4d/c2a09ae014ae984c6bdd29c11e74d3121b25eaa117eca0bb76340efd7e1c/contourpy-1.3.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:523a8ee12edfa36f6d2a49407f705a6ef4c5098de4f498619787e272de93f2d5", size = 255576, upload-time = "2024-11-12T10:55:36.246Z" }, + { url = "https://files.pythonhosted.org/packages/ab/8a/915380ee96a5638bda80cd061ccb8e666bfdccea38d5741cb69e6dbd61fc/contourpy-1.3.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ece6df05e2c41bd46776fbc712e0996f7c94e0d0543af1656956d150c4ca7c81", size = 306635, upload-time = "2024-11-12T10:55:41.904Z" }, + { url = "https://files.pythonhosted.org/packages/29/5c/c83ce09375428298acd4e6582aeb68b1e0d1447f877fa993d9bf6cd3b0a0/contourpy-1.3.1-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:573abb30e0e05bf31ed067d2f82500ecfdaec15627a59d63ea2d95714790f5c2", size = 345925, upload-time = "2024-11-12T10:55:47.206Z" }, + { url = "https://files.pythonhosted.org/packages/29/63/5b52f4a15e80c66c8078a641a3bfacd6e07106835682454647aca1afc852/contourpy-1.3.1-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a9fa36448e6a3a1a9a2ba23c02012c43ed88905ec80163f2ffe2421c7192a5d7", size = 318000, upload-time = "2024-11-12T10:55:52.264Z" }, + { url = "https://files.pythonhosted.org/packages/9a/e2/30ca086c692691129849198659bf0556d72a757fe2769eb9620a27169296/contourpy-1.3.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3ea9924d28fc5586bf0b42d15f590b10c224117e74409dd7a0be3b62b74a501c", size = 322689, upload-time = "2024-11-12T10:55:57.858Z" }, + { url = "https://files.pythonhosted.org/packages/6b/77/f37812ef700f1f185d348394debf33f22d531e714cf6a35d13d68a7003c7/contourpy-1.3.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:5b75aa69cb4d6f137b36f7eb2ace9280cfb60c55dc5f61c731fdf6f037f958a3", size = 1268413, upload-time = "2024-11-12T10:56:13.328Z" }, + { url = "https://files.pythonhosted.org/packages/3f/6d/ce84e79cdd128542ebeb268f84abb4b093af78e7f8ec504676673d2675bc/contourpy-1.3.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:041b640d4ec01922083645a94bb3b2e777e6b626788f4095cf21abbe266413c1", size = 1326530, upload-time = "2024-11-12T10:56:30.07Z" }, + { url = "https://files.pythonhosted.org/packages/72/22/8282f4eae20c73c89bee7a82a19c4e27af9b57bb602ecaa00713d5bdb54d/contourpy-1.3.1-cp313-cp313-win32.whl", hash = "sha256:36987a15e8ace5f58d4d5da9dca82d498c2bbb28dff6e5d04fbfcc35a9cb3a82", size = 175315, upload-time = "2024-11-12T10:57:42.804Z" }, + { url = "https://files.pythonhosted.org/packages/e3/d5/28bca491f65312b438fbf076589dcde7f6f966b196d900777f5811b9c4e2/contourpy-1.3.1-cp313-cp313-win_amd64.whl", hash = "sha256:a7895f46d47671fa7ceec40f31fae721da51ad34bdca0bee83e38870b1f47ffd", size = 220987, upload-time = "2024-11-12T10:57:46.365Z" }, + { url = "https://files.pythonhosted.org/packages/2f/24/a4b285d6adaaf9746e4700932f579f1a7b6f9681109f694cfa233ae75c4e/contourpy-1.3.1-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:9ddeb796389dadcd884c7eb07bd14ef12408aaae358f0e2ae24114d797eede30", size = 285001, upload-time = "2024-11-12T10:56:34.483Z" }, + { url = "https://files.pythonhosted.org/packages/48/1d/fb49a401b5ca4f06ccf467cd6c4f1fd65767e63c21322b29b04ec40b40b9/contourpy-1.3.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:19c1555a6801c2f084c7ddc1c6e11f02eb6a6016ca1318dd5452ba3f613a1751", size = 268553, upload-time = "2024-11-12T10:56:39.167Z" }, + { url = "https://files.pythonhosted.org/packages/79/1e/4aef9470d13fd029087388fae750dccb49a50c012a6c8d1d634295caa644/contourpy-1.3.1-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:841ad858cff65c2c04bf93875e384ccb82b654574a6d7f30453a04f04af71342", size = 310386, upload-time = "2024-11-12T10:56:44.594Z" }, + { url = "https://files.pythonhosted.org/packages/b0/34/910dc706ed70153b60392b5305c708c9810d425bde12499c9184a1100888/contourpy-1.3.1-cp313-cp313t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4318af1c925fb9a4fb190559ef3eec206845f63e80fb603d47f2d6d67683901c", size = 349806, upload-time = "2024-11-12T10:56:49.565Z" }, + { url = "https://files.pythonhosted.org/packages/31/3c/faee6a40d66d7f2a87f7102236bf4780c57990dd7f98e5ff29881b1b1344/contourpy-1.3.1-cp313-cp313t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:14c102b0eab282427b662cb590f2e9340a9d91a1c297f48729431f2dcd16e14f", size = 321108, upload-time = "2024-11-12T10:56:55.013Z" }, + { url = "https://files.pythonhosted.org/packages/17/69/390dc9b20dd4bb20585651d7316cc3054b7d4a7b4f8b710b2b698e08968d/contourpy-1.3.1-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:05e806338bfeaa006acbdeba0ad681a10be63b26e1b17317bfac3c5d98f36cda", size = 327291, upload-time = "2024-11-12T10:56:59.897Z" }, + { url = "https://files.pythonhosted.org/packages/ef/74/7030b67c4e941fe1e5424a3d988080e83568030ce0355f7c9fc556455b01/contourpy-1.3.1-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:4d76d5993a34ef3df5181ba3c92fabb93f1eaa5729504fb03423fcd9f3177242", size = 1263752, upload-time = "2024-11-12T10:57:14.79Z" }, + { url = "https://files.pythonhosted.org/packages/f0/ed/92d86f183a8615f13f6b9cbfc5d4298a509d6ce433432e21da838b4b63f4/contourpy-1.3.1-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:89785bb2a1980c1bd87f0cb1517a71cde374776a5f150936b82580ae6ead44a1", size = 1318403, upload-time = "2024-11-12T10:57:31.326Z" }, + { url = "https://files.pythonhosted.org/packages/b3/0e/c8e4950c77dcfc897c71d61e56690a0a9df39543d2164040301b5df8e67b/contourpy-1.3.1-cp313-cp313t-win32.whl", hash = "sha256:8eb96e79b9f3dcadbad2a3891672f81cdcab7f95b27f28f1c67d75f045b6b4f1", size = 185117, upload-time = "2024-11-12T10:57:34.735Z" }, + { url = "https://files.pythonhosted.org/packages/c1/31/1ae946f11dfbd229222e6d6ad8e7bd1891d3d48bde5fbf7a0beb9491f8e3/contourpy-1.3.1-cp313-cp313t-win_amd64.whl", hash = "sha256:287ccc248c9e0d0566934e7d606201abd74761b5703d804ff3df8935f523d546", size = 236668, upload-time = "2024-11-12T10:57:39.061Z" }, +] + +[[package]] +name = "cycler" +version = "0.12.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/a9/95/a3dbbb5028f35eafb79008e7522a75244477d2838f38cbb722248dabc2a8/cycler-0.12.1.tar.gz", hash = "sha256:88bb128f02ba341da8ef447245a9e138fae777f6a23943da4540077d3601eb1c", size = 7615, upload-time = "2023-10-07T05:32:18.335Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e7/05/c19819d5e3d95294a6f5947fb9b9629efb316b96de511b418c53d245aae6/cycler-0.12.1-py3-none-any.whl", hash = "sha256:85cef7cff222d8644161529808465972e51340599459b8ac3ccbac5a854e0d30", size = 8321, upload-time = "2023-10-07T05:32:16.783Z" }, +] + +[[package]] +name = "debugpy" +version = "1.8.12" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/68/25/c74e337134edf55c4dfc9af579eccb45af2393c40960e2795a94351e8140/debugpy-1.8.12.tar.gz", hash = "sha256:646530b04f45c830ceae8e491ca1c9320a2d2f0efea3141487c82130aba70dce", size = 1641122, upload-time = "2025-01-16T17:26:42.727Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/af/9f/5b8af282253615296264d4ef62d14a8686f0dcdebb31a669374e22fff0a4/debugpy-1.8.12-cp311-cp311-macosx_14_0_universal2.whl", hash = "sha256:36f4829839ef0afdfdd208bb54f4c3d0eea86106d719811681a8627ae2e53dd5", size = 2174643, upload-time = "2025-01-16T17:26:59.003Z" }, + { url = "https://files.pythonhosted.org/packages/ef/31/f9274dcd3b0f9f7d1e60373c3fa4696a585c55acb30729d313bb9d3bcbd1/debugpy-1.8.12-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a28ed481d530e3138553be60991d2d61103ce6da254e51547b79549675f539b7", size = 3133457, upload-time = "2025-01-16T17:27:02.014Z" }, + { url = "https://files.pythonhosted.org/packages/ab/ca/6ee59e9892e424477e0c76e3798046f1fd1288040b927319c7a7b0baa484/debugpy-1.8.12-cp311-cp311-win32.whl", hash = "sha256:4ad9a94d8f5c9b954e0e3b137cc64ef3f579d0df3c3698fe9c3734ee397e4abb", size = 5106220, upload-time = "2025-01-16T17:27:05.212Z" }, + { url = "https://files.pythonhosted.org/packages/d5/1a/8ab508ab05ede8a4eae3b139bbc06ea3ca6234f9e8c02713a044f253be5e/debugpy-1.8.12-cp311-cp311-win_amd64.whl", hash = "sha256:4703575b78dd697b294f8c65588dc86874ed787b7348c65da70cfc885efdf1e1", size = 5130481, upload-time = "2025-01-16T17:27:07.291Z" }, + { url = "https://files.pythonhosted.org/packages/ba/e6/0f876ecfe5831ebe4762b19214364753c8bc2b357d28c5d739a1e88325c7/debugpy-1.8.12-cp312-cp312-macosx_14_0_universal2.whl", hash = "sha256:7e94b643b19e8feb5215fa508aee531387494bf668b2eca27fa769ea11d9f498", size = 2500846, upload-time = "2025-01-16T17:27:09.277Z" }, + { url = "https://files.pythonhosted.org/packages/19/64/33f41653a701f3cd2cbff8b41ebaad59885b3428b5afd0d93d16012ecf17/debugpy-1.8.12-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:086b32e233e89a2740c1615c2f775c34ae951508b28b308681dbbb87bba97d06", size = 4222181, upload-time = "2025-01-16T17:27:11.106Z" }, + { url = "https://files.pythonhosted.org/packages/32/a6/02646cfe50bfacc9b71321c47dc19a46e35f4e0aceea227b6d205e900e34/debugpy-1.8.12-cp312-cp312-win32.whl", hash = "sha256:2ae5df899732a6051b49ea2632a9ea67f929604fd2b036613a9f12bc3163b92d", size = 5227017, upload-time = "2025-01-16T17:27:13.29Z" }, + { url = "https://files.pythonhosted.org/packages/da/a6/10056431b5c47103474312cf4a2ec1001f73e0b63b1216706d5fef2531eb/debugpy-1.8.12-cp312-cp312-win_amd64.whl", hash = "sha256:39dfbb6fa09f12fae32639e3286112fc35ae976114f1f3d37375f3130a820969", size = 5267555, upload-time = "2025-01-16T17:27:15.184Z" }, + { url = "https://files.pythonhosted.org/packages/cf/4d/7c3896619a8791effd5d8c31f0834471fc8f8fb3047ec4f5fc69dd1393dd/debugpy-1.8.12-cp313-cp313-macosx_14_0_universal2.whl", hash = "sha256:696d8ae4dff4cbd06bf6b10d671e088b66669f110c7c4e18a44c43cf75ce966f", size = 2485246, upload-time = "2025-01-16T17:27:18.389Z" }, + { url = "https://files.pythonhosted.org/packages/99/46/bc6dcfd7eb8cc969a5716d858e32485eb40c72c6a8dc88d1e3a4d5e95813/debugpy-1.8.12-cp313-cp313-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:898fba72b81a654e74412a67c7e0a81e89723cfe2a3ea6fcd3feaa3395138ca9", size = 4218616, upload-time = "2025-01-16T17:27:20.374Z" }, + { url = "https://files.pythonhosted.org/packages/03/dd/d7fcdf0381a9b8094da1f6a1c9f19fed493a4f8576a2682349b3a8b20ec7/debugpy-1.8.12-cp313-cp313-win32.whl", hash = "sha256:22a11c493c70413a01ed03f01c3c3a2fc4478fc6ee186e340487b2edcd6f4180", size = 5226540, upload-time = "2025-01-16T17:27:22.504Z" }, + { url = "https://files.pythonhosted.org/packages/25/bd/ecb98f5b5fc7ea0bfbb3c355bc1dd57c198a28780beadd1e19915bf7b4d9/debugpy-1.8.12-cp313-cp313-win_amd64.whl", hash = "sha256:fdb3c6d342825ea10b90e43d7f20f01535a72b3a1997850c0c3cefa5c27a4a2c", size = 5267134, upload-time = "2025-01-16T17:27:25.616Z" }, + { url = "https://files.pythonhosted.org/packages/38/c4/5120ad36405c3008f451f94b8f92ef1805b1e516f6ff870f331ccb3c4cc0/debugpy-1.8.12-py2.py3-none-any.whl", hash = "sha256:274b6a2040349b5c9864e475284bce5bb062e63dce368a394b8cc865ae3b00c6", size = 5229490, upload-time = "2025-01-16T17:27:49.412Z" }, +] + +[[package]] +name = "decorator" +version = "5.1.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/66/0c/8d907af351aa16b42caae42f9d6aa37b900c67308052d10fdce809f8d952/decorator-5.1.1.tar.gz", hash = "sha256:637996211036b6385ef91435e4fae22989472f9d571faba8927ba8253acbc330", size = 35016, upload-time = "2022-01-07T08:20:05.666Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d5/50/83c593b07763e1161326b3b8c6686f0f4b0f24d5526546bee538c89837d6/decorator-5.1.1-py3-none-any.whl", hash = "sha256:b8c3f85900b9dc423225913c5aace94729fe1fa9763b38939a95226f02d37186", size = 9073, upload-time = "2022-01-07T08:20:03.734Z" }, +] + +[[package]] +name = "docutils" +version = "0.21.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/ae/ed/aefcc8cd0ba62a0560c3c18c33925362d46c6075480bfa4df87b28e169a9/docutils-0.21.2.tar.gz", hash = "sha256:3a6b18732edf182daa3cd12775bbb338cf5691468f91eeeb109deff6ebfa986f", size = 2204444, upload-time = "2024-04-23T18:57:18.24Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/8f/d7/9322c609343d929e75e7e5e6255e614fcc67572cfd083959cdef3b7aad79/docutils-0.21.2-py3-none-any.whl", hash = "sha256:dafca5b9e384f0e419294eb4d2ff9fa826435bf15f15b7bd45723e8ad76811b2", size = 587408, upload-time = "2024-04-23T18:57:14.835Z" }, +] + +[[package]] +name = "executing" +version = "2.2.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/91/50/a9d80c47ff289c611ff12e63f7c5d13942c65d68125160cefd768c73e6e4/executing-2.2.0.tar.gz", hash = "sha256:5d108c028108fe2551d1a7b2e8b713341e2cb4fc0aa7dcf966fa4327a5226755", size = 978693, upload-time = "2025-01-22T15:41:29.403Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7b/8f/c4d9bafc34ad7ad5d8dc16dd1347ee0e507a52c3adb6bfa8887e1c6a26ba/executing-2.2.0-py2.py3-none-any.whl", hash = "sha256:11387150cad388d62750327a53d3339fad4888b39a6fe233c3afbb54ecffd3aa", size = 26702, upload-time = "2025-01-22T15:41:25.929Z" }, +] + +[[package]] +name = "fonttools" +version = "4.56.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/1c/8c/9ffa2a555af0e5e5d0e2ed7fdd8c9bef474ed676995bb4c57c9cd0014248/fonttools-4.56.0.tar.gz", hash = "sha256:a114d1567e1a1586b7e9e7fc2ff686ca542a82769a296cef131e4c4af51e58f4", size = 3462892, upload-time = "2025-02-07T13:46:29.026Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/35/56/a2f3e777d48fcae7ecd29de4d96352d84e5ea9871e5f3fc88241521572cf/fonttools-4.56.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:7ef04bc7827adb7532be3d14462390dd71287644516af3f1e67f1e6ff9c6d6df", size = 2753325, upload-time = "2025-02-07T13:43:57.855Z" }, + { url = "https://files.pythonhosted.org/packages/71/85/d483e9c4e5ed586b183bf037a353e8d766366b54fd15519b30e6178a6a6e/fonttools-4.56.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:ffda9b8cd9cb8b301cae2602ec62375b59e2e2108a117746f12215145e3f786c", size = 2281554, upload-time = "2025-02-07T13:44:01.671Z" }, + { url = "https://files.pythonhosted.org/packages/09/67/060473b832b2fade03c127019794df6dc02d9bc66fa4210b8e0d8a99d1e5/fonttools-4.56.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e2e993e8db36306cc3f1734edc8ea67906c55f98683d6fd34c3fc5593fdbba4c", size = 4869260, upload-time = "2025-02-07T13:44:05.746Z" }, + { url = "https://files.pythonhosted.org/packages/28/e9/47c02d5a7027e8ed841ab6a10ca00c93dadd5f16742f1af1fa3f9978adf4/fonttools-4.56.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:003548eadd674175510773f73fb2060bb46adb77c94854af3e0cc5bc70260049", size = 4898508, upload-time = "2025-02-07T13:44:09.965Z" }, + { url = "https://files.pythonhosted.org/packages/bf/8a/221d456d1afb8ca043cfd078f59f187ee5d0a580f4b49351b9ce95121f57/fonttools-4.56.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:bd9825822e7bb243f285013e653f6741954d8147427aaa0324a862cdbf4cbf62", size = 4877700, upload-time = "2025-02-07T13:44:13.598Z" }, + { url = "https://files.pythonhosted.org/packages/a4/8c/e503863adf7a6aeff7b960e2f66fa44dd0c29a7a8b79765b2821950d7b05/fonttools-4.56.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:b23d30a2c0b992fb1c4f8ac9bfde44b5586d23457759b6cf9a787f1a35179ee0", size = 5045817, upload-time = "2025-02-07T13:44:17.532Z" }, + { url = "https://files.pythonhosted.org/packages/2b/50/79ba3b7e42f4eaa70b82b9e79155f0f6797858dc8a97862428b6852c6aee/fonttools-4.56.0-cp311-cp311-win32.whl", hash = "sha256:47b5e4680002ae1756d3ae3b6114e20aaee6cc5c69d1e5911f5ffffd3ee46c6b", size = 2154426, upload-time = "2025-02-07T13:44:21.063Z" }, + { url = "https://files.pythonhosted.org/packages/3b/90/4926e653041c4116ecd43e50e3c79f5daae6dcafc58ceb64bc4f71dd4924/fonttools-4.56.0-cp311-cp311-win_amd64.whl", hash = "sha256:14a3e3e6b211660db54ca1ef7006401e4a694e53ffd4553ab9bc87ead01d0f05", size = 2200937, upload-time = "2025-02-07T13:44:24.607Z" }, + { url = "https://files.pythonhosted.org/packages/39/32/71cfd6877999576a11824a7fe7bc0bb57c5c72b1f4536fa56a3e39552643/fonttools-4.56.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:d6f195c14c01bd057bc9b4f70756b510e009c83c5ea67b25ced3e2c38e6ee6e9", size = 2747757, upload-time = "2025-02-07T13:44:28.021Z" }, + { url = "https://files.pythonhosted.org/packages/15/52/d9f716b072c5061a0b915dd4c387f74bef44c68c069e2195c753905bd9b7/fonttools-4.56.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:fa760e5fe8b50cbc2d71884a1eff2ed2b95a005f02dda2fa431560db0ddd927f", size = 2279007, upload-time = "2025-02-07T13:44:31.325Z" }, + { url = "https://files.pythonhosted.org/packages/d1/97/f1b3a8afa9a0d814a092a25cd42f59ccb98a0bb7a295e6e02fc9ba744214/fonttools-4.56.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d54a45d30251f1d729e69e5b675f9a08b7da413391a1227781e2a297fa37f6d2", size = 4783991, upload-time = "2025-02-07T13:44:34.888Z" }, + { url = "https://files.pythonhosted.org/packages/95/70/2a781bedc1c45a0c61d29c56425609b22ed7f971da5d7e5df2679488741b/fonttools-4.56.0-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:661a8995d11e6e4914a44ca7d52d1286e2d9b154f685a4d1f69add8418961563", size = 4855109, upload-time = "2025-02-07T13:44:40.702Z" }, + { url = "https://files.pythonhosted.org/packages/0c/02/a2597858e61a5e3fb6a14d5f6be9e6eb4eaf090da56ad70cedcbdd201685/fonttools-4.56.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:9d94449ad0a5f2a8bf5d2f8d71d65088aee48adbe45f3c5f8e00e3ad861ed81a", size = 4762496, upload-time = "2025-02-07T13:44:45.929Z" }, + { url = "https://files.pythonhosted.org/packages/f2/00/aaf00100d6078fdc73f7352b44589804af9dc12b182a2540b16002152ba4/fonttools-4.56.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:f59746f7953f69cc3290ce2f971ab01056e55ddd0fb8b792c31a8acd7fee2d28", size = 4990094, upload-time = "2025-02-07T13:44:49.004Z" }, + { url = "https://files.pythonhosted.org/packages/bf/dc/3ff1db522460db60cf3adaf1b64e0c72b43406717d139786d3fa1eb20709/fonttools-4.56.0-cp312-cp312-win32.whl", hash = "sha256:bce60f9a977c9d3d51de475af3f3581d9b36952e1f8fc19a1f2254f1dda7ce9c", size = 2142888, upload-time = "2025-02-07T13:44:54.127Z" }, + { url = "https://files.pythonhosted.org/packages/6f/e3/5a181a85777f7809076e51f7422e0dc77eb04676c40ec8bf6a49d390d1ff/fonttools-4.56.0-cp312-cp312-win_amd64.whl", hash = "sha256:300c310bb725b2bdb4f5fc7e148e190bd69f01925c7ab437b9c0ca3e1c7cd9ba", size = 2189734, upload-time = "2025-02-07T13:44:57.393Z" }, + { url = "https://files.pythonhosted.org/packages/a5/55/f06b48d48e0b4ec3a3489efafe9bd4d81b6e0802ac51026e3ee4634e89ba/fonttools-4.56.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:f20e2c0dfab82983a90f3d00703ac0960412036153e5023eed2b4641d7d5e692", size = 2735127, upload-time = "2025-02-07T13:44:59.966Z" }, + { url = "https://files.pythonhosted.org/packages/59/db/d2c7c9b6dd5cbd46f183e650a47403ffb88fca17484eb7c4b1cd88f9e513/fonttools-4.56.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:f36a0868f47b7566237640c026c65a86d09a3d9ca5df1cd039e30a1da73098a0", size = 2272519, upload-time = "2025-02-07T13:45:03.891Z" }, + { url = "https://files.pythonhosted.org/packages/4d/a2/da62d779c34a0e0c06415f02eab7fa3466de5d46df459c0275a255cefc65/fonttools-4.56.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:62b4c6802fa28e14dba010e75190e0e6228513573f1eeae57b11aa1a39b7e5b1", size = 4762423, upload-time = "2025-02-07T13:45:07.034Z" }, + { url = "https://files.pythonhosted.org/packages/be/6a/fd4018e0448c8a5e12138906411282c5eab51a598493f080a9f0960e658f/fonttools-4.56.0-cp313-cp313-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a05d1f07eb0a7d755fbe01fee1fd255c3a4d3730130cf1bfefb682d18fd2fcea", size = 4834442, upload-time = "2025-02-07T13:45:10.6Z" }, + { url = "https://files.pythonhosted.org/packages/6d/63/fa1dec8efb35bc11ef9c39b2d74754b45d48a3ccb2cf78c0109c0af639e8/fonttools-4.56.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:0073b62c3438cf0058488c002ea90489e8801d3a7af5ce5f7c05c105bee815c3", size = 4742800, upload-time = "2025-02-07T13:45:14.096Z" }, + { url = "https://files.pythonhosted.org/packages/dd/f4/963247ae8c73ccc4cf2929e7162f595c81dbe17997d1d0ea77da24a217c9/fonttools-4.56.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:e2cad98c94833465bcf28f51c248aaf07ca022efc6a3eba750ad9c1e0256d278", size = 4963746, upload-time = "2025-02-07T13:45:17.479Z" }, + { url = "https://files.pythonhosted.org/packages/ea/e0/46f9600c39c644b54e4420f941f75fa200d9288c9ae171e5d80918b8cbb9/fonttools-4.56.0-cp313-cp313-win32.whl", hash = "sha256:d0cb73ccf7f6d7ca8d0bc7ea8ac0a5b84969a41c56ac3ac3422a24df2680546f", size = 2140927, upload-time = "2025-02-07T13:45:21.084Z" }, + { url = "https://files.pythonhosted.org/packages/27/6d/3edda54f98a550a0473f032d8050315fbc8f1b76a0d9f3879b72ebb2cdd6/fonttools-4.56.0-cp313-cp313-win_amd64.whl", hash = "sha256:62cc1253827d1e500fde9dbe981219fea4eb000fd63402283472d38e7d8aa1c6", size = 2186709, upload-time = "2025-02-07T13:45:23.719Z" }, + { url = "https://files.pythonhosted.org/packages/bf/ff/44934a031ce5a39125415eb405b9efb76fe7f9586b75291d66ae5cbfc4e6/fonttools-4.56.0-py3-none-any.whl", hash = "sha256:1088182f68c303b50ca4dc0c82d42083d176cba37af1937e1a976a31149d4d14", size = 1089800, upload-time = "2025-02-07T13:46:26.415Z" }, +] + +[[package]] +name = "idna" +version = "3.10" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f1/70/7703c29685631f5a7590aa73f1f1d3fa9a380e654b86af429e0934a32f7d/idna-3.10.tar.gz", hash = "sha256:12f65c9b470abda6dc35cf8e63cc574b1c52b11df2c86030af0ac09b01b13ea9", size = 190490, upload-time = "2024-09-15T18:07:39.745Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/76/c6/c88e154df9c4e1a2a66ccf0005a88dfb2650c1dffb6f5ce603dfbd452ce3/idna-3.10-py3-none-any.whl", hash = "sha256:946d195a0d259cbba61165e88e65941f16e9b36ea6ddb97f00452bae8b1287d3", size = 70442, upload-time = "2024-09-15T18:07:37.964Z" }, +] + +[[package]] +name = "imagesize" +version = "1.4.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/a7/84/62473fb57d61e31fef6e36d64a179c8781605429fd927b5dd608c997be31/imagesize-1.4.1.tar.gz", hash = "sha256:69150444affb9cb0d5cc5a92b3676f0b2fb7cd9ae39e947a5e11a36b4497cd4a", size = 1280026, upload-time = "2022-07-01T12:21:05.687Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ff/62/85c4c919272577931d407be5ba5d71c20f0b616d31a0befe0ae45bb79abd/imagesize-1.4.1-py2.py3-none-any.whl", hash = "sha256:0d8d18d08f840c19d0ee7ca1fd82490fdc3729b7ac93f49870406ddde8ef8d8b", size = 8769, upload-time = "2022-07-01T12:21:02.467Z" }, +] + +[[package]] +name = "iniconfig" +version = "2.0.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/d7/4b/cbd8e699e64a6f16ca3a8220661b5f83792b3017d0f79807cb8708d33913/iniconfig-2.0.0.tar.gz", hash = "sha256:2d91e135bf72d31a410b17c16da610a82cb55f6b0477d1a902134b24a455b8b3", size = 4646, upload-time = "2023-01-07T11:08:11.254Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ef/a6/62565a6e1cf69e10f5727360368e451d4b7f58beeac6173dc9db836a5b46/iniconfig-2.0.0-py3-none-any.whl", hash = "sha256:b6a85871a79d2e3b22d2d1b94ac2824226a63c6b741c88f7ae975f18b6778374", size = 5892, upload-time = "2023-01-07T11:08:09.864Z" }, +] + +[[package]] +name = "ipykernel" +version = "6.29.5" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "appnope", marker = "sys_platform == 'darwin'" }, + { name = "comm" }, + { name = "debugpy" }, + { name = "ipython" }, + { name = "jupyter-client" }, + { name = "jupyter-core" }, + { name = "matplotlib-inline" }, + { name = "nest-asyncio" }, + { name = "packaging" }, + { name = "psutil" }, + { name = "pyzmq" }, + { name = "tornado" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/e9/5c/67594cb0c7055dc50814b21731c22a601101ea3b1b50a9a1b090e11f5d0f/ipykernel-6.29.5.tar.gz", hash = "sha256:f093a22c4a40f8828f8e330a9c297cb93dcab13bd9678ded6de8e5cf81c56215", size = 163367, upload-time = "2024-07-01T14:07:22.543Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/94/5c/368ae6c01c7628438358e6d337c19b05425727fbb221d2a3c4303c372f42/ipykernel-6.29.5-py3-none-any.whl", hash = "sha256:afdb66ba5aa354b09b91379bac28ae4afebbb30e8b39510c9690afb7a10421b5", size = 117173, upload-time = "2024-07-01T14:07:19.603Z" }, +] + +[[package]] +name = "ipython" +version = "8.32.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "colorama", marker = "sys_platform == 'win32'" }, + { name = "decorator" }, + { name = "jedi" }, + { name = "matplotlib-inline" }, + { name = "pexpect", marker = "sys_platform != 'emscripten' and sys_platform != 'win32'" }, + { name = "prompt-toolkit" }, + { name = "pygments" }, + { name = "stack-data" }, + { name = "traitlets" }, + { name = "typing-extensions", marker = "python_full_version < '3.12'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/36/80/4d2a072e0db7d250f134bc11676517299264ebe16d62a8619d49a78ced73/ipython-8.32.0.tar.gz", hash = "sha256:be2c91895b0b9ea7ba49d33b23e2040c352b33eb6a519cca7ce6e0c743444251", size = 5507441, upload-time = "2025-01-31T14:04:45.197Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e7/e1/f4474a7ecdb7745a820f6f6039dc43c66add40f1bcc66485607d93571af6/ipython-8.32.0-py3-none-any.whl", hash = "sha256:cae85b0c61eff1fc48b0a8002de5958b6528fa9c8defb1894da63f42613708aa", size = 825524, upload-time = "2025-01-31T14:04:41.675Z" }, +] + +[[package]] +name = "jedi" +version = "0.19.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "parso" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/72/3a/79a912fbd4d8dd6fbb02bf69afd3bb72cf0c729bb3063c6f4498603db17a/jedi-0.19.2.tar.gz", hash = "sha256:4770dc3de41bde3966b02eb84fbcf557fb33cce26ad23da12c742fb50ecb11f0", size = 1231287, upload-time = "2024-11-11T01:41:42.873Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c0/5a/9cac0c82afec3d09ccd97c8b6502d48f165f9124db81b4bcb90b4af974ee/jedi-0.19.2-py2.py3-none-any.whl", hash = "sha256:a8ef22bde8490f57fe5c7681a3c83cb58874daf72b4784de3cce5b6ef6edb5b9", size = 1572278, upload-time = "2024-11-11T01:41:40.175Z" }, +] + +[[package]] +name = "jinja2" +version = "3.1.5" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "markupsafe" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/af/92/b3130cbbf5591acf9ade8708c365f3238046ac7cb8ccba6e81abccb0ccff/jinja2-3.1.5.tar.gz", hash = "sha256:8fefff8dc3034e27bb80d67c671eb8a9bc424c0ef4c0826edbff304cceff43bb", size = 244674, upload-time = "2024-12-21T18:30:22.828Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/bd/0f/2ba5fbcd631e3e88689309dbe978c5769e883e4b84ebfe7da30b43275c5a/jinja2-3.1.5-py3-none-any.whl", hash = "sha256:aba0f4dc9ed8013c424088f68a5c226f7d6097ed89b246d7749c2ec4175c6adb", size = 134596, upload-time = "2024-12-21T18:30:19.133Z" }, +] + +[[package]] +name = "jupyter-client" +version = "8.6.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "jupyter-core" }, + { name = "python-dateutil" }, + { name = "pyzmq" }, + { name = "tornado" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/71/22/bf9f12fdaeae18019a468b68952a60fe6dbab5d67cd2a103cac7659b41ca/jupyter_client-8.6.3.tar.gz", hash = "sha256:35b3a0947c4a6e9d589eb97d7d4cd5e90f910ee73101611f01283732bd6d9419", size = 342019, upload-time = "2024-09-17T10:44:17.613Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/11/85/b0394e0b6fcccd2c1eeefc230978a6f8cb0c5df1e4cd3e7625735a0d7d1e/jupyter_client-8.6.3-py3-none-any.whl", hash = "sha256:e8a19cc986cc45905ac3362915f410f3af85424b4c0905e94fa5f2cb08e8f23f", size = 106105, upload-time = "2024-09-17T10:44:15.218Z" }, +] + +[[package]] +name = "jupyter-core" +version = "5.7.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "platformdirs" }, + { name = "pywin32", marker = "platform_python_implementation != 'PyPy' and sys_platform == 'win32'" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/00/11/b56381fa6c3f4cc5d2cf54a7dbf98ad9aa0b339ef7a601d6053538b079a7/jupyter_core-5.7.2.tar.gz", hash = "sha256:aa5f8d32bbf6b431ac830496da7392035d6f61b4f54872f15c4bd2a9c3f536d9", size = 87629, upload-time = "2024-03-12T12:37:35.652Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c9/fb/108ecd1fe961941959ad0ee4e12ee7b8b1477247f30b1fdfd83ceaf017f0/jupyter_core-5.7.2-py3-none-any.whl", hash = "sha256:4f7315d2f6b4bcf2e3e7cb6e46772eba760ae459cd1f59d29eb57b0a01bd7409", size = 28965, upload-time = "2024-03-12T12:37:32.36Z" }, +] + +[[package]] +name = "kiwisolver" +version = "1.4.8" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/82/59/7c91426a8ac292e1cdd53a63b6d9439abd573c875c3f92c146767dd33faf/kiwisolver-1.4.8.tar.gz", hash = "sha256:23d5f023bdc8c7e54eb65f03ca5d5bb25b601eac4d7f1a042888a1f45237987e", size = 97538, upload-time = "2024-12-24T18:30:51.519Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/da/ed/c913ee28936c371418cb167b128066ffb20bbf37771eecc2c97edf8a6e4c/kiwisolver-1.4.8-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:a4d3601908c560bdf880f07d94f31d734afd1bb71e96585cace0e38ef44c6d84", size = 124635, upload-time = "2024-12-24T18:28:51.826Z" }, + { url = "https://files.pythonhosted.org/packages/4c/45/4a7f896f7467aaf5f56ef093d1f329346f3b594e77c6a3c327b2d415f521/kiwisolver-1.4.8-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:856b269c4d28a5c0d5e6c1955ec36ebfd1651ac00e1ce0afa3e28da95293b561", size = 66717, upload-time = "2024-12-24T18:28:54.256Z" }, + { url = "https://files.pythonhosted.org/packages/5f/b4/c12b3ac0852a3a68f94598d4c8d569f55361beef6159dce4e7b624160da2/kiwisolver-1.4.8-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:c2b9a96e0f326205af81a15718a9073328df1173a2619a68553decb7097fd5d7", size = 65413, upload-time = "2024-12-24T18:28:55.184Z" }, + { url = "https://files.pythonhosted.org/packages/a9/98/1df4089b1ed23d83d410adfdc5947245c753bddfbe06541c4aae330e9e70/kiwisolver-1.4.8-cp311-cp311-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:c5020c83e8553f770cb3b5fc13faac40f17e0b205bd237aebd21d53d733adb03", size = 1343994, upload-time = "2024-12-24T18:28:57.493Z" }, + { url = "https://files.pythonhosted.org/packages/8d/bf/b4b169b050c8421a7c53ea1ea74e4ef9c335ee9013216c558a047f162d20/kiwisolver-1.4.8-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:dace81d28c787956bfbfbbfd72fdcef014f37d9b48830829e488fdb32b49d954", size = 1434804, upload-time = "2024-12-24T18:29:00.077Z" }, + { url = "https://files.pythonhosted.org/packages/66/5a/e13bd341fbcf73325ea60fdc8af752addf75c5079867af2e04cc41f34434/kiwisolver-1.4.8-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:11e1022b524bd48ae56c9b4f9296bce77e15a2e42a502cceba602f804b32bb79", size = 1450690, upload-time = "2024-12-24T18:29:01.401Z" }, + { url = "https://files.pythonhosted.org/packages/9b/4f/5955dcb376ba4a830384cc6fab7d7547bd6759fe75a09564910e9e3bb8ea/kiwisolver-1.4.8-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:3b9b4d2892fefc886f30301cdd80debd8bb01ecdf165a449eb6e78f79f0fabd6", size = 1376839, upload-time = "2024-12-24T18:29:02.685Z" }, + { url = "https://files.pythonhosted.org/packages/3a/97/5edbed69a9d0caa2e4aa616ae7df8127e10f6586940aa683a496c2c280b9/kiwisolver-1.4.8-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3a96c0e790ee875d65e340ab383700e2b4891677b7fcd30a699146f9384a2bb0", size = 1435109, upload-time = "2024-12-24T18:29:04.113Z" }, + { url = "https://files.pythonhosted.org/packages/13/fc/e756382cb64e556af6c1809a1bbb22c141bbc2445049f2da06b420fe52bf/kiwisolver-1.4.8-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:23454ff084b07ac54ca8be535f4174170c1094a4cff78fbae4f73a4bcc0d4dab", size = 2245269, upload-time = "2024-12-24T18:29:05.488Z" }, + { url = "https://files.pythonhosted.org/packages/76/15/e59e45829d7f41c776d138245cabae6515cb4eb44b418f6d4109c478b481/kiwisolver-1.4.8-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:87b287251ad6488e95b4f0b4a79a6d04d3ea35fde6340eb38fbd1ca9cd35bbbc", size = 2393468, upload-time = "2024-12-24T18:29:06.79Z" }, + { url = "https://files.pythonhosted.org/packages/e9/39/483558c2a913ab8384d6e4b66a932406f87c95a6080112433da5ed668559/kiwisolver-1.4.8-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:b21dbe165081142b1232a240fc6383fd32cdd877ca6cc89eab93e5f5883e1c25", size = 2355394, upload-time = "2024-12-24T18:29:08.24Z" }, + { url = "https://files.pythonhosted.org/packages/01/aa/efad1fbca6570a161d29224f14b082960c7e08268a133fe5dc0f6906820e/kiwisolver-1.4.8-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:768cade2c2df13db52475bd28d3a3fac8c9eff04b0e9e2fda0f3760f20b3f7fc", size = 2490901, upload-time = "2024-12-24T18:29:09.653Z" }, + { url = "https://files.pythonhosted.org/packages/c9/4f/15988966ba46bcd5ab9d0c8296914436720dd67fca689ae1a75b4ec1c72f/kiwisolver-1.4.8-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:d47cfb2650f0e103d4bf68b0b5804c68da97272c84bb12850d877a95c056bd67", size = 2312306, upload-time = "2024-12-24T18:29:12.644Z" }, + { url = "https://files.pythonhosted.org/packages/2d/27/bdf1c769c83f74d98cbc34483a972f221440703054894a37d174fba8aa68/kiwisolver-1.4.8-cp311-cp311-win_amd64.whl", hash = "sha256:ed33ca2002a779a2e20eeb06aea7721b6e47f2d4b8a8ece979d8ba9e2a167e34", size = 71966, upload-time = "2024-12-24T18:29:14.089Z" }, + { url = "https://files.pythonhosted.org/packages/4a/c9/9642ea855604aeb2968a8e145fc662edf61db7632ad2e4fb92424be6b6c0/kiwisolver-1.4.8-cp311-cp311-win_arm64.whl", hash = "sha256:16523b40aab60426ffdebe33ac374457cf62863e330a90a0383639ce14bf44b2", size = 65311, upload-time = "2024-12-24T18:29:15.892Z" }, + { url = "https://files.pythonhosted.org/packages/fc/aa/cea685c4ab647f349c3bc92d2daf7ae34c8e8cf405a6dcd3a497f58a2ac3/kiwisolver-1.4.8-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:d6af5e8815fd02997cb6ad9bbed0ee1e60014438ee1a5c2444c96f87b8843502", size = 124152, upload-time = "2024-12-24T18:29:16.85Z" }, + { url = "https://files.pythonhosted.org/packages/c5/0b/8db6d2e2452d60d5ebc4ce4b204feeb16176a851fd42462f66ade6808084/kiwisolver-1.4.8-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:bade438f86e21d91e0cf5dd7c0ed00cda0f77c8c1616bd83f9fc157fa6760d31", size = 66555, upload-time = "2024-12-24T18:29:19.146Z" }, + { url = "https://files.pythonhosted.org/packages/60/26/d6a0db6785dd35d3ba5bf2b2df0aedc5af089962c6eb2cbf67a15b81369e/kiwisolver-1.4.8-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:b83dc6769ddbc57613280118fb4ce3cd08899cc3369f7d0e0fab518a7cf37fdb", size = 65067, upload-time = "2024-12-24T18:29:20.096Z" }, + { url = "https://files.pythonhosted.org/packages/c9/ed/1d97f7e3561e09757a196231edccc1bcf59d55ddccefa2afc9c615abd8e0/kiwisolver-1.4.8-cp312-cp312-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:111793b232842991be367ed828076b03d96202c19221b5ebab421ce8bcad016f", size = 1378443, upload-time = "2024-12-24T18:29:22.843Z" }, + { url = "https://files.pythonhosted.org/packages/29/61/39d30b99954e6b46f760e6289c12fede2ab96a254c443639052d1b573fbc/kiwisolver-1.4.8-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:257af1622860e51b1a9d0ce387bf5c2c4f36a90594cb9514f55b074bcc787cfc", size = 1472728, upload-time = "2024-12-24T18:29:24.463Z" }, + { url = "https://files.pythonhosted.org/packages/0c/3e/804163b932f7603ef256e4a715e5843a9600802bb23a68b4e08c8c0ff61d/kiwisolver-1.4.8-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:69b5637c3f316cab1ec1c9a12b8c5f4750a4c4b71af9157645bf32830e39c03a", size = 1478388, upload-time = "2024-12-24T18:29:25.776Z" }, + { url = "https://files.pythonhosted.org/packages/8a/9e/60eaa75169a154700be74f875a4d9961b11ba048bef315fbe89cb6999056/kiwisolver-1.4.8-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:782bb86f245ec18009890e7cb8d13a5ef54dcf2ebe18ed65f795e635a96a1c6a", size = 1413849, upload-time = "2024-12-24T18:29:27.202Z" }, + { url = "https://files.pythonhosted.org/packages/bc/b3/9458adb9472e61a998c8c4d95cfdfec91c73c53a375b30b1428310f923e4/kiwisolver-1.4.8-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:cc978a80a0db3a66d25767b03688f1147a69e6237175c0f4ffffaaedf744055a", size = 1475533, upload-time = "2024-12-24T18:29:28.638Z" }, + { url = "https://files.pythonhosted.org/packages/e4/7a/0a42d9571e35798de80aef4bb43a9b672aa7f8e58643d7bd1950398ffb0a/kiwisolver-1.4.8-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:36dbbfd34838500a31f52c9786990d00150860e46cd5041386f217101350f0d3", size = 2268898, upload-time = "2024-12-24T18:29:30.368Z" }, + { url = "https://files.pythonhosted.org/packages/d9/07/1255dc8d80271400126ed8db35a1795b1a2c098ac3a72645075d06fe5c5d/kiwisolver-1.4.8-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:eaa973f1e05131de5ff3569bbba7f5fd07ea0595d3870ed4a526d486fe57fa1b", size = 2425605, upload-time = "2024-12-24T18:29:33.151Z" }, + { url = "https://files.pythonhosted.org/packages/84/df/5a3b4cf13780ef6f6942df67b138b03b7e79e9f1f08f57c49957d5867f6e/kiwisolver-1.4.8-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:a66f60f8d0c87ab7f59b6fb80e642ebb29fec354a4dfad687ca4092ae69d04f4", size = 2375801, upload-time = "2024-12-24T18:29:34.584Z" }, + { url = "https://files.pythonhosted.org/packages/8f/10/2348d068e8b0f635c8c86892788dac7a6b5c0cb12356620ab575775aad89/kiwisolver-1.4.8-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:858416b7fb777a53f0c59ca08190ce24e9abbd3cffa18886a5781b8e3e26f65d", size = 2520077, upload-time = "2024-12-24T18:29:36.138Z" }, + { url = "https://files.pythonhosted.org/packages/32/d8/014b89fee5d4dce157d814303b0fce4d31385a2af4c41fed194b173b81ac/kiwisolver-1.4.8-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:085940635c62697391baafaaeabdf3dd7a6c3643577dde337f4d66eba021b2b8", size = 2338410, upload-time = "2024-12-24T18:29:39.991Z" }, + { url = "https://files.pythonhosted.org/packages/bd/72/dfff0cc97f2a0776e1c9eb5bef1ddfd45f46246c6533b0191887a427bca5/kiwisolver-1.4.8-cp312-cp312-win_amd64.whl", hash = "sha256:01c3d31902c7db5fb6182832713d3b4122ad9317c2c5877d0539227d96bb2e50", size = 71853, upload-time = "2024-12-24T18:29:42.006Z" }, + { url = "https://files.pythonhosted.org/packages/dc/85/220d13d914485c0948a00f0b9eb419efaf6da81b7d72e88ce2391f7aed8d/kiwisolver-1.4.8-cp312-cp312-win_arm64.whl", hash = "sha256:a3c44cb68861de93f0c4a8175fbaa691f0aa22550c331fefef02b618a9dcb476", size = 65424, upload-time = "2024-12-24T18:29:44.38Z" }, + { url = "https://files.pythonhosted.org/packages/79/b3/e62464a652f4f8cd9006e13d07abad844a47df1e6537f73ddfbf1bc997ec/kiwisolver-1.4.8-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:1c8ceb754339793c24aee1c9fb2485b5b1f5bb1c2c214ff13368431e51fc9a09", size = 124156, upload-time = "2024-12-24T18:29:45.368Z" }, + { url = "https://files.pythonhosted.org/packages/8d/2d/f13d06998b546a2ad4f48607a146e045bbe48030774de29f90bdc573df15/kiwisolver-1.4.8-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:54a62808ac74b5e55a04a408cda6156f986cefbcf0ada13572696b507cc92fa1", size = 66555, upload-time = "2024-12-24T18:29:46.37Z" }, + { url = "https://files.pythonhosted.org/packages/59/e3/b8bd14b0a54998a9fd1e8da591c60998dc003618cb19a3f94cb233ec1511/kiwisolver-1.4.8-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:68269e60ee4929893aad82666821aaacbd455284124817af45c11e50a4b42e3c", size = 65071, upload-time = "2024-12-24T18:29:47.333Z" }, + { url = "https://files.pythonhosted.org/packages/f0/1c/6c86f6d85ffe4d0ce04228d976f00674f1df5dc893bf2dd4f1928748f187/kiwisolver-1.4.8-cp313-cp313-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:34d142fba9c464bc3bbfeff15c96eab0e7310343d6aefb62a79d51421fcc5f1b", size = 1378053, upload-time = "2024-12-24T18:29:49.636Z" }, + { url = "https://files.pythonhosted.org/packages/4e/b9/1c6e9f6dcb103ac5cf87cb695845f5fa71379021500153566d8a8a9fc291/kiwisolver-1.4.8-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3ddc373e0eef45b59197de815b1b28ef89ae3955e7722cc9710fb91cd77b7f47", size = 1472278, upload-time = "2024-12-24T18:29:51.164Z" }, + { url = "https://files.pythonhosted.org/packages/ee/81/aca1eb176de671f8bda479b11acdc42c132b61a2ac861c883907dde6debb/kiwisolver-1.4.8-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:77e6f57a20b9bd4e1e2cedda4d0b986ebd0216236f0106e55c28aea3d3d69b16", size = 1478139, upload-time = "2024-12-24T18:29:52.594Z" }, + { url = "https://files.pythonhosted.org/packages/49/f4/e081522473671c97b2687d380e9e4c26f748a86363ce5af48b4a28e48d06/kiwisolver-1.4.8-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:08e77738ed7538f036cd1170cbed942ef749137b1311fa2bbe2a7fda2f6bf3cc", size = 1413517, upload-time = "2024-12-24T18:29:53.941Z" }, + { url = "https://files.pythonhosted.org/packages/8f/e9/6a7d025d8da8c4931522922cd706105aa32b3291d1add8c5427cdcd66e63/kiwisolver-1.4.8-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a5ce1e481a74b44dd5e92ff03ea0cb371ae7a0268318e202be06c8f04f4f1246", size = 1474952, upload-time = "2024-12-24T18:29:56.523Z" }, + { url = "https://files.pythonhosted.org/packages/82/13/13fa685ae167bee5d94b415991c4fc7bb0a1b6ebea6e753a87044b209678/kiwisolver-1.4.8-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:fc2ace710ba7c1dfd1a3b42530b62b9ceed115f19a1656adefce7b1782a37794", size = 2269132, upload-time = "2024-12-24T18:29:57.989Z" }, + { url = "https://files.pythonhosted.org/packages/ef/92/bb7c9395489b99a6cb41d502d3686bac692586db2045adc19e45ee64ed23/kiwisolver-1.4.8-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:3452046c37c7692bd52b0e752b87954ef86ee2224e624ef7ce6cb21e8c41cc1b", size = 2425997, upload-time = "2024-12-24T18:29:59.393Z" }, + { url = "https://files.pythonhosted.org/packages/ed/12/87f0e9271e2b63d35d0d8524954145837dd1a6c15b62a2d8c1ebe0f182b4/kiwisolver-1.4.8-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:7e9a60b50fe8b2ec6f448fe8d81b07e40141bfced7f896309df271a0b92f80f3", size = 2376060, upload-time = "2024-12-24T18:30:01.338Z" }, + { url = "https://files.pythonhosted.org/packages/02/6e/c8af39288edbce8bf0fa35dee427b082758a4b71e9c91ef18fa667782138/kiwisolver-1.4.8-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:918139571133f366e8362fa4a297aeba86c7816b7ecf0bc79168080e2bd79957", size = 2520471, upload-time = "2024-12-24T18:30:04.574Z" }, + { url = "https://files.pythonhosted.org/packages/13/78/df381bc7b26e535c91469f77f16adcd073beb3e2dd25042efd064af82323/kiwisolver-1.4.8-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:e063ef9f89885a1d68dd8b2e18f5ead48653176d10a0e324e3b0030e3a69adeb", size = 2338793, upload-time = "2024-12-24T18:30:06.25Z" }, + { url = "https://files.pythonhosted.org/packages/d0/dc/c1abe38c37c071d0fc71c9a474fd0b9ede05d42f5a458d584619cfd2371a/kiwisolver-1.4.8-cp313-cp313-win_amd64.whl", hash = "sha256:a17b7c4f5b2c51bb68ed379defd608a03954a1845dfed7cc0117f1cc8a9b7fd2", size = 71855, upload-time = "2024-12-24T18:30:07.535Z" }, + { url = "https://files.pythonhosted.org/packages/a0/b6/21529d595b126ac298fdd90b705d87d4c5693de60023e0efcb4f387ed99e/kiwisolver-1.4.8-cp313-cp313-win_arm64.whl", hash = "sha256:3cd3bc628b25f74aedc6d374d5babf0166a92ff1317f46267f12d2ed54bc1d30", size = 65430, upload-time = "2024-12-24T18:30:08.504Z" }, + { url = "https://files.pythonhosted.org/packages/34/bd/b89380b7298e3af9b39f49334e3e2a4af0e04819789f04b43d560516c0c8/kiwisolver-1.4.8-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:370fd2df41660ed4e26b8c9d6bbcad668fbe2560462cba151a721d49e5b6628c", size = 126294, upload-time = "2024-12-24T18:30:09.508Z" }, + { url = "https://files.pythonhosted.org/packages/83/41/5857dc72e5e4148eaac5aa76e0703e594e4465f8ab7ec0fc60e3a9bb8fea/kiwisolver-1.4.8-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:84a2f830d42707de1d191b9490ac186bf7997a9495d4e9072210a1296345f7dc", size = 67736, upload-time = "2024-12-24T18:30:11.039Z" }, + { url = "https://files.pythonhosted.org/packages/e1/d1/be059b8db56ac270489fb0b3297fd1e53d195ba76e9bbb30e5401fa6b759/kiwisolver-1.4.8-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:7a3ad337add5148cf51ce0b55642dc551c0b9d6248458a757f98796ca7348712", size = 66194, upload-time = "2024-12-24T18:30:14.886Z" }, + { url = "https://files.pythonhosted.org/packages/e1/83/4b73975f149819eb7dcf9299ed467eba068ecb16439a98990dcb12e63fdd/kiwisolver-1.4.8-cp313-cp313t-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:7506488470f41169b86d8c9aeff587293f530a23a23a49d6bc64dab66bedc71e", size = 1465942, upload-time = "2024-12-24T18:30:18.927Z" }, + { url = "https://files.pythonhosted.org/packages/c7/2c/30a5cdde5102958e602c07466bce058b9d7cb48734aa7a4327261ac8e002/kiwisolver-1.4.8-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2f0121b07b356a22fb0414cec4666bbe36fd6d0d759db3d37228f496ed67c880", size = 1595341, upload-time = "2024-12-24T18:30:22.102Z" }, + { url = "https://files.pythonhosted.org/packages/ff/9b/1e71db1c000385aa069704f5990574b8244cce854ecd83119c19e83c9586/kiwisolver-1.4.8-cp313-cp313t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d6d6bd87df62c27d4185de7c511c6248040afae67028a8a22012b010bc7ad062", size = 1598455, upload-time = "2024-12-24T18:30:24.947Z" }, + { url = "https://files.pythonhosted.org/packages/85/92/c8fec52ddf06231b31cbb779af77e99b8253cd96bd135250b9498144c78b/kiwisolver-1.4.8-cp313-cp313t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:291331973c64bb9cce50bbe871fb2e675c4331dab4f31abe89f175ad7679a4d7", size = 1522138, upload-time = "2024-12-24T18:30:26.286Z" }, + { url = "https://files.pythonhosted.org/packages/0b/51/9eb7e2cd07a15d8bdd976f6190c0164f92ce1904e5c0c79198c4972926b7/kiwisolver-1.4.8-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:893f5525bb92d3d735878ec00f781b2de998333659507d29ea4466208df37bed", size = 1582857, upload-time = "2024-12-24T18:30:28.86Z" }, + { url = "https://files.pythonhosted.org/packages/0f/95/c5a00387a5405e68ba32cc64af65ce881a39b98d73cc394b24143bebc5b8/kiwisolver-1.4.8-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:b47a465040146981dc9db8647981b8cb96366fbc8d452b031e4f8fdffec3f26d", size = 2293129, upload-time = "2024-12-24T18:30:30.34Z" }, + { url = "https://files.pythonhosted.org/packages/44/83/eeb7af7d706b8347548313fa3a3a15931f404533cc54fe01f39e830dd231/kiwisolver-1.4.8-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:99cea8b9dd34ff80c521aef46a1dddb0dcc0283cf18bde6d756f1e6f31772165", size = 2421538, upload-time = "2024-12-24T18:30:33.334Z" }, + { url = "https://files.pythonhosted.org/packages/05/f9/27e94c1b3eb29e6933b6986ffc5fa1177d2cd1f0c8efc5f02c91c9ac61de/kiwisolver-1.4.8-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:151dffc4865e5fe6dafce5480fab84f950d14566c480c08a53c663a0020504b6", size = 2390661, upload-time = "2024-12-24T18:30:34.939Z" }, + { url = "https://files.pythonhosted.org/packages/d9/d4/3c9735faa36ac591a4afcc2980d2691000506050b7a7e80bcfe44048daa7/kiwisolver-1.4.8-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:577facaa411c10421314598b50413aa1ebcf5126f704f1e5d72d7e4e9f020d90", size = 2546710, upload-time = "2024-12-24T18:30:37.281Z" }, + { url = "https://files.pythonhosted.org/packages/4c/fa/be89a49c640930180657482a74970cdcf6f7072c8d2471e1babe17a222dc/kiwisolver-1.4.8-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:be4816dc51c8a471749d664161b434912eee82f2ea66bd7628bd14583a833e85", size = 2349213, upload-time = "2024-12-24T18:30:40.019Z" }, +] + +[[package]] +name = "markupsafe" +version = "3.0.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/b2/97/5d42485e71dfc078108a86d6de8fa46db44a1a9295e89c5d6d4a06e23a62/markupsafe-3.0.2.tar.gz", hash = "sha256:ee55d3edf80167e48ea11a923c7386f4669df67d7994554387f84e7d8b0a2bf0", size = 20537, upload-time = "2024-10-18T15:21:54.129Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/6b/28/bbf83e3f76936960b850435576dd5e67034e200469571be53f69174a2dfd/MarkupSafe-3.0.2-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:9025b4018f3a1314059769c7bf15441064b2207cb3f065e6ea1e7359cb46db9d", size = 14353, upload-time = "2024-10-18T15:21:02.187Z" }, + { url = "https://files.pythonhosted.org/packages/6c/30/316d194b093cde57d448a4c3209f22e3046c5bb2fb0820b118292b334be7/MarkupSafe-3.0.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:93335ca3812df2f366e80509ae119189886b0f3c2b81325d39efdb84a1e2ae93", size = 12392, upload-time = "2024-10-18T15:21:02.941Z" }, + { url = "https://files.pythonhosted.org/packages/f2/96/9cdafba8445d3a53cae530aaf83c38ec64c4d5427d975c974084af5bc5d2/MarkupSafe-3.0.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2cb8438c3cbb25e220c2ab33bb226559e7afb3baec11c4f218ffa7308603c832", size = 23984, upload-time = "2024-10-18T15:21:03.953Z" }, + { url = "https://files.pythonhosted.org/packages/f1/a4/aefb044a2cd8d7334c8a47d3fb2c9f328ac48cb349468cc31c20b539305f/MarkupSafe-3.0.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a123e330ef0853c6e822384873bef7507557d8e4a082961e1defa947aa59ba84", size = 23120, upload-time = "2024-10-18T15:21:06.495Z" }, + { url = "https://files.pythonhosted.org/packages/8d/21/5e4851379f88f3fad1de30361db501300d4f07bcad047d3cb0449fc51f8c/MarkupSafe-3.0.2-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1e084f686b92e5b83186b07e8a17fc09e38fff551f3602b249881fec658d3eca", size = 23032, upload-time = "2024-10-18T15:21:07.295Z" }, + { url = "https://files.pythonhosted.org/packages/00/7b/e92c64e079b2d0d7ddf69899c98842f3f9a60a1ae72657c89ce2655c999d/MarkupSafe-3.0.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:d8213e09c917a951de9d09ecee036d5c7d36cb6cb7dbaece4c71a60d79fb9798", size = 24057, upload-time = "2024-10-18T15:21:08.073Z" }, + { url = "https://files.pythonhosted.org/packages/f9/ac/46f960ca323037caa0a10662ef97d0a4728e890334fc156b9f9e52bcc4ca/MarkupSafe-3.0.2-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:5b02fb34468b6aaa40dfc198d813a641e3a63b98c2b05a16b9f80b7ec314185e", size = 23359, upload-time = "2024-10-18T15:21:09.318Z" }, + { url = "https://files.pythonhosted.org/packages/69/84/83439e16197337b8b14b6a5b9c2105fff81d42c2a7c5b58ac7b62ee2c3b1/MarkupSafe-3.0.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:0bff5e0ae4ef2e1ae4fdf2dfd5b76c75e5c2fa4132d05fc1b0dabcd20c7e28c4", size = 23306, upload-time = "2024-10-18T15:21:10.185Z" }, + { url = "https://files.pythonhosted.org/packages/9a/34/a15aa69f01e2181ed8d2b685c0d2f6655d5cca2c4db0ddea775e631918cd/MarkupSafe-3.0.2-cp311-cp311-win32.whl", hash = "sha256:6c89876f41da747c8d3677a2b540fb32ef5715f97b66eeb0c6b66f5e3ef6f59d", size = 15094, upload-time = "2024-10-18T15:21:11.005Z" }, + { url = "https://files.pythonhosted.org/packages/da/b8/3a3bd761922d416f3dc5d00bfbed11f66b1ab89a0c2b6e887240a30b0f6b/MarkupSafe-3.0.2-cp311-cp311-win_amd64.whl", hash = "sha256:70a87b411535ccad5ef2f1df5136506a10775d267e197e4cf531ced10537bd6b", size = 15521, upload-time = "2024-10-18T15:21:12.911Z" }, + { url = "https://files.pythonhosted.org/packages/22/09/d1f21434c97fc42f09d290cbb6350d44eb12f09cc62c9476effdb33a18aa/MarkupSafe-3.0.2-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:9778bd8ab0a994ebf6f84c2b949e65736d5575320a17ae8984a77fab08db94cf", size = 14274, upload-time = "2024-10-18T15:21:13.777Z" }, + { url = "https://files.pythonhosted.org/packages/6b/b0/18f76bba336fa5aecf79d45dcd6c806c280ec44538b3c13671d49099fdd0/MarkupSafe-3.0.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:846ade7b71e3536c4e56b386c2a47adf5741d2d8b94ec9dc3e92e5e1ee1e2225", size = 12348, upload-time = "2024-10-18T15:21:14.822Z" }, + { url = "https://files.pythonhosted.org/packages/e0/25/dd5c0f6ac1311e9b40f4af06c78efde0f3b5cbf02502f8ef9501294c425b/MarkupSafe-3.0.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1c99d261bd2d5f6b59325c92c73df481e05e57f19837bdca8413b9eac4bd8028", size = 24149, upload-time = "2024-10-18T15:21:15.642Z" }, + { url = "https://files.pythonhosted.org/packages/f3/f0/89e7aadfb3749d0f52234a0c8c7867877876e0a20b60e2188e9850794c17/MarkupSafe-3.0.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e17c96c14e19278594aa4841ec148115f9c7615a47382ecb6b82bd8fea3ab0c8", size = 23118, upload-time = "2024-10-18T15:21:17.133Z" }, + { url = "https://files.pythonhosted.org/packages/d5/da/f2eeb64c723f5e3777bc081da884b414671982008c47dcc1873d81f625b6/MarkupSafe-3.0.2-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:88416bd1e65dcea10bc7569faacb2c20ce071dd1f87539ca2ab364bf6231393c", size = 22993, upload-time = "2024-10-18T15:21:18.064Z" }, + { url = "https://files.pythonhosted.org/packages/da/0e/1f32af846df486dce7c227fe0f2398dc7e2e51d4a370508281f3c1c5cddc/MarkupSafe-3.0.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:2181e67807fc2fa785d0592dc2d6206c019b9502410671cc905d132a92866557", size = 24178, upload-time = "2024-10-18T15:21:18.859Z" }, + { url = "https://files.pythonhosted.org/packages/c4/f6/bb3ca0532de8086cbff5f06d137064c8410d10779c4c127e0e47d17c0b71/MarkupSafe-3.0.2-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:52305740fe773d09cffb16f8ed0427942901f00adedac82ec8b67752f58a1b22", size = 23319, upload-time = "2024-10-18T15:21:19.671Z" }, + { url = "https://files.pythonhosted.org/packages/a2/82/8be4c96ffee03c5b4a034e60a31294daf481e12c7c43ab8e34a1453ee48b/MarkupSafe-3.0.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:ad10d3ded218f1039f11a75f8091880239651b52e9bb592ca27de44eed242a48", size = 23352, upload-time = "2024-10-18T15:21:20.971Z" }, + { url = "https://files.pythonhosted.org/packages/51/ae/97827349d3fcffee7e184bdf7f41cd6b88d9919c80f0263ba7acd1bbcb18/MarkupSafe-3.0.2-cp312-cp312-win32.whl", hash = "sha256:0f4ca02bea9a23221c0182836703cbf8930c5e9454bacce27e767509fa286a30", size = 15097, upload-time = "2024-10-18T15:21:22.646Z" }, + { url = "https://files.pythonhosted.org/packages/c1/80/a61f99dc3a936413c3ee4e1eecac96c0da5ed07ad56fd975f1a9da5bc630/MarkupSafe-3.0.2-cp312-cp312-win_amd64.whl", hash = "sha256:8e06879fc22a25ca47312fbe7c8264eb0b662f6db27cb2d3bbbc74b1df4b9b87", size = 15601, upload-time = "2024-10-18T15:21:23.499Z" }, + { url = "https://files.pythonhosted.org/packages/83/0e/67eb10a7ecc77a0c2bbe2b0235765b98d164d81600746914bebada795e97/MarkupSafe-3.0.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:ba9527cdd4c926ed0760bc301f6728ef34d841f405abf9d4f959c478421e4efd", size = 14274, upload-time = "2024-10-18T15:21:24.577Z" }, + { url = "https://files.pythonhosted.org/packages/2b/6d/9409f3684d3335375d04e5f05744dfe7e9f120062c9857df4ab490a1031a/MarkupSafe-3.0.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:f8b3d067f2e40fe93e1ccdd6b2e1d16c43140e76f02fb1319a05cf2b79d99430", size = 12352, upload-time = "2024-10-18T15:21:25.382Z" }, + { url = "https://files.pythonhosted.org/packages/d2/f5/6eadfcd3885ea85fe2a7c128315cc1bb7241e1987443d78c8fe712d03091/MarkupSafe-3.0.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:569511d3b58c8791ab4c2e1285575265991e6d8f8700c7be0e88f86cb0672094", size = 24122, upload-time = "2024-10-18T15:21:26.199Z" }, + { url = "https://files.pythonhosted.org/packages/0c/91/96cf928db8236f1bfab6ce15ad070dfdd02ed88261c2afafd4b43575e9e9/MarkupSafe-3.0.2-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:15ab75ef81add55874e7ab7055e9c397312385bd9ced94920f2802310c930396", size = 23085, upload-time = "2024-10-18T15:21:27.029Z" }, + { url = "https://files.pythonhosted.org/packages/c2/cf/c9d56af24d56ea04daae7ac0940232d31d5a8354f2b457c6d856b2057d69/MarkupSafe-3.0.2-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f3818cb119498c0678015754eba762e0d61e5b52d34c8b13d770f0719f7b1d79", size = 22978, upload-time = "2024-10-18T15:21:27.846Z" }, + { url = "https://files.pythonhosted.org/packages/2a/9f/8619835cd6a711d6272d62abb78c033bda638fdc54c4e7f4272cf1c0962b/MarkupSafe-3.0.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:cdb82a876c47801bb54a690c5ae105a46b392ac6099881cdfb9f6e95e4014c6a", size = 24208, upload-time = "2024-10-18T15:21:28.744Z" }, + { url = "https://files.pythonhosted.org/packages/f9/bf/176950a1792b2cd2102b8ffeb5133e1ed984547b75db47c25a67d3359f77/MarkupSafe-3.0.2-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:cabc348d87e913db6ab4aa100f01b08f481097838bdddf7c7a84b7575b7309ca", size = 23357, upload-time = "2024-10-18T15:21:29.545Z" }, + { url = "https://files.pythonhosted.org/packages/ce/4f/9a02c1d335caabe5c4efb90e1b6e8ee944aa245c1aaaab8e8a618987d816/MarkupSafe-3.0.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:444dcda765c8a838eaae23112db52f1efaf750daddb2d9ca300bcae1039adc5c", size = 23344, upload-time = "2024-10-18T15:21:30.366Z" }, + { url = "https://files.pythonhosted.org/packages/ee/55/c271b57db36f748f0e04a759ace9f8f759ccf22b4960c270c78a394f58be/MarkupSafe-3.0.2-cp313-cp313-win32.whl", hash = "sha256:bcf3e58998965654fdaff38e58584d8937aa3096ab5354d493c77d1fdd66d7a1", size = 15101, upload-time = "2024-10-18T15:21:31.207Z" }, + { url = "https://files.pythonhosted.org/packages/29/88/07df22d2dd4df40aba9f3e402e6dc1b8ee86297dddbad4872bd5e7b0094f/MarkupSafe-3.0.2-cp313-cp313-win_amd64.whl", hash = "sha256:e6a2a455bd412959b57a172ce6328d2dd1f01cb2135efda2e4576e8a23fa3b0f", size = 15603, upload-time = "2024-10-18T15:21:32.032Z" }, + { url = "https://files.pythonhosted.org/packages/62/6a/8b89d24db2d32d433dffcd6a8779159da109842434f1dd2f6e71f32f738c/MarkupSafe-3.0.2-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:b5a6b3ada725cea8a5e634536b1b01c30bcdcd7f9c6fff4151548d5bf6b3a36c", size = 14510, upload-time = "2024-10-18T15:21:33.625Z" }, + { url = "https://files.pythonhosted.org/packages/7a/06/a10f955f70a2e5a9bf78d11a161029d278eeacbd35ef806c3fd17b13060d/MarkupSafe-3.0.2-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:a904af0a6162c73e3edcb969eeeb53a63ceeb5d8cf642fade7d39e7963a22ddb", size = 12486, upload-time = "2024-10-18T15:21:34.611Z" }, + { url = "https://files.pythonhosted.org/packages/34/cf/65d4a571869a1a9078198ca28f39fba5fbb910f952f9dbc5220afff9f5e6/MarkupSafe-3.0.2-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4aa4e5faecf353ed117801a068ebab7b7e09ffb6e1d5e412dc852e0da018126c", size = 25480, upload-time = "2024-10-18T15:21:35.398Z" }, + { url = "https://files.pythonhosted.org/packages/0c/e3/90e9651924c430b885468b56b3d597cabf6d72be4b24a0acd1fa0e12af67/MarkupSafe-3.0.2-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c0ef13eaeee5b615fb07c9a7dadb38eac06a0608b41570d8ade51c56539e509d", size = 23914, upload-time = "2024-10-18T15:21:36.231Z" }, + { url = "https://files.pythonhosted.org/packages/66/8c/6c7cf61f95d63bb866db39085150df1f2a5bd3335298f14a66b48e92659c/MarkupSafe-3.0.2-cp313-cp313t-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:d16a81a06776313e817c951135cf7340a3e91e8c1ff2fac444cfd75fffa04afe", size = 23796, upload-time = "2024-10-18T15:21:37.073Z" }, + { url = "https://files.pythonhosted.org/packages/bb/35/cbe9238ec3f47ac9a7c8b3df7a808e7cb50fe149dc7039f5f454b3fba218/MarkupSafe-3.0.2-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:6381026f158fdb7c72a168278597a5e3a5222e83ea18f543112b2662a9b699c5", size = 25473, upload-time = "2024-10-18T15:21:37.932Z" }, + { url = "https://files.pythonhosted.org/packages/e6/32/7621a4382488aa283cc05e8984a9c219abad3bca087be9ec77e89939ded9/MarkupSafe-3.0.2-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:3d79d162e7be8f996986c064d1c7c817f6df3a77fe3d6859f6f9e7be4b8c213a", size = 24114, upload-time = "2024-10-18T15:21:39.799Z" }, + { url = "https://files.pythonhosted.org/packages/0d/80/0985960e4b89922cb5a0bac0ed39c5b96cbc1a536a99f30e8c220a996ed9/MarkupSafe-3.0.2-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:131a3c7689c85f5ad20f9f6fb1b866f402c445b220c19fe4308c0b147ccd2ad9", size = 24098, upload-time = "2024-10-18T15:21:40.813Z" }, + { url = "https://files.pythonhosted.org/packages/82/78/fedb03c7d5380df2427038ec8d973587e90561b2d90cd472ce9254cf348b/MarkupSafe-3.0.2-cp313-cp313t-win32.whl", hash = "sha256:ba8062ed2cf21c07a9e295d5b8a2a5ce678b913b45fdf68c32d95d6c1291e0b6", size = 15208, upload-time = "2024-10-18T15:21:41.814Z" }, + { url = "https://files.pythonhosted.org/packages/4f/65/6079a46068dfceaeabb5dcad6d674f5f5c61a6fa5673746f42a9f4c233b3/MarkupSafe-3.0.2-cp313-cp313t-win_amd64.whl", hash = "sha256:e444a31f8db13eb18ada366ab3cf45fd4b31e4db1236a4448f68778c1d1a5a2f", size = 15739, upload-time = "2024-10-18T15:21:42.784Z" }, +] + +[[package]] +name = "matplotlib" +version = "3.10.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "contourpy" }, + { name = "cycler" }, + { name = "fonttools" }, + { name = "kiwisolver" }, + { name = "numpy" }, + { name = "packaging" }, + { name = "pillow" }, + { name = "pyparsing" }, + { name = "python-dateutil" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/68/dd/fa2e1a45fce2d09f4aea3cee169760e672c8262325aa5796c49d543dc7e6/matplotlib-3.10.0.tar.gz", hash = "sha256:b886d02a581b96704c9d1ffe55709e49b4d2d52709ccebc4be42db856e511278", size = 36686418, upload-time = "2024-12-14T06:32:51.547Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/0c/f1/e37f6c84d252867d7ddc418fff70fc661cfd363179263b08e52e8b748e30/matplotlib-3.10.0-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:fd44fc75522f58612ec4a33958a7e5552562b7705b42ef1b4f8c0818e304a363", size = 8171677, upload-time = "2024-12-14T06:31:03.742Z" }, + { url = "https://files.pythonhosted.org/packages/c7/8b/92e9da1f28310a1f6572b5c55097b0c0ceb5e27486d85fb73b54f5a9b939/matplotlib-3.10.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:c58a9622d5dbeb668f407f35f4e6bfac34bb9ecdcc81680c04d0258169747997", size = 8044945, upload-time = "2024-12-14T06:31:08.494Z" }, + { url = "https://files.pythonhosted.org/packages/c5/cb/49e83f0fd066937a5bd3bc5c5d63093703f3637b2824df8d856e0558beef/matplotlib-3.10.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:845d96568ec873be63f25fa80e9e7fae4be854a66a7e2f0c8ccc99e94a8bd4ef", size = 8458269, upload-time = "2024-12-14T06:31:11.346Z" }, + { url = "https://files.pythonhosted.org/packages/b2/7d/2d873209536b9ee17340754118a2a17988bc18981b5b56e6715ee07373ac/matplotlib-3.10.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5439f4c5a3e2e8eab18e2f8c3ef929772fd5641876db71f08127eed95ab64683", size = 8599369, upload-time = "2024-12-14T06:31:14.677Z" }, + { url = "https://files.pythonhosted.org/packages/b8/03/57d6cbbe85c61fe4cbb7c94b54dce443d68c21961830833a1f34d056e5ea/matplotlib-3.10.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:4673ff67a36152c48ddeaf1135e74ce0d4bce1bbf836ae40ed39c29edf7e2765", size = 9405992, upload-time = "2024-12-14T06:31:18.871Z" }, + { url = "https://files.pythonhosted.org/packages/14/cf/e382598f98be11bf51dd0bc60eca44a517f6793e3dc8b9d53634a144620c/matplotlib-3.10.0-cp311-cp311-win_amd64.whl", hash = "sha256:7e8632baebb058555ac0cde75db885c61f1212e47723d63921879806b40bec6a", size = 8034580, upload-time = "2024-12-14T06:31:21.998Z" }, + { url = "https://files.pythonhosted.org/packages/44/c7/6b2d8cb7cc251d53c976799cacd3200add56351c175ba89ab9cbd7c1e68a/matplotlib-3.10.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:4659665bc7c9b58f8c00317c3c2a299f7f258eeae5a5d56b4c64226fca2f7c59", size = 8172465, upload-time = "2024-12-14T06:31:24.727Z" }, + { url = "https://files.pythonhosted.org/packages/42/2a/6d66d0fba41e13e9ca6512a0a51170f43e7e7ed3a8dfa036324100775612/matplotlib-3.10.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:d44cb942af1693cced2604c33a9abcef6205601c445f6d0dc531d813af8a2f5a", size = 8043300, upload-time = "2024-12-14T06:31:28.55Z" }, + { url = "https://files.pythonhosted.org/packages/90/60/2a60342b27b90a16bada939a85e29589902b41073f59668b904b15ea666c/matplotlib-3.10.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a994f29e968ca002b50982b27168addfd65f0105610b6be7fa515ca4b5307c95", size = 8448936, upload-time = "2024-12-14T06:31:32.223Z" }, + { url = "https://files.pythonhosted.org/packages/a7/b2/d872fc3d753516870d520595ddd8ce4dd44fa797a240999f125f58521ad7/matplotlib-3.10.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9b0558bae37f154fffda54d779a592bc97ca8b4701f1c710055b609a3bac44c8", size = 8594151, upload-time = "2024-12-14T06:31:34.894Z" }, + { url = "https://files.pythonhosted.org/packages/f4/bd/b2f60cf7f57d014ab33e4f74602a2b5bdc657976db8196bbc022185f6f9c/matplotlib-3.10.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:503feb23bd8c8acc75541548a1d709c059b7184cde26314896e10a9f14df5f12", size = 9400347, upload-time = "2024-12-14T06:31:39.552Z" }, + { url = "https://files.pythonhosted.org/packages/9f/6e/264673e64001b99d747aff5a288eca82826c024437a3694e19aed1decf46/matplotlib-3.10.0-cp312-cp312-win_amd64.whl", hash = "sha256:c40ba2eb08b3f5de88152c2333c58cee7edcead0a2a0d60fcafa116b17117adc", size = 8039144, upload-time = "2024-12-14T06:31:44.128Z" }, + { url = "https://files.pythonhosted.org/packages/72/11/1b2a094d95dcb6e6edd4a0b238177c439006c6b7a9fe8d31801237bf512f/matplotlib-3.10.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:96f2886f5c1e466f21cc41b70c5a0cd47bfa0015eb2d5793c88ebce658600e25", size = 8173073, upload-time = "2024-12-14T06:31:46.592Z" }, + { url = "https://files.pythonhosted.org/packages/0d/c4/87b6ad2723070511a411ea719f9c70fde64605423b184face4e94986de9d/matplotlib-3.10.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:12eaf48463b472c3c0f8dbacdbf906e573013df81a0ab82f0616ea4b11281908", size = 8043892, upload-time = "2024-12-14T06:31:49.14Z" }, + { url = "https://files.pythonhosted.org/packages/57/69/cb0812a136550b21361335e9ffb7d459bf6d13e03cb7b015555d5143d2d6/matplotlib-3.10.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2fbbabc82fde51391c4da5006f965e36d86d95f6ee83fb594b279564a4c5d0d2", size = 8450532, upload-time = "2024-12-14T06:31:53.005Z" }, + { url = "https://files.pythonhosted.org/packages/ea/3a/bab9deb4fb199c05e9100f94d7f1c702f78d3241e6a71b784d2b88d7bebd/matplotlib-3.10.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ad2e15300530c1a94c63cfa546e3b7864bd18ea2901317bae8bbf06a5ade6dcf", size = 8593905, upload-time = "2024-12-14T06:31:59.022Z" }, + { url = "https://files.pythonhosted.org/packages/8b/66/742fd242f989adc1847ddf5f445815f73ad7c46aa3440690cc889cfa423c/matplotlib-3.10.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:3547d153d70233a8496859097ef0312212e2689cdf8d7ed764441c77604095ae", size = 9399609, upload-time = "2024-12-14T06:32:05.151Z" }, + { url = "https://files.pythonhosted.org/packages/fa/d6/54cee7142cef7d910a324a7aedf335c0c147b03658b54d49ec48166f10a6/matplotlib-3.10.0-cp313-cp313-win_amd64.whl", hash = "sha256:c55b20591ced744aa04e8c3e4b7543ea4d650b6c3c4b208c08a05b4010e8b442", size = 8039076, upload-time = "2024-12-14T06:32:08.38Z" }, + { url = "https://files.pythonhosted.org/packages/43/14/815d072dc36e88753433bfd0385113405efb947e6895ff7b4d2e8614a33b/matplotlib-3.10.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:9ade1003376731a971e398cc4ef38bb83ee8caf0aee46ac6daa4b0506db1fd06", size = 8211000, upload-time = "2024-12-14T06:32:12.383Z" }, + { url = "https://files.pythonhosted.org/packages/9a/76/34e75f364194ec352678adcb540964be6f35ec7d3d8c75ebcb17e6839359/matplotlib-3.10.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:95b710fea129c76d30be72c3b38f330269363fbc6e570a5dd43580487380b5ff", size = 8087707, upload-time = "2024-12-14T06:32:15.773Z" }, + { url = "https://files.pythonhosted.org/packages/c3/2b/b6bc0dff6a72d333bc7df94a66e6ce662d224e43daa8ad8ae4eaa9a77f55/matplotlib-3.10.0-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5cdbaf909887373c3e094b0318d7ff230b2ad9dcb64da7ade654182872ab2593", size = 8477384, upload-time = "2024-12-14T06:32:20.311Z" }, + { url = "https://files.pythonhosted.org/packages/c2/2d/b5949fb2b76e9b47ab05e25a5f5f887c70de20d8b0cbc704a4e2ee71c786/matplotlib-3.10.0-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d907fddb39f923d011875452ff1eca29a9e7f21722b873e90db32e5d8ddff12e", size = 8610334, upload-time = "2024-12-14T06:32:25.779Z" }, + { url = "https://files.pythonhosted.org/packages/d6/9a/6e3c799d5134d9af44b01c787e1360bee38cf51850506ea2e743a787700b/matplotlib-3.10.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:3b427392354d10975c1d0f4ee18aa5844640b512d5311ef32efd4dd7db106ede", size = 9406777, upload-time = "2024-12-14T06:32:28.919Z" }, + { url = "https://files.pythonhosted.org/packages/0e/dd/e6ae97151e5ed648ab2ea48885bc33d39202b640eec7a2910e2c843f7ac0/matplotlib-3.10.0-cp313-cp313t-win_amd64.whl", hash = "sha256:5fd41b0ec7ee45cd960a8e71aea7c946a28a0b8a4dcee47d2856b2af051f334c", size = 8109742, upload-time = "2024-12-14T06:32:32.115Z" }, +] + +[[package]] +name = "matplotlib-inline" +version = "0.1.7" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/99/5b/a36a337438a14116b16480db471ad061c36c3694df7c2084a0da7ba538b7/matplotlib_inline-0.1.7.tar.gz", hash = "sha256:8423b23ec666be3d16e16b60bdd8ac4e86e840ebd1dd11a30b9f117f2fa0ab90", size = 8159, upload-time = "2024-04-15T13:44:44.803Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/8f/8e/9ad090d3553c280a8060fbf6e24dc1c0c29704ee7d1c372f0c174aa59285/matplotlib_inline-0.1.7-py3-none-any.whl", hash = "sha256:df192d39a4ff8f21b1895d72e6a13f5fcc5099f00fa84384e0ea28c2cc0653ca", size = 9899, upload-time = "2024-04-15T13:44:43.265Z" }, +] + +[[package]] +name = "nest-asyncio" +version = "1.6.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/83/f8/51569ac65d696c8ecbee95938f89d4abf00f47d58d48f6fbabfe8f0baefe/nest_asyncio-1.6.0.tar.gz", hash = "sha256:6f172d5449aca15afd6c646851f4e31e02c598d553a667e38cafa997cfec55fe", size = 7418, upload-time = "2024-01-21T14:25:19.227Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a0/c4/c2971a3ba4c6103a3d10c4b0f24f461ddc027f0f09763220cf35ca1401b3/nest_asyncio-1.6.0-py3-none-any.whl", hash = "sha256:87af6efd6b5e897c81050477ef65c62e2b2f35d51703cae01aff2905b1852e1c", size = 5195, upload-time = "2024-01-21T14:25:17.223Z" }, +] + +[[package]] +name = "numpy" +version = "2.2.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/ec/d0/c12ddfd3a02274be06ffc71f3efc6d0e457b0409c4481596881e748cb264/numpy-2.2.2.tar.gz", hash = "sha256:ed6906f61834d687738d25988ae117683705636936cc605be0bb208b23df4d8f", size = 20233295, upload-time = "2025-01-19T00:02:09.581Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/21/67/32c68756eed84df181c06528ff57e09138f893c4653448c4967311e0f992/numpy-2.2.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:642199e98af1bd2b6aeb8ecf726972d238c9877b0f6e8221ee5ab945ec8a2189", size = 21220002, upload-time = "2025-01-18T23:00:41.728Z" }, + { url = "https://files.pythonhosted.org/packages/3b/89/f43bcad18f2b2e5814457b1c7f7b0e671d0db12c8c0e43397ab8cb1831ed/numpy-2.2.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:6d9fc9d812c81e6168b6d405bf00b8d6739a7f72ef22a9214c4241e0dc70b323", size = 14391215, upload-time = "2025-01-18T23:01:15.534Z" }, + { url = "https://files.pythonhosted.org/packages/9c/e6/efb8cd6122bf25e86e3dd89d9dbfec9e6861c50e8810eed77d4be59b51c6/numpy-2.2.2-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:c7d1fd447e33ee20c1f33f2c8e6634211124a9aabde3c617687d8b739aa69eac", size = 5391918, upload-time = "2025-01-18T23:01:35.138Z" }, + { url = "https://files.pythonhosted.org/packages/47/e2/fccf89d64d9b47ffb242823d4e851fc9d36fa751908c9aac2807924d9b4e/numpy-2.2.2-cp311-cp311-macosx_14_0_x86_64.whl", hash = "sha256:451e854cfae0febe723077bd0cf0a4302a5d84ff25f0bfece8f29206c7bed02e", size = 6933133, upload-time = "2025-01-18T23:01:53.087Z" }, + { url = "https://files.pythonhosted.org/packages/34/22/5ece749c0e5420a9380eef6fbf83d16a50010bd18fef77b9193d80a6760e/numpy-2.2.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:bd249bc894af67cbd8bad2c22e7cbcd46cf87ddfca1f1289d1e7e54868cc785c", size = 14338187, upload-time = "2025-01-18T23:02:29.11Z" }, + { url = "https://files.pythonhosted.org/packages/5b/86/caec78829311f62afa6fa334c8dfcd79cffb4d24bcf96ee02ae4840d462b/numpy-2.2.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:02935e2c3c0c6cbe9c7955a8efa8908dd4221d7755644c59d1bba28b94fd334f", size = 16393429, upload-time = "2025-01-18T23:03:00.683Z" }, + { url = "https://files.pythonhosted.org/packages/c8/4e/0c25f74c88239a37924577d6ad780f3212a50f4b4b5f54f5e8c918d726bd/numpy-2.2.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:a972cec723e0563aa0823ee2ab1df0cb196ed0778f173b381c871a03719d4826", size = 15559103, upload-time = "2025-01-18T23:03:44.838Z" }, + { url = "https://files.pythonhosted.org/packages/d4/bd/d557f10fa50dc4d5871fb9606af563249b66af2fc6f99041a10e8757c6f1/numpy-2.2.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:d6d6a0910c3b4368d89dde073e630882cdb266755565155bc33520283b2d9df8", size = 18182967, upload-time = "2025-01-18T23:22:14.371Z" }, + { url = "https://files.pythonhosted.org/packages/30/e9/66cc0f66386d78ed89e45a56e2a1d051e177b6e04477c4a41cd590ef4017/numpy-2.2.2-cp311-cp311-win32.whl", hash = "sha256:860fd59990c37c3ef913c3ae390b3929d005243acca1a86facb0773e2d8d9e50", size = 6571499, upload-time = "2025-01-18T23:22:28.118Z" }, + { url = "https://files.pythonhosted.org/packages/66/a3/4139296b481ae7304a43581046b8f0a20da6a0dfe0ee47a044cade796603/numpy-2.2.2-cp311-cp311-win_amd64.whl", hash = "sha256:da1eeb460ecce8d5b8608826595c777728cdf28ce7b5a5a8c8ac8d949beadcf2", size = 12919805, upload-time = "2025-01-18T23:22:56.851Z" }, + { url = "https://files.pythonhosted.org/packages/0c/e6/847d15770ab7a01e807bdfcd4ead5bdae57c0092b7dc83878171b6af97bb/numpy-2.2.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:ac9bea18d6d58a995fac1b2cb4488e17eceeac413af014b1dd26170b766d8467", size = 20912636, upload-time = "2025-01-18T23:23:58.337Z" }, + { url = "https://files.pythonhosted.org/packages/d1/af/f83580891577b13bd7e261416120e036d0d8fb508c8a43a73e38928b794b/numpy-2.2.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:23ae9f0c2d889b7b2d88a3791f6c09e2ef827c2446f1c4a3e3e76328ee4afd9a", size = 14098403, upload-time = "2025-01-18T23:25:26.896Z" }, + { url = "https://files.pythonhosted.org/packages/2b/86/d019fb60a9d0f1d4cf04b014fe88a9135090adfadcc31c1fadbb071d7fa7/numpy-2.2.2-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:3074634ea4d6df66be04f6728ee1d173cfded75d002c75fac79503a880bf3825", size = 5128938, upload-time = "2025-01-18T23:25:37.21Z" }, + { url = "https://files.pythonhosted.org/packages/7a/1b/50985edb6f1ec495a1c36452e860476f5b7ecdc3fc59ea89ccad3c4926c5/numpy-2.2.2-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:8ec0636d3f7d68520afc6ac2dc4b8341ddb725039de042faf0e311599f54eb37", size = 6661937, upload-time = "2025-01-18T23:26:05.86Z" }, + { url = "https://files.pythonhosted.org/packages/f4/1b/17efd94cad1b9d605c3f8907fb06bcffc4ce4d1d14d46b95316cccccf2b9/numpy-2.2.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2ffbb1acd69fdf8e89dd60ef6182ca90a743620957afb7066385a7bbe88dc748", size = 14049518, upload-time = "2025-01-18T23:26:33.364Z" }, + { url = "https://files.pythonhosted.org/packages/5b/73/65d2f0b698df1731e851e3295eb29a5ab8aa06f763f7e4188647a809578d/numpy-2.2.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0349b025e15ea9d05c3d63f9657707a4e1d471128a3b1d876c095f328f8ff7f0", size = 16099146, upload-time = "2025-01-18T23:27:15.132Z" }, + { url = "https://files.pythonhosted.org/packages/d5/69/308f55c0e19d4b5057b5df286c5433822e3c8039ede06d4051d96f1c2c4e/numpy-2.2.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:463247edcee4a5537841d5350bc87fe8e92d7dd0e8c71c995d2c6eecb8208278", size = 15246336, upload-time = "2025-01-18T23:28:09.658Z" }, + { url = "https://files.pythonhosted.org/packages/f0/d8/d8d333ad0d8518d077a21aeea7b7c826eff766a2b1ce1194dea95ca0bacf/numpy-2.2.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:9dd47ff0cb2a656ad69c38da850df3454da88ee9a6fde0ba79acceee0e79daba", size = 17863507, upload-time = "2025-01-18T23:28:56.146Z" }, + { url = "https://files.pythonhosted.org/packages/82/6e/0b84ad3103ffc16d6673e63b5acbe7901b2af96c2837174c6318c98e27ab/numpy-2.2.2-cp312-cp312-win32.whl", hash = "sha256:4525b88c11906d5ab1b0ec1f290996c0020dd318af8b49acaa46f198b1ffc283", size = 6276491, upload-time = "2025-01-18T23:29:09.409Z" }, + { url = "https://files.pythonhosted.org/packages/fc/84/7f801a42a67b9772a883223a0a1e12069a14626c81a732bd70aac57aebc1/numpy-2.2.2-cp312-cp312-win_amd64.whl", hash = "sha256:5acea83b801e98541619af398cc0109ff48016955cc0818f478ee9ef1c5c3dcb", size = 12616372, upload-time = "2025-01-18T23:29:46.645Z" }, + { url = "https://files.pythonhosted.org/packages/e1/fe/df5624001f4f5c3e0b78e9017bfab7fdc18a8d3b3d3161da3d64924dd659/numpy-2.2.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:b208cfd4f5fe34e1535c08983a1a6803fdbc7a1e86cf13dd0c61de0b51a0aadc", size = 20899188, upload-time = "2025-01-18T23:31:15.292Z" }, + { url = "https://files.pythonhosted.org/packages/a9/80/d349c3b5ed66bd3cb0214be60c27e32b90a506946857b866838adbe84040/numpy-2.2.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:d0bbe7dd86dca64854f4b6ce2ea5c60b51e36dfd597300057cf473d3615f2369", size = 14113972, upload-time = "2025-01-18T23:31:42.323Z" }, + { url = "https://files.pythonhosted.org/packages/9d/50/949ec9cbb28c4b751edfa64503f0913cbfa8d795b4a251e7980f13a8a655/numpy-2.2.2-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:22ea3bb552ade325530e72a0c557cdf2dea8914d3a5e1fecf58fa5dbcc6f43cd", size = 5114294, upload-time = "2025-01-18T23:31:54.219Z" }, + { url = "https://files.pythonhosted.org/packages/8d/f3/399c15629d5a0c68ef2aa7621d430b2be22034f01dd7f3c65a9c9666c445/numpy-2.2.2-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:128c41c085cab8a85dc29e66ed88c05613dccf6bc28b3866cd16050a2f5448be", size = 6648426, upload-time = "2025-01-18T23:32:06.055Z" }, + { url = "https://files.pythonhosted.org/packages/2c/03/c72474c13772e30e1bc2e558cdffd9123c7872b731263d5648b5c49dd459/numpy-2.2.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:250c16b277e3b809ac20d1f590716597481061b514223c7badb7a0f9993c7f84", size = 14045990, upload-time = "2025-01-18T23:32:38.031Z" }, + { url = "https://files.pythonhosted.org/packages/83/9c/96a9ab62274ffafb023f8ee08c88d3d31ee74ca58869f859db6845494fa6/numpy-2.2.2-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e0c8854b09bc4de7b041148d8550d3bd712b5c21ff6a8ed308085f190235d7ff", size = 16096614, upload-time = "2025-01-18T23:33:12.265Z" }, + { url = "https://files.pythonhosted.org/packages/d5/34/cd0a735534c29bec7093544b3a509febc9b0df77718a9b41ffb0809c9f46/numpy-2.2.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:b6fb9c32a91ec32a689ec6410def76443e3c750e7cfc3fb2206b985ffb2b85f0", size = 15242123, upload-time = "2025-01-18T23:33:46.412Z" }, + { url = "https://files.pythonhosted.org/packages/5e/6d/541717a554a8f56fa75e91886d9b79ade2e595918690eb5d0d3dbd3accb9/numpy-2.2.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:57b4012e04cc12b78590a334907e01b3a85efb2107df2b8733ff1ed05fce71de", size = 17859160, upload-time = "2025-01-18T23:34:37.857Z" }, + { url = "https://files.pythonhosted.org/packages/b9/a5/fbf1f2b54adab31510728edd06a05c1b30839f37cf8c9747cb85831aaf1b/numpy-2.2.2-cp313-cp313-win32.whl", hash = "sha256:4dbd80e453bd34bd003b16bd802fac70ad76bd463f81f0c518d1245b1c55e3d9", size = 6273337, upload-time = "2025-01-18T23:40:10.83Z" }, + { url = "https://files.pythonhosted.org/packages/56/e5/01106b9291ef1d680f82bc47d0c5b5e26dfed15b0754928e8f856c82c881/numpy-2.2.2-cp313-cp313-win_amd64.whl", hash = "sha256:5a8c863ceacae696aff37d1fd636121f1a512117652e5dfb86031c8d84836369", size = 12609010, upload-time = "2025-01-18T23:40:31.34Z" }, + { url = "https://files.pythonhosted.org/packages/9f/30/f23d9876de0f08dceb707c4dcf7f8dd7588266745029debb12a3cdd40be6/numpy-2.2.2-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:b3482cb7b3325faa5f6bc179649406058253d91ceda359c104dac0ad320e1391", size = 20924451, upload-time = "2025-01-18T23:35:26.639Z" }, + { url = "https://files.pythonhosted.org/packages/6a/ec/6ea85b2da9d5dfa1dbb4cb3c76587fc8ddcae580cb1262303ab21c0926c4/numpy-2.2.2-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:9491100aba630910489c1d0158034e1c9a6546f0b1340f716d522dc103788e39", size = 14122390, upload-time = "2025-01-18T23:36:30.596Z" }, + { url = "https://files.pythonhosted.org/packages/68/05/bfbdf490414a7dbaf65b10c78bc243f312c4553234b6d91c94eb7c4b53c2/numpy-2.2.2-cp313-cp313t-macosx_14_0_arm64.whl", hash = "sha256:41184c416143defa34cc8eb9d070b0a5ba4f13a0fa96a709e20584638254b317", size = 5156590, upload-time = "2025-01-18T23:36:52.637Z" }, + { url = "https://files.pythonhosted.org/packages/f7/ec/fe2e91b2642b9d6544518388a441bcd65c904cea38d9ff998e2e8ebf808e/numpy-2.2.2-cp313-cp313t-macosx_14_0_x86_64.whl", hash = "sha256:7dca87ca328f5ea7dafc907c5ec100d187911f94825f8700caac0b3f4c384b49", size = 6671958, upload-time = "2025-01-18T23:37:05.361Z" }, + { url = "https://files.pythonhosted.org/packages/b1/6f/6531a78e182f194d33ee17e59d67d03d0d5a1ce7f6be7343787828d1bd4a/numpy-2.2.2-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0bc61b307655d1a7f9f4b043628b9f2b721e80839914ede634e3d485913e1fb2", size = 14019950, upload-time = "2025-01-18T23:37:38.605Z" }, + { url = "https://files.pythonhosted.org/packages/e1/fb/13c58591d0b6294a08cc40fcc6b9552d239d773d520858ae27f39997f2ae/numpy-2.2.2-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9fad446ad0bc886855ddf5909cbf8cb5d0faa637aaa6277fb4b19ade134ab3c7", size = 16079759, upload-time = "2025-01-18T23:38:05.757Z" }, + { url = "https://files.pythonhosted.org/packages/2c/f2/f2f8edd62abb4b289f65a7f6d1f3650273af00b91b7267a2431be7f1aec6/numpy-2.2.2-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:149d1113ac15005652e8d0d3f6fd599360e1a708a4f98e43c9c77834a28238cb", size = 15226139, upload-time = "2025-01-18T23:38:38.458Z" }, + { url = "https://files.pythonhosted.org/packages/aa/29/14a177f1a90b8ad8a592ca32124ac06af5eff32889874e53a308f850290f/numpy-2.2.2-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:106397dbbb1896f99e044efc90360d098b3335060375c26aa89c0d8a97c5f648", size = 17856316, upload-time = "2025-01-18T23:39:11.454Z" }, + { url = "https://files.pythonhosted.org/packages/95/03/242ae8d7b97f4e0e4ab8dd51231465fb23ed5e802680d629149722e3faf1/numpy-2.2.2-cp313-cp313t-win32.whl", hash = "sha256:0eec19f8af947a61e968d5429f0bd92fec46d92b0008d0a6685b40d6adf8a4f4", size = 6329134, upload-time = "2025-01-18T23:39:28.128Z" }, + { url = "https://files.pythonhosted.org/packages/80/94/cd9e9b04012c015cb6320ab3bf43bc615e248dddfeb163728e800a5d96f0/numpy-2.2.2-cp313-cp313t-win_amd64.whl", hash = "sha256:97b974d3ba0fb4612b77ed35d7627490e8e3dff56ab41454d9e8b23448940576", size = 12696208, upload-time = "2025-01-18T23:39:51.85Z" }, +] + +[[package]] +name = "packaging" +version = "24.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/d0/63/68dbb6eb2de9cb10ee4c9c14a0148804425e13c4fb20d61cce69f53106da/packaging-24.2.tar.gz", hash = "sha256:c228a6dc5e932d346bc5739379109d49e8853dd8223571c7c5b55260edc0b97f", size = 163950, upload-time = "2024-11-08T09:47:47.202Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/88/ef/eb23f262cca3c0c4eb7ab1933c3b1f03d021f2c48f54763065b6f0e321be/packaging-24.2-py3-none-any.whl", hash = "sha256:09abb1bccd265c01f4a3aa3f7a7db064b36514d2cba19a2f694fe6150451a759", size = 65451, upload-time = "2024-11-08T09:47:44.722Z" }, +] + +[[package]] +name = "pandas" +version = "2.2.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "numpy" }, + { name = "python-dateutil" }, + { name = "pytz" }, + { name = "tzdata" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/9c/d6/9f8431bacc2e19dca897724cd097b1bb224a6ad5433784a44b587c7c13af/pandas-2.2.3.tar.gz", hash = "sha256:4f18ba62b61d7e192368b84517265a99b4d7ee8912f8708660fb4a366cc82667", size = 4399213, upload-time = "2024-09-20T13:10:04.827Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a8/44/d9502bf0ed197ba9bf1103c9867d5904ddcaf869e52329787fc54ed70cc8/pandas-2.2.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:66108071e1b935240e74525006034333f98bcdb87ea116de573a6a0dccb6c039", size = 12602222, upload-time = "2024-09-20T13:08:56.254Z" }, + { url = "https://files.pythonhosted.org/packages/52/11/9eac327a38834f162b8250aab32a6781339c69afe7574368fffe46387edf/pandas-2.2.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:7c2875855b0ff77b2a64a0365e24455d9990730d6431b9e0ee18ad8acee13dbd", size = 11321274, upload-time = "2024-09-20T13:08:58.645Z" }, + { url = "https://files.pythonhosted.org/packages/45/fb/c4beeb084718598ba19aa9f5abbc8aed8b42f90930da861fcb1acdb54c3a/pandas-2.2.3-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:cd8d0c3be0515c12fed0bdbae072551c8b54b7192c7b1fda0ba56059a0179698", size = 15579836, upload-time = "2024-09-20T19:01:57.571Z" }, + { url = "https://files.pythonhosted.org/packages/cd/5f/4dba1d39bb9c38d574a9a22548c540177f78ea47b32f99c0ff2ec499fac5/pandas-2.2.3-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c124333816c3a9b03fbeef3a9f230ba9a737e9e5bb4060aa2107a86cc0a497fc", size = 13058505, upload-time = "2024-09-20T13:09:01.501Z" }, + { url = "https://files.pythonhosted.org/packages/b9/57/708135b90391995361636634df1f1130d03ba456e95bcf576fada459115a/pandas-2.2.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:63cc132e40a2e084cf01adf0775b15ac515ba905d7dcca47e9a251819c575ef3", size = 16744420, upload-time = "2024-09-20T19:02:00.678Z" }, + { url = "https://files.pythonhosted.org/packages/86/4a/03ed6b7ee323cf30404265c284cee9c65c56a212e0a08d9ee06984ba2240/pandas-2.2.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:29401dbfa9ad77319367d36940cd8a0b3a11aba16063e39632d98b0e931ddf32", size = 14440457, upload-time = "2024-09-20T13:09:04.105Z" }, + { url = "https://files.pythonhosted.org/packages/ed/8c/87ddf1fcb55d11f9f847e3c69bb1c6f8e46e2f40ab1a2d2abadb2401b007/pandas-2.2.3-cp311-cp311-win_amd64.whl", hash = "sha256:3fc6873a41186404dad67245896a6e440baacc92f5b716ccd1bc9ed2995ab2c5", size = 11617166, upload-time = "2024-09-20T13:09:06.917Z" }, + { url = "https://files.pythonhosted.org/packages/17/a3/fb2734118db0af37ea7433f57f722c0a56687e14b14690edff0cdb4b7e58/pandas-2.2.3-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:b1d432e8d08679a40e2a6d8b2f9770a5c21793a6f9f47fdd52c5ce1948a5a8a9", size = 12529893, upload-time = "2024-09-20T13:09:09.655Z" }, + { url = "https://files.pythonhosted.org/packages/e1/0c/ad295fd74bfac85358fd579e271cded3ac969de81f62dd0142c426b9da91/pandas-2.2.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:a5a1595fe639f5988ba6a8e5bc9649af3baf26df3998a0abe56c02609392e0a4", size = 11363475, upload-time = "2024-09-20T13:09:14.718Z" }, + { url = "https://files.pythonhosted.org/packages/c6/2a/4bba3f03f7d07207481fed47f5b35f556c7441acddc368ec43d6643c5777/pandas-2.2.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:5de54125a92bb4d1c051c0659e6fcb75256bf799a732a87184e5ea503965bce3", size = 15188645, upload-time = "2024-09-20T19:02:03.88Z" }, + { url = "https://files.pythonhosted.org/packages/38/f8/d8fddee9ed0d0c0f4a2132c1dfcf0e3e53265055da8df952a53e7eaf178c/pandas-2.2.3-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fffb8ae78d8af97f849404f21411c95062db1496aeb3e56f146f0355c9989319", size = 12739445, upload-time = "2024-09-20T13:09:17.621Z" }, + { url = "https://files.pythonhosted.org/packages/20/e8/45a05d9c39d2cea61ab175dbe6a2de1d05b679e8de2011da4ee190d7e748/pandas-2.2.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:6dfcb5ee8d4d50c06a51c2fffa6cff6272098ad6540aed1a76d15fb9318194d8", size = 16359235, upload-time = "2024-09-20T19:02:07.094Z" }, + { url = "https://files.pythonhosted.org/packages/1d/99/617d07a6a5e429ff90c90da64d428516605a1ec7d7bea494235e1c3882de/pandas-2.2.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:062309c1b9ea12a50e8ce661145c6aab431b1e99530d3cd60640e255778bd43a", size = 14056756, upload-time = "2024-09-20T13:09:20.474Z" }, + { url = "https://files.pythonhosted.org/packages/29/d4/1244ab8edf173a10fd601f7e13b9566c1b525c4f365d6bee918e68381889/pandas-2.2.3-cp312-cp312-win_amd64.whl", hash = "sha256:59ef3764d0fe818125a5097d2ae867ca3fa64df032331b7e0917cf5d7bf66b13", size = 11504248, upload-time = "2024-09-20T13:09:23.137Z" }, + { url = "https://files.pythonhosted.org/packages/64/22/3b8f4e0ed70644e85cfdcd57454686b9057c6c38d2f74fe4b8bc2527214a/pandas-2.2.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:f00d1345d84d8c86a63e476bb4955e46458b304b9575dcf71102b5c705320015", size = 12477643, upload-time = "2024-09-20T13:09:25.522Z" }, + { url = "https://files.pythonhosted.org/packages/e4/93/b3f5d1838500e22c8d793625da672f3eec046b1a99257666c94446969282/pandas-2.2.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:3508d914817e153ad359d7e069d752cdd736a247c322d932eb89e6bc84217f28", size = 11281573, upload-time = "2024-09-20T13:09:28.012Z" }, + { url = "https://files.pythonhosted.org/packages/f5/94/6c79b07f0e5aab1dcfa35a75f4817f5c4f677931d4234afcd75f0e6a66ca/pandas-2.2.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:22a9d949bfc9a502d320aa04e5d02feab689d61da4e7764b62c30b991c42c5f0", size = 15196085, upload-time = "2024-09-20T19:02:10.451Z" }, + { url = "https://files.pythonhosted.org/packages/e8/31/aa8da88ca0eadbabd0a639788a6da13bb2ff6edbbb9f29aa786450a30a91/pandas-2.2.3-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f3a255b2c19987fbbe62a9dfd6cff7ff2aa9ccab3fc75218fd4b7530f01efa24", size = 12711809, upload-time = "2024-09-20T13:09:30.814Z" }, + { url = "https://files.pythonhosted.org/packages/ee/7c/c6dbdb0cb2a4344cacfb8de1c5808ca885b2e4dcfde8008266608f9372af/pandas-2.2.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:800250ecdadb6d9c78eae4990da62743b857b470883fa27f652db8bdde7f6659", size = 16356316, upload-time = "2024-09-20T19:02:13.825Z" }, + { url = "https://files.pythonhosted.org/packages/57/b7/8b757e7d92023b832869fa8881a992696a0bfe2e26f72c9ae9f255988d42/pandas-2.2.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:6374c452ff3ec675a8f46fd9ab25c4ad0ba590b71cf0656f8b6daa5202bca3fb", size = 14022055, upload-time = "2024-09-20T13:09:33.462Z" }, + { url = "https://files.pythonhosted.org/packages/3b/bc/4b18e2b8c002572c5a441a64826252ce5da2aa738855747247a971988043/pandas-2.2.3-cp313-cp313-win_amd64.whl", hash = "sha256:61c5ad4043f791b61dd4752191d9f07f0ae412515d59ba8f005832a532f8736d", size = 11481175, upload-time = "2024-09-20T13:09:35.871Z" }, + { url = "https://files.pythonhosted.org/packages/76/a3/a5d88146815e972d40d19247b2c162e88213ef51c7c25993942c39dbf41d/pandas-2.2.3-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:3b71f27954685ee685317063bf13c7709a7ba74fc996b84fc6821c59b0f06468", size = 12615650, upload-time = "2024-09-20T13:09:38.685Z" }, + { url = "https://files.pythonhosted.org/packages/9c/8c/f0fd18f6140ddafc0c24122c8a964e48294acc579d47def376fef12bcb4a/pandas-2.2.3-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:38cf8125c40dae9d5acc10fa66af8ea6fdf760b2714ee482ca691fc66e6fcb18", size = 11290177, upload-time = "2024-09-20T13:09:41.141Z" }, + { url = "https://files.pythonhosted.org/packages/ed/f9/e995754eab9c0f14c6777401f7eece0943840b7a9fc932221c19d1abee9f/pandas-2.2.3-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:ba96630bc17c875161df3818780af30e43be9b166ce51c9a18c1feae342906c2", size = 14651526, upload-time = "2024-09-20T19:02:16.905Z" }, + { url = "https://files.pythonhosted.org/packages/25/b0/98d6ae2e1abac4f35230aa756005e8654649d305df9a28b16b9ae4353bff/pandas-2.2.3-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1db71525a1538b30142094edb9adc10be3f3e176748cd7acc2240c2f2e5aa3a4", size = 11871013, upload-time = "2024-09-20T13:09:44.39Z" }, + { url = "https://files.pythonhosted.org/packages/cc/57/0f72a10f9db6a4628744c8e8f0df4e6e21de01212c7c981d31e50ffc8328/pandas-2.2.3-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:15c0e1e02e93116177d29ff83e8b1619c93ddc9c49083f237d4312337a61165d", size = 15711620, upload-time = "2024-09-20T19:02:20.639Z" }, + { url = "https://files.pythonhosted.org/packages/ab/5f/b38085618b950b79d2d9164a711c52b10aefc0ae6833b96f626b7021b2ed/pandas-2.2.3-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:ad5b65698ab28ed8d7f18790a0dc58005c7629f227be9ecc1072aa74c0c1d43a", size = 13098436, upload-time = "2024-09-20T13:09:48.112Z" }, +] + +[[package]] +name = "parso" +version = "0.8.4" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/66/94/68e2e17afaa9169cf6412ab0f28623903be73d1b32e208d9e8e541bb086d/parso-0.8.4.tar.gz", hash = "sha256:eb3a7b58240fb99099a345571deecc0f9540ea5f4dd2fe14c2a99d6b281ab92d", size = 400609, upload-time = "2024-04-05T09:43:55.897Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c6/ac/dac4a63f978e4dcb3c6d3a78c4d8e0192a113d288502a1216950c41b1027/parso-0.8.4-py2.py3-none-any.whl", hash = "sha256:a418670a20291dacd2dddc80c377c5c3791378ee1e8d12bffc35420643d43f18", size = 103650, upload-time = "2024-04-05T09:43:53.299Z" }, +] + +[[package]] +name = "pexpect" +version = "4.9.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "ptyprocess" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/42/92/cc564bf6381ff43ce1f4d06852fc19a2f11d180f23dc32d9588bee2f149d/pexpect-4.9.0.tar.gz", hash = "sha256:ee7d41123f3c9911050ea2c2dac107568dc43b2d3b0c7557a33212c398ead30f", size = 166450, upload-time = "2023-11-25T09:07:26.339Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9e/c3/059298687310d527a58bb01f3b1965787ee3b40dce76752eda8b44e9a2c5/pexpect-4.9.0-py2.py3-none-any.whl", hash = "sha256:7236d1e080e4936be2dc3e326cec0af72acf9212a7e1d060210e70a47e253523", size = 63772, upload-time = "2023-11-25T06:56:14.81Z" }, +] + +[[package]] +name = "pillow" +version = "11.1.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f3/af/c097e544e7bd278333db77933e535098c259609c4eb3b85381109602fb5b/pillow-11.1.0.tar.gz", hash = "sha256:368da70808b36d73b4b390a8ffac11069f8a5c85f29eff1f1b01bcf3ef5b2a20", size = 46742715, upload-time = "2025-01-02T08:13:58.407Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/dd/d6/2000bfd8d5414fb70cbbe52c8332f2283ff30ed66a9cde42716c8ecbe22c/pillow-11.1.0-cp311-cp311-macosx_10_10_x86_64.whl", hash = "sha256:e06695e0326d05b06833b40b7ef477e475d0b1ba3a6d27da1bb48c23209bf457", size = 3229968, upload-time = "2025-01-02T08:10:48.172Z" }, + { url = "https://files.pythonhosted.org/packages/d9/45/3fe487010dd9ce0a06adf9b8ff4f273cc0a44536e234b0fad3532a42c15b/pillow-11.1.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:96f82000e12f23e4f29346e42702b6ed9a2f2fea34a740dd5ffffcc8c539eb35", size = 3101806, upload-time = "2025-01-02T08:10:50.981Z" }, + { url = "https://files.pythonhosted.org/packages/e3/72/776b3629c47d9d5f1c160113158a7a7ad177688d3a1159cd3b62ded5a33a/pillow-11.1.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a3cd561ded2cf2bbae44d4605837221b987c216cff94f49dfeed63488bb228d2", size = 4322283, upload-time = "2025-01-02T08:10:54.724Z" }, + { url = "https://files.pythonhosted.org/packages/e4/c2/e25199e7e4e71d64eeb869f5b72c7ddec70e0a87926398785ab944d92375/pillow-11.1.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f189805c8be5ca5add39e6f899e6ce2ed824e65fb45f3c28cb2841911da19070", size = 4402945, upload-time = "2025-01-02T08:10:57.376Z" }, + { url = "https://files.pythonhosted.org/packages/c1/ed/51d6136c9d5911f78632b1b86c45241c712c5a80ed7fa7f9120a5dff1eba/pillow-11.1.0-cp311-cp311-manylinux_2_28_aarch64.whl", hash = "sha256:dd0052e9db3474df30433f83a71b9b23bd9e4ef1de13d92df21a52c0303b8ab6", size = 4361228, upload-time = "2025-01-02T08:11:02.374Z" }, + { url = "https://files.pythonhosted.org/packages/48/a4/fbfe9d5581d7b111b28f1d8c2762dee92e9821bb209af9fa83c940e507a0/pillow-11.1.0-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:837060a8599b8f5d402e97197d4924f05a2e0d68756998345c829c33186217b1", size = 4484021, upload-time = "2025-01-02T08:11:04.431Z" }, + { url = "https://files.pythonhosted.org/packages/39/db/0b3c1a5018117f3c1d4df671fb8e47d08937f27519e8614bbe86153b65a5/pillow-11.1.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:aa8dd43daa836b9a8128dbe7d923423e5ad86f50a7a14dc688194b7be5c0dea2", size = 4287449, upload-time = "2025-01-02T08:11:07.412Z" }, + { url = "https://files.pythonhosted.org/packages/d9/58/bc128da7fea8c89fc85e09f773c4901e95b5936000e6f303222490c052f3/pillow-11.1.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:0a2f91f8a8b367e7a57c6e91cd25af510168091fb89ec5146003e424e1558a96", size = 4419972, upload-time = "2025-01-02T08:11:09.508Z" }, + { url = "https://files.pythonhosted.org/packages/5f/bb/58f34379bde9fe197f51841c5bbe8830c28bbb6d3801f16a83b8f2ad37df/pillow-11.1.0-cp311-cp311-win32.whl", hash = "sha256:c12fc111ef090845de2bb15009372175d76ac99969bdf31e2ce9b42e4b8cd88f", size = 2291201, upload-time = "2025-01-02T08:11:13.056Z" }, + { url = "https://files.pythonhosted.org/packages/3a/c6/fce9255272bcf0c39e15abd2f8fd8429a954cf344469eaceb9d0d1366913/pillow-11.1.0-cp311-cp311-win_amd64.whl", hash = "sha256:fbd43429d0d7ed6533b25fc993861b8fd512c42d04514a0dd6337fb3ccf22761", size = 2625686, upload-time = "2025-01-02T08:11:16.547Z" }, + { url = "https://files.pythonhosted.org/packages/c8/52/8ba066d569d932365509054859f74f2a9abee273edcef5cd75e4bc3e831e/pillow-11.1.0-cp311-cp311-win_arm64.whl", hash = "sha256:f7955ecf5609dee9442cbface754f2c6e541d9e6eda87fad7f7a989b0bdb9d71", size = 2375194, upload-time = "2025-01-02T08:11:19.897Z" }, + { url = "https://files.pythonhosted.org/packages/95/20/9ce6ed62c91c073fcaa23d216e68289e19d95fb8188b9fb7a63d36771db8/pillow-11.1.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:2062ffb1d36544d42fcaa277b069c88b01bb7298f4efa06731a7fd6cc290b81a", size = 3226818, upload-time = "2025-01-02T08:11:22.518Z" }, + { url = "https://files.pythonhosted.org/packages/b9/d8/f6004d98579a2596c098d1e30d10b248798cceff82d2b77aa914875bfea1/pillow-11.1.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:a85b653980faad27e88b141348707ceeef8a1186f75ecc600c395dcac19f385b", size = 3101662, upload-time = "2025-01-02T08:11:25.19Z" }, + { url = "https://files.pythonhosted.org/packages/08/d9/892e705f90051c7a2574d9f24579c9e100c828700d78a63239676f960b74/pillow-11.1.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9409c080586d1f683df3f184f20e36fb647f2e0bc3988094d4fd8c9f4eb1b3b3", size = 4329317, upload-time = "2025-01-02T08:11:30.371Z" }, + { url = "https://files.pythonhosted.org/packages/8c/aa/7f29711f26680eab0bcd3ecdd6d23ed6bce180d82e3f6380fb7ae35fcf3b/pillow-11.1.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7fdadc077553621911f27ce206ffcbec7d3f8d7b50e0da39f10997e8e2bb7f6a", size = 4412999, upload-time = "2025-01-02T08:11:33.499Z" }, + { url = "https://files.pythonhosted.org/packages/c8/c4/8f0fe3b9e0f7196f6d0bbb151f9fba323d72a41da068610c4c960b16632a/pillow-11.1.0-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:93a18841d09bcdd774dcdc308e4537e1f867b3dec059c131fde0327899734aa1", size = 4368819, upload-time = "2025-01-02T08:11:37.304Z" }, + { url = "https://files.pythonhosted.org/packages/38/0d/84200ed6a871ce386ddc82904bfadc0c6b28b0c0ec78176871a4679e40b3/pillow-11.1.0-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:9aa9aeddeed452b2f616ff5507459e7bab436916ccb10961c4a382cd3e03f47f", size = 4496081, upload-time = "2025-01-02T08:11:39.598Z" }, + { url = "https://files.pythonhosted.org/packages/84/9c/9bcd66f714d7e25b64118e3952d52841a4babc6d97b6d28e2261c52045d4/pillow-11.1.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:3cdcdb0b896e981678eee140d882b70092dac83ac1cdf6b3a60e2216a73f2b91", size = 4296513, upload-time = "2025-01-02T08:11:43.083Z" }, + { url = "https://files.pythonhosted.org/packages/db/61/ada2a226e22da011b45f7104c95ebda1b63dcbb0c378ad0f7c2a710f8fd2/pillow-11.1.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:36ba10b9cb413e7c7dfa3e189aba252deee0602c86c309799da5a74009ac7a1c", size = 4431298, upload-time = "2025-01-02T08:11:46.626Z" }, + { url = "https://files.pythonhosted.org/packages/e7/c4/fc6e86750523f367923522014b821c11ebc5ad402e659d8c9d09b3c9d70c/pillow-11.1.0-cp312-cp312-win32.whl", hash = "sha256:cfd5cd998c2e36a862d0e27b2df63237e67273f2fc78f47445b14e73a810e7e6", size = 2291630, upload-time = "2025-01-02T08:11:49.401Z" }, + { url = "https://files.pythonhosted.org/packages/08/5c/2104299949b9d504baf3f4d35f73dbd14ef31bbd1ddc2c1b66a5b7dfda44/pillow-11.1.0-cp312-cp312-win_amd64.whl", hash = "sha256:a697cd8ba0383bba3d2d3ada02b34ed268cb548b369943cd349007730c92bddf", size = 2626369, upload-time = "2025-01-02T08:11:52.02Z" }, + { url = "https://files.pythonhosted.org/packages/37/f3/9b18362206b244167c958984b57c7f70a0289bfb59a530dd8af5f699b910/pillow-11.1.0-cp312-cp312-win_arm64.whl", hash = "sha256:4dd43a78897793f60766563969442020e90eb7847463eca901e41ba186a7d4a5", size = 2375240, upload-time = "2025-01-02T08:11:56.193Z" }, + { url = "https://files.pythonhosted.org/packages/b3/31/9ca79cafdce364fd5c980cd3416c20ce1bebd235b470d262f9d24d810184/pillow-11.1.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:ae98e14432d458fc3de11a77ccb3ae65ddce70f730e7c76140653048c71bfcbc", size = 3226640, upload-time = "2025-01-02T08:11:58.329Z" }, + { url = "https://files.pythonhosted.org/packages/ac/0f/ff07ad45a1f172a497aa393b13a9d81a32e1477ef0e869d030e3c1532521/pillow-11.1.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:cc1331b6d5a6e144aeb5e626f4375f5b7ae9934ba620c0ac6b3e43d5e683a0f0", size = 3101437, upload-time = "2025-01-02T08:12:01.797Z" }, + { url = "https://files.pythonhosted.org/packages/08/2f/9906fca87a68d29ec4530be1f893149e0cb64a86d1f9f70a7cfcdfe8ae44/pillow-11.1.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:758e9d4ef15d3560214cddbc97b8ef3ef86ce04d62ddac17ad39ba87e89bd3b1", size = 4326605, upload-time = "2025-01-02T08:12:05.224Z" }, + { url = "https://files.pythonhosted.org/packages/b0/0f/f3547ee15b145bc5c8b336401b2d4c9d9da67da9dcb572d7c0d4103d2c69/pillow-11.1.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b523466b1a31d0dcef7c5be1f20b942919b62fd6e9a9be199d035509cbefc0ec", size = 4411173, upload-time = "2025-01-02T08:12:08.281Z" }, + { url = "https://files.pythonhosted.org/packages/b1/df/bf8176aa5db515c5de584c5e00df9bab0713548fd780c82a86cba2c2fedb/pillow-11.1.0-cp313-cp313-manylinux_2_28_aarch64.whl", hash = "sha256:9044b5e4f7083f209c4e35aa5dd54b1dd5b112b108648f5c902ad586d4f945c5", size = 4369145, upload-time = "2025-01-02T08:12:11.411Z" }, + { url = "https://files.pythonhosted.org/packages/de/7c/7433122d1cfadc740f577cb55526fdc39129a648ac65ce64db2eb7209277/pillow-11.1.0-cp313-cp313-manylinux_2_28_x86_64.whl", hash = "sha256:3764d53e09cdedd91bee65c2527815d315c6b90d7b8b79759cc48d7bf5d4f114", size = 4496340, upload-time = "2025-01-02T08:12:15.29Z" }, + { url = "https://files.pythonhosted.org/packages/25/46/dd94b93ca6bd555588835f2504bd90c00d5438fe131cf01cfa0c5131a19d/pillow-11.1.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:31eba6bbdd27dde97b0174ddf0297d7a9c3a507a8a1480e1e60ef914fe23d352", size = 4296906, upload-time = "2025-01-02T08:12:17.485Z" }, + { url = "https://files.pythonhosted.org/packages/a8/28/2f9d32014dfc7753e586db9add35b8a41b7a3b46540e965cb6d6bc607bd2/pillow-11.1.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:b5d658fbd9f0d6eea113aea286b21d3cd4d3fd978157cbf2447a6035916506d3", size = 4431759, upload-time = "2025-01-02T08:12:20.382Z" }, + { url = "https://files.pythonhosted.org/packages/33/48/19c2cbe7403870fbe8b7737d19eb013f46299cdfe4501573367f6396c775/pillow-11.1.0-cp313-cp313-win32.whl", hash = "sha256:f86d3a7a9af5d826744fabf4afd15b9dfef44fe69a98541f666f66fbb8d3fef9", size = 2291657, upload-time = "2025-01-02T08:12:23.922Z" }, + { url = "https://files.pythonhosted.org/packages/3b/ad/285c556747d34c399f332ba7c1a595ba245796ef3e22eae190f5364bb62b/pillow-11.1.0-cp313-cp313-win_amd64.whl", hash = "sha256:593c5fd6be85da83656b93ffcccc2312d2d149d251e98588b14fbc288fd8909c", size = 2626304, upload-time = "2025-01-02T08:12:28.069Z" }, + { url = "https://files.pythonhosted.org/packages/e5/7b/ef35a71163bf36db06e9c8729608f78dedf032fc8313d19bd4be5c2588f3/pillow-11.1.0-cp313-cp313-win_arm64.whl", hash = "sha256:11633d58b6ee5733bde153a8dafd25e505ea3d32e261accd388827ee987baf65", size = 2375117, upload-time = "2025-01-02T08:12:30.064Z" }, + { url = "https://files.pythonhosted.org/packages/79/30/77f54228401e84d6791354888549b45824ab0ffde659bafa67956303a09f/pillow-11.1.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:70ca5ef3b3b1c4a0812b5c63c57c23b63e53bc38e758b37a951e5bc466449861", size = 3230060, upload-time = "2025-01-02T08:12:32.362Z" }, + { url = "https://files.pythonhosted.org/packages/ce/b1/56723b74b07dd64c1010fee011951ea9c35a43d8020acd03111f14298225/pillow-11.1.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:8000376f139d4d38d6851eb149b321a52bb8893a88dae8ee7d95840431977081", size = 3106192, upload-time = "2025-01-02T08:12:34.361Z" }, + { url = "https://files.pythonhosted.org/packages/e1/cd/7bf7180e08f80a4dcc6b4c3a0aa9e0b0ae57168562726a05dc8aa8fa66b0/pillow-11.1.0-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9ee85f0696a17dd28fbcfceb59f9510aa71934b483d1f5601d1030c3c8304f3c", size = 4446805, upload-time = "2025-01-02T08:12:36.99Z" }, + { url = "https://files.pythonhosted.org/packages/97/42/87c856ea30c8ed97e8efbe672b58c8304dee0573f8c7cab62ae9e31db6ae/pillow-11.1.0-cp313-cp313t-manylinux_2_28_x86_64.whl", hash = "sha256:dd0e081319328928531df7a0e63621caf67652c8464303fd102141b785ef9547", size = 4530623, upload-time = "2025-01-02T08:12:41.912Z" }, + { url = "https://files.pythonhosted.org/packages/ff/41/026879e90c84a88e33fb00cc6bd915ac2743c67e87a18f80270dfe3c2041/pillow-11.1.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:e63e4e5081de46517099dc30abe418122f54531a6ae2ebc8680bcd7096860eab", size = 4465191, upload-time = "2025-01-02T08:12:45.186Z" }, + { url = "https://files.pythonhosted.org/packages/e5/fb/a7960e838bc5df57a2ce23183bfd2290d97c33028b96bde332a9057834d3/pillow-11.1.0-cp313-cp313t-win32.whl", hash = "sha256:dda60aa465b861324e65a78c9f5cf0f4bc713e4309f83bc387be158b077963d9", size = 2295494, upload-time = "2025-01-02T08:12:47.098Z" }, + { url = "https://files.pythonhosted.org/packages/d7/6c/6ec83ee2f6f0fda8d4cf89045c6be4b0373ebfc363ba8538f8c999f63fcd/pillow-11.1.0-cp313-cp313t-win_amd64.whl", hash = "sha256:ad5db5781c774ab9a9b2c4302bbf0c1014960a0a7be63278d13ae6fdf88126fe", size = 2631595, upload-time = "2025-01-02T08:12:50.47Z" }, + { url = "https://files.pythonhosted.org/packages/cf/6c/41c21c6c8af92b9fea313aa47c75de49e2f9a467964ee33eb0135d47eb64/pillow-11.1.0-cp313-cp313t-win_arm64.whl", hash = "sha256:67cd427c68926108778a9005f2a04adbd5e67c442ed21d95389fe1d595458756", size = 2377651, upload-time = "2025-01-02T08:12:53.356Z" }, +] + +[[package]] +name = "platformdirs" +version = "4.3.6" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/13/fc/128cc9cb8f03208bdbf93d3aa862e16d376844a14f9a0ce5cf4507372de4/platformdirs-4.3.6.tar.gz", hash = "sha256:357fb2acbc885b0419afd3ce3ed34564c13c9b95c89360cd9563f73aa5e2b907", size = 21302, upload-time = "2024-09-17T19:06:50.688Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/3c/a6/bc1012356d8ece4d66dd75c4b9fc6c1f6650ddd5991e421177d9f8f671be/platformdirs-4.3.6-py3-none-any.whl", hash = "sha256:73e575e1408ab8103900836b97580d5307456908a03e92031bab39e4554cc3fb", size = 18439, upload-time = "2024-09-17T19:06:49.212Z" }, +] + +[[package]] +name = "pluggy" +version = "1.5.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/96/2d/02d4312c973c6050a18b314a5ad0b3210edb65a906f868e31c111dede4a6/pluggy-1.5.0.tar.gz", hash = "sha256:2cffa88e94fdc978c4c574f15f9e59b7f4201d439195c3715ca9e2486f1d0cf1", size = 67955, upload-time = "2024-04-20T21:34:42.531Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/88/5f/e351af9a41f866ac3f1fac4ca0613908d9a41741cfcf2228f4ad853b697d/pluggy-1.5.0-py3-none-any.whl", hash = "sha256:44e1ad92c8ca002de6377e165f3e0f1be63266ab4d554740532335b9d75ea669", size = 20556, upload-time = "2024-04-20T21:34:40.434Z" }, +] + +[[package]] +name = "prompt-toolkit" +version = "3.0.50" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "wcwidth" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/a1/e1/bd15cb8ffdcfeeb2bdc215de3c3cffca11408d829e4b8416dcfe71ba8854/prompt_toolkit-3.0.50.tar.gz", hash = "sha256:544748f3860a2623ca5cd6d2795e7a14f3d0e1c3c9728359013f79877fc89bab", size = 429087, upload-time = "2025-01-20T15:55:35.072Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e4/ea/d836f008d33151c7a1f62caf3d8dd782e4d15f6a43897f64480c2b8de2ad/prompt_toolkit-3.0.50-py3-none-any.whl", hash = "sha256:9b6427eb19e479d98acff65196a307c555eb567989e6d88ebbb1b509d9779198", size = 387816, upload-time = "2025-01-20T15:55:29.98Z" }, +] + +[[package]] +name = "psutil" +version = "6.1.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/1f/5a/07871137bb752428aa4b659f910b399ba6f291156bdea939be3e96cae7cb/psutil-6.1.1.tar.gz", hash = "sha256:cf8496728c18f2d0b45198f06895be52f36611711746b7f30c464b422b50e2f5", size = 508502, upload-time = "2024-12-19T18:21:20.568Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/61/99/ca79d302be46f7bdd8321089762dd4476ee725fce16fc2b2e1dbba8cac17/psutil-6.1.1-cp36-abi3-macosx_10_9_x86_64.whl", hash = "sha256:fc0ed7fe2231a444fc219b9c42d0376e0a9a1a72f16c5cfa0f68d19f1a0663e8", size = 247511, upload-time = "2024-12-19T18:21:45.163Z" }, + { url = "https://files.pythonhosted.org/packages/0b/6b/73dbde0dd38f3782905d4587049b9be64d76671042fdcaf60e2430c6796d/psutil-6.1.1-cp36-abi3-macosx_11_0_arm64.whl", hash = "sha256:0bdd4eab935276290ad3cb718e9809412895ca6b5b334f5a9111ee6d9aff9377", size = 248985, upload-time = "2024-12-19T18:21:49.254Z" }, + { url = "https://files.pythonhosted.org/packages/17/38/c319d31a1d3f88c5b79c68b3116c129e5133f1822157dd6da34043e32ed6/psutil-6.1.1-cp36-abi3-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b6e06c20c05fe95a3d7302d74e7097756d4ba1247975ad6905441ae1b5b66003", size = 284488, upload-time = "2024-12-19T18:21:51.638Z" }, + { url = "https://files.pythonhosted.org/packages/9c/39/0f88a830a1c8a3aba27fededc642da37613c57cbff143412e3536f89784f/psutil-6.1.1-cp36-abi3-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:97f7cb9921fbec4904f522d972f0c0e1f4fabbdd4e0287813b21215074a0f160", size = 287477, upload-time = "2024-12-19T18:21:55.306Z" }, + { url = "https://files.pythonhosted.org/packages/47/da/99f4345d4ddf2845cb5b5bd0d93d554e84542d116934fde07a0c50bd4e9f/psutil-6.1.1-cp36-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:33431e84fee02bc84ea36d9e2c4a6d395d479c9dd9bba2376c1f6ee8f3a4e0b3", size = 289017, upload-time = "2024-12-19T18:21:57.875Z" }, + { url = "https://files.pythonhosted.org/packages/38/53/bd755c2896f4461fd4f36fa6a6dcb66a88a9e4b9fd4e5b66a77cf9d4a584/psutil-6.1.1-cp37-abi3-win32.whl", hash = "sha256:eaa912e0b11848c4d9279a93d7e2783df352b082f40111e078388701fd479e53", size = 250602, upload-time = "2024-12-19T18:22:08.808Z" }, + { url = "https://files.pythonhosted.org/packages/7b/d7/7831438e6c3ebbfa6e01a927127a6cb42ad3ab844247f3c5b96bea25d73d/psutil-6.1.1-cp37-abi3-win_amd64.whl", hash = "sha256:f35cfccb065fff93529d2afb4a2e89e363fe63ca1e4a5da22b603a85833c2649", size = 254444, upload-time = "2024-12-19T18:22:11.335Z" }, +] + +[[package]] +name = "ptyprocess" +version = "0.7.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/20/e5/16ff212c1e452235a90aeb09066144d0c5a6a8c0834397e03f5224495c4e/ptyprocess-0.7.0.tar.gz", hash = "sha256:5c5d0a3b48ceee0b48485e0c26037c0acd7d29765ca3fbb5cb3831d347423220", size = 70762, upload-time = "2020-12-28T15:15:30.155Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/22/a6/858897256d0deac81a172289110f31629fc4cee19b6f01283303e18c8db3/ptyprocess-0.7.0-py2.py3-none-any.whl", hash = "sha256:4b41f3967fce3af57cc7e94b888626c18bf37a083e3651ca8feeb66d492fef35", size = 13993, upload-time = "2020-12-28T15:15:28.35Z" }, +] + +[[package]] +name = "pure-eval" +version = "0.2.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/cd/05/0a34433a064256a578f1783a10da6df098ceaa4a57bbeaa96a6c0352786b/pure_eval-0.2.3.tar.gz", hash = "sha256:5f4e983f40564c576c7c8635ae88db5956bb2229d7e9237d03b3c0b0190eaf42", size = 19752, upload-time = "2024-07-21T12:58:21.801Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/8e/37/efad0257dc6e593a18957422533ff0f87ede7c9c6ea010a2177d738fb82f/pure_eval-0.2.3-py3-none-any.whl", hash = "sha256:1db8e35b67b3d218d818ae653e27f06c3aa420901fa7b081ca98cbedc874e0d0", size = 11842, upload-time = "2024-07-21T12:58:20.04Z" }, +] + +[[package]] +name = "pyannote-core" +source = { editable = "." } +dependencies = [ + { name = "numpy" }, + { name = "pandas" }, + { name = "sortedcontainers" }, +] + +[package.optional-dependencies] +doc = [ + { name = "ipython" }, + { name = "matplotlib" }, + { name = "sphinx" }, + { name = "sphinx-rtd-theme" }, +] +notebook = [ + { name = "ipython" }, + { name = "matplotlib" }, +] +test = [ + { name = "matplotlib" }, + { name = "pytest" }, + { name = "scipy", version = "1.17.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.12'" }, + { name = "scipy", version = "1.18.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.12'" }, +] + +[package.dev-dependencies] +dev = [ + { name = "ipykernel" }, +] + +[package.metadata] +requires-dist = [ + { name = "ipython", marker = "extra == 'doc'", specifier = ">=8.32.0" }, + { name = "ipython", marker = "extra == 'notebook'", specifier = ">=8.31.0" }, + { name = "matplotlib", marker = "extra == 'doc'", specifier = ">=3.10.0" }, + { name = "matplotlib", marker = "extra == 'notebook'", specifier = ">=3.10.0" }, + { name = "matplotlib", marker = "extra == 'test'", specifier = ">=3.10.0" }, + { name = "numpy", specifier = ">=2.0" }, + { name = "pandas", specifier = ">=2.2.3" }, + { name = "pytest", marker = "extra == 'test'", specifier = ">=8.3.4" }, + { name = "scipy", marker = "extra == 'test'", specifier = ">=1.15.1" }, + { name = "sortedcontainers", specifier = ">=2.4.0" }, + { name = "sphinx", marker = "extra == 'doc'", specifier = ">=8.1.3" }, + { name = "sphinx-rtd-theme", marker = "extra == 'doc'", specifier = ">=3.0.2" }, +] +provides-extras = ["doc", "notebook", "test"] + +[package.metadata.requires-dev] +dev = [{ name = "ipykernel", specifier = ">=6.29.5" }] + +[[package]] +name = "pycparser" +version = "2.22" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/1d/b2/31537cf4b1ca988837256c910a668b553fceb8f069bedc4b1c826024b52c/pycparser-2.22.tar.gz", hash = "sha256:491c8be9c040f5390f5bf44a5b07752bd07f56edf992381b05c701439eec10f6", size = 172736, upload-time = "2024-03-30T13:22:22.564Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/13/a3/a812df4e2dd5696d1f351d58b8fe16a405b234ad2886a0dab9183fb78109/pycparser-2.22-py3-none-any.whl", hash = "sha256:c3702b6d3dd8c7abc1afa565d7e63d53a1d0bd86cdc24edd75470f4de499cfcc", size = 117552, upload-time = "2024-03-30T13:22:20.476Z" }, +] + +[[package]] +name = "pygments" +version = "2.19.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/7c/2d/c3338d48ea6cc0feb8446d8e6937e1408088a72a39937982cc6111d17f84/pygments-2.19.1.tar.gz", hash = "sha256:61c16d2a8576dc0649d9f39e089b5f02bcd27fba10d8fb4dcc28173f7a45151f", size = 4968581, upload-time = "2025-01-06T17:26:30.443Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/8a/0b/9fcc47d19c48b59121088dd6da2488a49d5f72dacf8262e2790a1d2c7d15/pygments-2.19.1-py3-none-any.whl", hash = "sha256:9ea1544ad55cecf4b8242fab6dd35a93bbce657034b0611ee383099054ab6d8c", size = 1225293, upload-time = "2025-01-06T17:26:25.553Z" }, +] + +[[package]] +name = "pyparsing" +version = "3.2.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/8b/1a/3544f4f299a47911c2ab3710f534e52fea62a633c96806995da5d25be4b2/pyparsing-3.2.1.tar.gz", hash = "sha256:61980854fd66de3a90028d679a954d5f2623e83144b5afe5ee86f43d762e5f0a", size = 1067694, upload-time = "2024-12-31T20:59:46.157Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/1c/a7/c8a2d361bf89c0d9577c934ebb7421b25dc84bf3a8e3ac0a40aed9acc547/pyparsing-3.2.1-py3-none-any.whl", hash = "sha256:506ff4f4386c4cec0590ec19e6302d3aedb992fdc02c761e90416f158dacf8e1", size = 107716, upload-time = "2024-12-31T20:59:42.738Z" }, +] + +[[package]] +name = "pytest" +version = "8.3.4" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "colorama", marker = "sys_platform == 'win32'" }, + { name = "iniconfig" }, + { name = "packaging" }, + { name = "pluggy" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/05/35/30e0d83068951d90a01852cb1cef56e5d8a09d20c7f511634cc2f7e0372a/pytest-8.3.4.tar.gz", hash = "sha256:965370d062bce11e73868e0335abac31b4d3de0e82f4007408d242b4f8610761", size = 1445919, upload-time = "2024-12-01T12:54:25.98Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/11/92/76a1c94d3afee238333bc0a42b82935dd8f9cf8ce9e336ff87ee14d9e1cf/pytest-8.3.4-py3-none-any.whl", hash = "sha256:50e16d954148559c9a74109af1eaf0c945ba2d8f30f0a3d3335edde19788b6f6", size = 343083, upload-time = "2024-12-01T12:54:19.735Z" }, +] + +[[package]] +name = "python-dateutil" +version = "2.9.0.post0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "six" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/66/c0/0c8b6ad9f17a802ee498c46e004a0eb49bc148f2fd230864601a86dcf6db/python-dateutil-2.9.0.post0.tar.gz", hash = "sha256:37dd54208da7e1cd875388217d5e00ebd4179249f90fb72437e91a35459a0ad3", size = 342432, upload-time = "2024-03-01T18:36:20.211Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ec/57/56b9bcc3c9c6a792fcbaf139543cee77261f3651ca9da0c93f5c1221264b/python_dateutil-2.9.0.post0-py2.py3-none-any.whl", hash = "sha256:a8b2bc7bffae282281c8140a97d3aa9c14da0b136dfe83f850eea9a5f7470427", size = 229892, upload-time = "2024-03-01T18:36:18.57Z" }, +] + +[[package]] +name = "pytz" +version = "2025.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/5f/57/df1c9157c8d5a05117e455d66fd7cf6dbc46974f832b1058ed4856785d8a/pytz-2025.1.tar.gz", hash = "sha256:c2db42be2a2518b28e65f9207c4d05e6ff547d1efa4086469ef855e4ab70178e", size = 319617, upload-time = "2025-01-31T01:54:48.615Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/eb/38/ac33370d784287baa1c3d538978b5e2ea064d4c1b93ffbd12826c190dd10/pytz-2025.1-py2.py3-none-any.whl", hash = "sha256:89dd22dca55b46eac6eda23b2d72721bf1bdfef212645d81513ef5d03038de57", size = 507930, upload-time = "2025-01-31T01:54:45.634Z" }, +] + +[[package]] +name = "pywin32" +version = "308" +source = { registry = "https://pypi.org/simple" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/eb/e2/02652007469263fe1466e98439831d65d4ca80ea1a2df29abecedf7e47b7/pywin32-308-cp311-cp311-win32.whl", hash = "sha256:5d8c8015b24a7d6855b1550d8e660d8daa09983c80e5daf89a273e5c6fb5095a", size = 5928156, upload-time = "2024-10-12T20:42:05.78Z" }, + { url = "https://files.pythonhosted.org/packages/48/ef/f4fb45e2196bc7ffe09cad0542d9aff66b0e33f6c0954b43e49c33cad7bd/pywin32-308-cp311-cp311-win_amd64.whl", hash = "sha256:575621b90f0dc2695fec346b2d6302faebd4f0f45c05ea29404cefe35d89442b", size = 6559559, upload-time = "2024-10-12T20:42:07.644Z" }, + { url = "https://files.pythonhosted.org/packages/79/ef/68bb6aa865c5c9b11a35771329e95917b5559845bd75b65549407f9fc6b4/pywin32-308-cp311-cp311-win_arm64.whl", hash = "sha256:100a5442b7332070983c4cd03f2e906a5648a5104b8a7f50175f7906efd16bb6", size = 7972495, upload-time = "2024-10-12T20:42:09.803Z" }, + { url = "https://files.pythonhosted.org/packages/00/7c/d00d6bdd96de4344e06c4afbf218bc86b54436a94c01c71a8701f613aa56/pywin32-308-cp312-cp312-win32.whl", hash = "sha256:587f3e19696f4bf96fde9d8a57cec74a57021ad5f204c9e627e15c33ff568897", size = 5939729, upload-time = "2024-10-12T20:42:12.001Z" }, + { url = "https://files.pythonhosted.org/packages/21/27/0c8811fbc3ca188f93b5354e7c286eb91f80a53afa4e11007ef661afa746/pywin32-308-cp312-cp312-win_amd64.whl", hash = "sha256:00b3e11ef09ede56c6a43c71f2d31857cf7c54b0ab6e78ac659497abd2834f47", size = 6543015, upload-time = "2024-10-12T20:42:14.044Z" }, + { url = "https://files.pythonhosted.org/packages/9d/0f/d40f8373608caed2255781a3ad9a51d03a594a1248cd632d6a298daca693/pywin32-308-cp312-cp312-win_arm64.whl", hash = "sha256:9b4de86c8d909aed15b7011182c8cab38c8850de36e6afb1f0db22b8959e3091", size = 7976033, upload-time = "2024-10-12T20:42:16.215Z" }, + { url = "https://files.pythonhosted.org/packages/a9/a4/aa562d8935e3df5e49c161b427a3a2efad2ed4e9cf81c3de636f1fdddfd0/pywin32-308-cp313-cp313-win32.whl", hash = "sha256:1c44539a37a5b7b21d02ab34e6a4d314e0788f1690d65b48e9b0b89f31abbbed", size = 5938579, upload-time = "2024-10-12T20:42:18.623Z" }, + { url = "https://files.pythonhosted.org/packages/c7/50/b0efb8bb66210da67a53ab95fd7a98826a97ee21f1d22949863e6d588b22/pywin32-308-cp313-cp313-win_amd64.whl", hash = "sha256:fd380990e792eaf6827fcb7e187b2b4b1cede0585e3d0c9e84201ec27b9905e4", size = 6542056, upload-time = "2024-10-12T20:42:20.864Z" }, + { url = "https://files.pythonhosted.org/packages/26/df/2b63e3e4f2df0224f8aaf6d131f54fe4e8c96400eb9df563e2aae2e1a1f9/pywin32-308-cp313-cp313-win_arm64.whl", hash = "sha256:ef313c46d4c18dfb82a2431e3051ac8f112ccee1a34f29c263c583c568db63cd", size = 7974986, upload-time = "2024-10-12T20:42:22.799Z" }, +] + +[[package]] +name = "pyzmq" +version = "26.2.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "cffi", marker = "implementation_name == 'pypy'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/5a/e3/8d0382cb59feb111c252b54e8728257416a38ffcb2243c4e4775a3c990fe/pyzmq-26.2.1.tar.gz", hash = "sha256:17d72a74e5e9ff3829deb72897a175333d3ef5b5413948cae3cf7ebf0b02ecca", size = 278433, upload-time = "2025-01-30T11:42:00.757Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b9/03/5ecc46a6ed5971299f5c03e016ca637802d8660e44392bea774fb7797405/pyzmq-26.2.1-cp311-cp311-macosx_10_15_universal2.whl", hash = "sha256:c059883840e634a21c5b31d9b9a0e2b48f991b94d60a811092bc37992715146a", size = 1346032, upload-time = "2025-01-30T11:38:17.357Z" }, + { url = "https://files.pythonhosted.org/packages/40/51/48fec8f990ee644f461ff14c8fe5caa341b0b9b3a0ad7544f8ef17d6f528/pyzmq-26.2.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:ed038a921df836d2f538e509a59cb638df3e70ca0fcd70d0bf389dfcdf784d2a", size = 943324, upload-time = "2025-01-30T11:38:19.942Z" }, + { url = "https://files.pythonhosted.org/packages/c1/f4/f322b389727c687845e38470b48d7a43c18a83f26d4d5084603c6c3f79ca/pyzmq-26.2.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9027a7fcf690f1a3635dc9e55e38a0d6602dbbc0548935d08d46d2e7ec91f454", size = 678418, upload-time = "2025-01-30T11:38:21.806Z" }, + { url = "https://files.pythonhosted.org/packages/a8/df/2834e3202533bd05032d83e02db7ac09fa1be853bbef59974f2b2e3a8557/pyzmq-26.2.1-cp311-cp311-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:6d75fcb00a1537f8b0c0bb05322bc7e35966148ffc3e0362f0369e44a4a1de99", size = 915466, upload-time = "2025-01-30T11:38:23.963Z" }, + { url = "https://files.pythonhosted.org/packages/b5/e2/45c0f6e122b562cb8c6c45c0dcac1160a4e2207385ef9b13463e74f93031/pyzmq-26.2.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f0019cc804ac667fb8c8eaecdb66e6d4a68acf2e155d5c7d6381a5645bd93ae4", size = 873347, upload-time = "2025-01-30T11:38:26.496Z" }, + { url = "https://files.pythonhosted.org/packages/de/b9/3e0fbddf8b87454e914501d368171466a12550c70355b3844115947d68ea/pyzmq-26.2.1-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:f19dae58b616ac56b96f2e2290f2d18730a898a171f447f491cc059b073ca1fa", size = 874545, upload-time = "2025-01-30T11:38:28.428Z" }, + { url = "https://files.pythonhosted.org/packages/1f/1c/1ee41d6e10b2127263b1994bc53b9e74ece015b0d2c0a30e0afaf69b78b2/pyzmq-26.2.1-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:f5eeeb82feec1fc5cbafa5ee9022e87ffdb3a8c48afa035b356fcd20fc7f533f", size = 1208630, upload-time = "2025-01-30T11:38:30.96Z" }, + { url = "https://files.pythonhosted.org/packages/3d/a9/50228465c625851a06aeee97c74f253631f509213f979166e83796299c60/pyzmq-26.2.1-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:000760e374d6f9d1a3478a42ed0c98604de68c9e94507e5452951e598ebecfba", size = 1519568, upload-time = "2025-01-30T11:38:32.813Z" }, + { url = "https://files.pythonhosted.org/packages/c6/f2/6360b619e69da78863c2108beb5196ae8b955fe1e161c0b886b95dc6b1ac/pyzmq-26.2.1-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:817fcd3344d2a0b28622722b98500ae9c8bfee0f825b8450932ff19c0b15bebd", size = 1419677, upload-time = "2025-01-30T11:38:35.902Z" }, + { url = "https://files.pythonhosted.org/packages/da/d5/f179da989168f5dfd1be8103ef508ade1d38a8078dda4f10ebae3131a490/pyzmq-26.2.1-cp311-cp311-win32.whl", hash = "sha256:88812b3b257f80444a986b3596e5ea5c4d4ed4276d2b85c153a6fbc5ca457ae7", size = 582682, upload-time = "2025-01-30T11:38:38.556Z" }, + { url = "https://files.pythonhosted.org/packages/60/50/e5b2e9de3ffab73ff92bee736216cf209381081fa6ab6ba96427777d98b1/pyzmq-26.2.1-cp311-cp311-win_amd64.whl", hash = "sha256:ef29630fde6022471d287c15c0a2484aba188adbfb978702624ba7a54ddfa6c1", size = 648128, upload-time = "2025-01-30T11:38:40.427Z" }, + { url = "https://files.pythonhosted.org/packages/d9/fe/7bb93476dd8405b0fc9cab1fd921a08bd22d5e3016aa6daea1a78d54129b/pyzmq-26.2.1-cp311-cp311-win_arm64.whl", hash = "sha256:f32718ee37c07932cc336096dc7403525301fd626349b6eff8470fe0f996d8d7", size = 562465, upload-time = "2025-01-30T11:38:41.994Z" }, + { url = "https://files.pythonhosted.org/packages/9c/b9/260a74786f162c7f521f5f891584a51d5a42fd15f5dcaa5c9226b2865fcc/pyzmq-26.2.1-cp312-cp312-macosx_10_15_universal2.whl", hash = "sha256:a6549ecb0041dafa55b5932dcbb6c68293e0bd5980b5b99f5ebb05f9a3b8a8f3", size = 1348495, upload-time = "2025-01-30T11:38:44.299Z" }, + { url = "https://files.pythonhosted.org/packages/bf/73/8a0757e4b68f5a8ccb90ddadbb76c6a5f880266cdb18be38c99bcdc17aaa/pyzmq-26.2.1-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:0250c94561f388db51fd0213cdccbd0b9ef50fd3c57ce1ac937bf3034d92d72e", size = 945035, upload-time = "2025-01-30T11:38:46.303Z" }, + { url = "https://files.pythonhosted.org/packages/cf/de/f02ec973cd33155bb772bae33ace774acc7cc71b87b25c4829068bec35de/pyzmq-26.2.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:36ee4297d9e4b34b5dc1dd7ab5d5ea2cbba8511517ef44104d2915a917a56dc8", size = 671213, upload-time = "2025-01-30T11:38:48.334Z" }, + { url = "https://files.pythonhosted.org/packages/d1/80/8fc583085f85ac91682744efc916888dd9f11f9f75a31aef1b78a5486c6c/pyzmq-26.2.1-cp312-cp312-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:c2a9cb17fd83b7a3a3009901aca828feaf20aa2451a8a487b035455a86549c09", size = 908750, upload-time = "2025-01-30T11:38:50.398Z" }, + { url = "https://files.pythonhosted.org/packages/c3/25/0b4824596f261a3cc512ab152448b383047ff5f143a6906a36876415981c/pyzmq-26.2.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:786dd8a81b969c2081b31b17b326d3a499ddd1856e06d6d79ad41011a25148da", size = 865416, upload-time = "2025-01-30T11:38:52.301Z" }, + { url = "https://files.pythonhosted.org/packages/a1/d1/6fda77a034d02034367b040973fd3861d945a5347e607bd2e98c99f20599/pyzmq-26.2.1-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:2d88ba221a07fc2c5581565f1d0fe8038c15711ae79b80d9462e080a1ac30435", size = 865922, upload-time = "2025-01-30T11:38:54.332Z" }, + { url = "https://files.pythonhosted.org/packages/ad/81/48f7fd8a71c427412e739ce576fc1ee14f3dc34527ca9b0076e471676183/pyzmq-26.2.1-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:1c84c1297ff9f1cd2440da4d57237cb74be21fdfe7d01a10810acba04e79371a", size = 1201526, upload-time = "2025-01-30T11:38:57.162Z" }, + { url = "https://files.pythonhosted.org/packages/c7/d8/818f15c6ef36b5450e435cbb0d3a51599fc884a5d2b27b46b9c00af68ef1/pyzmq-26.2.1-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:46d4ebafc27081a7f73a0f151d0c38d4291656aa134344ec1f3d0199ebfbb6d4", size = 1512808, upload-time = "2025-01-30T11:38:59.137Z" }, + { url = "https://files.pythonhosted.org/packages/d9/c4/b3edb7d0ae82ad6fb1a8cdb191a4113c427a01e85139906f3b655b07f4f8/pyzmq-26.2.1-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:91e2bfb8e9a29f709d51b208dd5f441dc98eb412c8fe75c24ea464734ccdb48e", size = 1411836, upload-time = "2025-01-30T11:39:01.157Z" }, + { url = "https://files.pythonhosted.org/packages/69/1c/151e3d42048f02cc5cd6dfc241d9d36b38375b4dee2e728acb5c353a6d52/pyzmq-26.2.1-cp312-cp312-win32.whl", hash = "sha256:4a98898fdce380c51cc3e38ebc9aa33ae1e078193f4dc641c047f88b8c690c9a", size = 581378, upload-time = "2025-01-30T11:39:02.858Z" }, + { url = "https://files.pythonhosted.org/packages/b6/b9/d59a7462848aaab7277fddb253ae134a570520115d80afa85e952287e6bc/pyzmq-26.2.1-cp312-cp312-win_amd64.whl", hash = "sha256:a0741edbd0adfe5f30bba6c5223b78c131b5aa4a00a223d631e5ef36e26e6d13", size = 643737, upload-time = "2025-01-30T11:39:05.495Z" }, + { url = "https://files.pythonhosted.org/packages/55/09/f37e707937cce328944c1d57e5e50ab905011d35252a0745c4f7e5822a76/pyzmq-26.2.1-cp312-cp312-win_arm64.whl", hash = "sha256:e5e33b1491555843ba98d5209439500556ef55b6ab635f3a01148545498355e5", size = 558303, upload-time = "2025-01-30T11:39:08.163Z" }, + { url = "https://files.pythonhosted.org/packages/4f/2e/fa7a91ce349975971d6aa925b4c7e1a05abaae99b97ade5ace758160c43d/pyzmq-26.2.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:099b56ef464bc355b14381f13355542e452619abb4c1e57a534b15a106bf8e23", size = 942331, upload-time = "2025-01-30T11:39:10.936Z" }, + { url = "https://files.pythonhosted.org/packages/64/2b/1f10b34b6dc7ff4b40f668ea25ba9b8093ce61d874c784b90229b367707b/pyzmq-26.2.1-cp313-cp313-macosx_10_15_universal2.whl", hash = "sha256:651726f37fcbce9f8dd2a6dab0f024807929780621890a4dc0c75432636871be", size = 1345831, upload-time = "2025-01-30T11:39:14.136Z" }, + { url = "https://files.pythonhosted.org/packages/4c/8d/34884cbd4a8ec050841b5fb58d37af136766a9f95b0b2634c2971deb09da/pyzmq-26.2.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:57dd4d91b38fa4348e237a9388b4423b24ce9c1695bbd4ba5a3eada491e09399", size = 670773, upload-time = "2025-01-30T11:39:16.881Z" }, + { url = "https://files.pythonhosted.org/packages/0f/f4/d4becfcf9e416ad2564f18a6653f7c6aa917da08df5c3760edb0baa1c863/pyzmq-26.2.1-cp313-cp313-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:d51a7bfe01a48e1064131f3416a5439872c533d756396be2b39e3977b41430f9", size = 908836, upload-time = "2025-01-30T11:39:19.68Z" }, + { url = "https://files.pythonhosted.org/packages/07/fa/ab105f1b86b85cb2e821239f1d0900fccd66192a91d97ee04661b5436b4d/pyzmq-26.2.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c7154d228502e18f30f150b7ce94f0789d6b689f75261b623f0fdc1eec642aab", size = 865369, upload-time = "2025-01-30T11:39:23.038Z" }, + { url = "https://files.pythonhosted.org/packages/c9/48/15d5f415504572dd4b92b52db5de7a5befc76bb75340ba9f36f71306a66d/pyzmq-26.2.1-cp313-cp313-manylinux_2_28_x86_64.whl", hash = "sha256:f1f31661a80cc46aba381bed475a9135b213ba23ca7ff6797251af31510920ce", size = 865676, upload-time = "2025-01-30T11:39:25.173Z" }, + { url = "https://files.pythonhosted.org/packages/7e/35/2d91bcc7ccbb56043dd4d2c1763f24a8de5f05e06a134f767a7fb38e149c/pyzmq-26.2.1-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:290c96f479504439b6129a94cefd67a174b68ace8a8e3f551b2239a64cfa131a", size = 1201457, upload-time = "2025-01-30T11:39:27.022Z" }, + { url = "https://files.pythonhosted.org/packages/6d/bb/aa7c5119307a5762b8dca6c9db73e3ab4bccf32b15d7c4f376271ff72b2b/pyzmq-26.2.1-cp313-cp313-musllinux_1_1_i686.whl", hash = "sha256:f2c307fbe86e18ab3c885b7e01de942145f539165c3360e2af0f094dd440acd9", size = 1513035, upload-time = "2025-01-30T11:39:29.756Z" }, + { url = "https://files.pythonhosted.org/packages/4f/4c/527e6650c2fccec7750b783301329c8a8716d59423818afb67282304ce5a/pyzmq-26.2.1-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:b314268e716487bfb86fcd6f84ebbe3e5bec5fac75fdf42bc7d90fdb33f618ad", size = 1411881, upload-time = "2025-01-30T11:39:32.631Z" }, + { url = "https://files.pythonhosted.org/packages/89/9f/e4412ea1b3e220acc21777a5edba8885856403d29c6999aaf00a9459eb03/pyzmq-26.2.1-cp313-cp313-win32.whl", hash = "sha256:edb550616f567cd5603b53bb52a5f842c0171b78852e6fc7e392b02c2a1504bb", size = 581354, upload-time = "2025-01-30T11:39:34.568Z" }, + { url = "https://files.pythonhosted.org/packages/55/cd/f89dd3e9fc2da0d1619a82c4afb600c86b52bc72d7584953d460bc8d5027/pyzmq-26.2.1-cp313-cp313-win_amd64.whl", hash = "sha256:100a826a029c8ef3d77a1d4c97cbd6e867057b5806a7276f2bac1179f893d3bf", size = 643560, upload-time = "2025-01-30T11:39:36.905Z" }, + { url = "https://files.pythonhosted.org/packages/a7/99/5de4f8912860013f1116f818a0047659bc20d71d1bc1d48f874bdc2d7b9c/pyzmq-26.2.1-cp313-cp313-win_arm64.whl", hash = "sha256:6991ee6c43e0480deb1b45d0c7c2bac124a6540cba7db4c36345e8e092da47ce", size = 558037, upload-time = "2025-01-30T11:39:38.753Z" }, + { url = "https://files.pythonhosted.org/packages/06/0b/63b6d7a2f07a77dbc9768c6302ae2d7518bed0c6cee515669ca0d8ec743e/pyzmq-26.2.1-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:25e720dba5b3a3bb2ad0ad5d33440babd1b03438a7a5220511d0c8fa677e102e", size = 938580, upload-time = "2025-01-30T11:39:40.536Z" }, + { url = "https://files.pythonhosted.org/packages/85/38/e5e2c3ffa23ea5f95f1c904014385a55902a11a67cd43c10edf61a653467/pyzmq-26.2.1-cp313-cp313t-macosx_10_15_universal2.whl", hash = "sha256:9ec6abfb701437142ce9544bd6a236addaf803a32628d2260eb3dbd9a60e2891", size = 1339670, upload-time = "2025-01-30T11:39:42.492Z" }, + { url = "https://files.pythonhosted.org/packages/d2/87/da5519ed7f8b31e4beee8f57311ec02926822fe23a95120877354cd80144/pyzmq-26.2.1-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2e1eb9d2bfdf5b4e21165b553a81b2c3bd5be06eeddcc4e08e9692156d21f1f6", size = 660983, upload-time = "2025-01-30T11:39:44.503Z" }, + { url = "https://files.pythonhosted.org/packages/f6/e8/1ca6a2d59562e04d326a026c9e3f791a6f1a276ebde29da478843a566fdb/pyzmq-26.2.1-cp313-cp313t-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:90dc731d8e3e91bcd456aa7407d2eba7ac6f7860e89f3766baabb521f2c1de4a", size = 896509, upload-time = "2025-01-30T11:39:46.388Z" }, + { url = "https://files.pythonhosted.org/packages/5c/e5/0b4688f7c74bea7e4f1e920da973fcd7d20175f4f1181cb9b692429c6bb9/pyzmq-26.2.1-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0b6a93d684278ad865fc0b9e89fe33f6ea72d36da0e842143891278ff7fd89c3", size = 853196, upload-time = "2025-01-30T11:39:48.192Z" }, + { url = "https://files.pythonhosted.org/packages/8f/35/c17241da01195001828319e98517683dad0ac4df6fcba68763d61b630390/pyzmq-26.2.1-cp313-cp313t-manylinux_2_28_x86_64.whl", hash = "sha256:c1bb37849e2294d519117dd99b613c5177934e5c04a5bb05dd573fa42026567e", size = 855133, upload-time = "2025-01-30T11:39:50.097Z" }, + { url = "https://files.pythonhosted.org/packages/d2/14/268ee49bbecc3f72e225addeac7f0e2bd5808747b78c7bf7f87ed9f9d5a8/pyzmq-26.2.1-cp313-cp313t-musllinux_1_1_aarch64.whl", hash = "sha256:632a09c6d8af17b678d84df442e9c3ad8e4949c109e48a72f805b22506c4afa7", size = 1191612, upload-time = "2025-01-30T11:39:52.05Z" }, + { url = "https://files.pythonhosted.org/packages/5e/02/6394498620b1b4349b95c534f3ebc3aef95f39afbdced5ed7ee315c49c14/pyzmq-26.2.1-cp313-cp313t-musllinux_1_1_i686.whl", hash = "sha256:fc409c18884eaf9ddde516d53af4f2db64a8bc7d81b1a0c274b8aa4e929958e8", size = 1500824, upload-time = "2025-01-30T11:39:54.148Z" }, + { url = "https://files.pythonhosted.org/packages/17/fc/b79f0b72891cbb9917698add0fede71dfb64e83fa3481a02ed0e78c34be7/pyzmq-26.2.1-cp313-cp313t-musllinux_1_1_x86_64.whl", hash = "sha256:17f88622b848805d3f6427ce1ad5a2aa3cf61f12a97e684dab2979802024d460", size = 1399943, upload-time = "2025-01-30T11:39:58.293Z" }, +] + +[[package]] +name = "requests" +version = "2.32.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "certifi" }, + { name = "charset-normalizer" }, + { name = "idna" }, + { name = "urllib3" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/63/70/2bf7780ad2d390a8d301ad0b550f1581eadbd9a20f896afe06353c2a2913/requests-2.32.3.tar.gz", hash = "sha256:55365417734eb18255590a9ff9eb97e9e1da868d4ccd6402399eaf68af20a760", size = 131218, upload-time = "2024-05-29T15:37:49.536Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f9/9b/335f9764261e915ed497fcdeb11df5dfd6f7bf257d4a6a2a686d80da4d54/requests-2.32.3-py3-none-any.whl", hash = "sha256:70761cfe03c773ceb22aa2f671b4757976145175cdfca038c02654d061d6dcc6", size = 64928, upload-time = "2024-05-29T15:37:47.027Z" }, +] + +[[package]] +name = "scipy" +version = "1.17.1" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version < '3.12'", +] +dependencies = [ + { name = "numpy" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/7a/97/5a3609c4f8d58b039179648e62dd220f89864f56f7357f5d4f45c29eb2cc/scipy-1.17.1.tar.gz", hash = "sha256:95d8e012d8cb8816c226aef832200b1d45109ed4464303e997c5b13122b297c0", size = 30573822, upload-time = "2026-02-23T00:26:24.851Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/df/75/b4ce781849931fef6fd529afa6b63711d5a733065722d0c3e2724af9e40a/scipy-1.17.1-cp311-cp311-macosx_10_14_x86_64.whl", hash = "sha256:1f95b894f13729334fb990162e911c9e5dc1ab390c58aa6cbecb389c5b5e28ec", size = 31613675, upload-time = "2026-02-23T00:16:00.13Z" }, + { url = "https://files.pythonhosted.org/packages/f7/58/bccc2861b305abdd1b8663d6130c0b3d7cc22e8d86663edbc8401bfd40d4/scipy-1.17.1-cp311-cp311-macosx_12_0_arm64.whl", hash = "sha256:e18f12c6b0bc5a592ed23d3f7b891f68fd7f8241d69b7883769eb5d5dfb52696", size = 28162057, upload-time = "2026-02-23T00:16:09.456Z" }, + { url = "https://files.pythonhosted.org/packages/6d/ee/18146b7757ed4976276b9c9819108adbc73c5aad636e5353e20746b73069/scipy-1.17.1-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:a3472cfbca0a54177d0faa68f697d8ba4c80bbdc19908c3465556d9f7efce9ee", size = 20334032, upload-time = "2026-02-23T00:16:17.358Z" }, + { url = "https://files.pythonhosted.org/packages/ec/e6/cef1cf3557f0c54954198554a10016b6a03b2ec9e22a4e1df734936bd99c/scipy-1.17.1-cp311-cp311-macosx_14_0_x86_64.whl", hash = "sha256:766e0dc5a616d026a3a1cffa379af959671729083882f50307e18175797b3dfd", size = 22709533, upload-time = "2026-02-23T00:16:25.791Z" }, + { url = "https://files.pythonhosted.org/packages/4d/60/8804678875fc59362b0fb759ab3ecce1f09c10a735680318ac30da8cd76b/scipy-1.17.1-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:744b2bf3640d907b79f3fd7874efe432d1cf171ee721243e350f55234b4cec4c", size = 33062057, upload-time = "2026-02-23T00:16:36.931Z" }, + { url = "https://files.pythonhosted.org/packages/09/7d/af933f0f6e0767995b4e2d705a0665e454d1c19402aa7e895de3951ebb04/scipy-1.17.1-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:43af8d1f3bea642559019edfe64e9b11192a8978efbd1539d7bc2aaa23d92de4", size = 35349300, upload-time = "2026-02-23T00:16:49.108Z" }, + { url = "https://files.pythonhosted.org/packages/b4/3d/7ccbbdcbb54c8fdc20d3b6930137c782a163fa626f0aef920349873421ba/scipy-1.17.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:cd96a1898c0a47be4520327e01f874acfd61fb48a9420f8aa9f6483412ffa444", size = 35127333, upload-time = "2026-02-23T00:17:01.293Z" }, + { url = "https://files.pythonhosted.org/packages/e8/19/f926cb11c42b15ba08e3a71e376d816ac08614f769b4f47e06c3580c836a/scipy-1.17.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:4eb6c25dd62ee8d5edf68a8e1c171dd71c292fdae95d8aeb3dd7d7de4c364082", size = 37741314, upload-time = "2026-02-23T00:17:12.576Z" }, + { url = "https://files.pythonhosted.org/packages/95/da/0d1df507cf574b3f224ccc3d45244c9a1d732c81dcb26b1e8a766ae271a8/scipy-1.17.1-cp311-cp311-win_amd64.whl", hash = "sha256:d30e57c72013c2a4fe441c2fcb8e77b14e152ad48b5464858e07e2ad9fbfceff", size = 36607512, upload-time = "2026-02-23T00:17:23.424Z" }, + { url = "https://files.pythonhosted.org/packages/68/7f/bdd79ceaad24b671543ffe0ef61ed8e659440eb683b66f033454dcee90eb/scipy-1.17.1-cp311-cp311-win_arm64.whl", hash = "sha256:9ecb4efb1cd6e8c4afea0daa91a87fbddbce1b99d2895d151596716c0b2e859d", size = 24599248, upload-time = "2026-02-23T00:17:34.561Z" }, + { url = "https://files.pythonhosted.org/packages/35/48/b992b488d6f299dbe3f11a20b24d3dda3d46f1a635ede1c46b5b17a7b163/scipy-1.17.1-cp312-cp312-macosx_10_14_x86_64.whl", hash = "sha256:35c3a56d2ef83efc372eaec584314bd0ef2e2f0d2adb21c55e6ad5b344c0dcb8", size = 31610954, upload-time = "2026-02-23T00:17:49.855Z" }, + { url = "https://files.pythonhosted.org/packages/b2/02/cf107b01494c19dc100f1d0b7ac3cc08666e96ba2d64db7626066cee895e/scipy-1.17.1-cp312-cp312-macosx_12_0_arm64.whl", hash = "sha256:fcb310ddb270a06114bb64bbe53c94926b943f5b7f0842194d585c65eb4edd76", size = 28172662, upload-time = "2026-02-23T00:18:01.64Z" }, + { url = "https://files.pythonhosted.org/packages/cf/a9/599c28631bad314d219cf9ffd40e985b24d603fc8a2f4ccc5ae8419a535b/scipy-1.17.1-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:cc90d2e9c7e5c7f1a482c9875007c095c3194b1cfedca3c2f3291cdc2bc7c086", size = 20344366, upload-time = "2026-02-23T00:18:12.015Z" }, + { url = "https://files.pythonhosted.org/packages/35/f5/906eda513271c8deb5af284e5ef0206d17a96239af79f9fa0aebfe0e36b4/scipy-1.17.1-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:c80be5ede8f3f8eded4eff73cc99a25c388ce98e555b17d31da05287015ffa5b", size = 22704017, upload-time = "2026-02-23T00:18:21.502Z" }, + { url = "https://files.pythonhosted.org/packages/da/34/16f10e3042d2f1d6b66e0428308ab52224b6a23049cb2f5c1756f713815f/scipy-1.17.1-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e19ebea31758fac5893a2ac360fedd00116cbb7628e650842a6691ba7ca28a21", size = 32927842, upload-time = "2026-02-23T00:18:35.367Z" }, + { url = "https://files.pythonhosted.org/packages/01/8e/1e35281b8ab6d5d72ebe9911edcdffa3f36b04ed9d51dec6dd140396e220/scipy-1.17.1-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:02ae3b274fde71c5e92ac4d54bc06c42d80e399fec704383dcd99b301df37458", size = 35235890, upload-time = "2026-02-23T00:18:49.188Z" }, + { url = "https://files.pythonhosted.org/packages/c5/5c/9d7f4c88bea6e0d5a4f1bc0506a53a00e9fcb198de372bfe4d3652cef482/scipy-1.17.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:8a604bae87c6195d8b1045eddece0514d041604b14f2727bbc2b3020172045eb", size = 35003557, upload-time = "2026-02-23T00:18:54.74Z" }, + { url = "https://files.pythonhosted.org/packages/65/94/7698add8f276dbab7a9de9fb6b0e02fc13ee61d51c7c3f85ac28b65e1239/scipy-1.17.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:f590cd684941912d10becc07325a3eeb77886fe981415660d9265c4c418d0bea", size = 37625856, upload-time = "2026-02-23T00:19:00.307Z" }, + { url = "https://files.pythonhosted.org/packages/a2/84/dc08d77fbf3d87d3ee27f6a0c6dcce1de5829a64f2eae85a0ecc1f0daa73/scipy-1.17.1-cp312-cp312-win_amd64.whl", hash = "sha256:41b71f4a3a4cab9d366cd9065b288efc4d4f3c0b37a91a8e0947fb5bd7f31d87", size = 36549682, upload-time = "2026-02-23T00:19:07.67Z" }, + { url = "https://files.pythonhosted.org/packages/bc/98/fe9ae9ffb3b54b62559f52dedaebe204b408db8109a8c66fdd04869e6424/scipy-1.17.1-cp312-cp312-win_arm64.whl", hash = "sha256:f4115102802df98b2b0db3cce5cb9b92572633a1197c77b7553e5203f284a5b3", size = 24547340, upload-time = "2026-02-23T00:19:12.024Z" }, + { url = "https://files.pythonhosted.org/packages/76/27/07ee1b57b65e92645f219b37148a7e7928b82e2b5dbeccecb4dff7c64f0b/scipy-1.17.1-cp313-cp313-macosx_10_14_x86_64.whl", hash = "sha256:5e3c5c011904115f88a39308379c17f91546f77c1667cea98739fe0fccea804c", size = 31590199, upload-time = "2026-02-23T00:19:17.192Z" }, + { url = "https://files.pythonhosted.org/packages/ec/ae/db19f8ab842e9b724bf5dbb7db29302a91f1e55bc4d04b1025d6d605a2c5/scipy-1.17.1-cp313-cp313-macosx_12_0_arm64.whl", hash = "sha256:6fac755ca3d2c3edcb22f479fceaa241704111414831ddd3bc6056e18516892f", size = 28154001, upload-time = "2026-02-23T00:19:22.241Z" }, + { url = "https://files.pythonhosted.org/packages/5b/58/3ce96251560107b381cbd6e8413c483bbb1228a6b919fa8652b0d4090e7f/scipy-1.17.1-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:7ff200bf9d24f2e4d5dc6ee8c3ac64d739d3a89e2326ba68aaf6c4a2b838fd7d", size = 20325719, upload-time = "2026-02-23T00:19:26.329Z" }, + { url = "https://files.pythonhosted.org/packages/b2/83/15087d945e0e4d48ce2377498abf5ad171ae013232ae31d06f336e64c999/scipy-1.17.1-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:4b400bdc6f79fa02a4d86640310dde87a21fba0c979efff5248908c6f15fad1b", size = 22683595, upload-time = "2026-02-23T00:19:30.304Z" }, + { url = "https://files.pythonhosted.org/packages/b4/e0/e58fbde4a1a594c8be8114eb4aac1a55bcd6587047efc18a61eb1f5c0d30/scipy-1.17.1-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2b64ca7d4aee0102a97f3ba22124052b4bd2152522355073580bf4845e2550b6", size = 32896429, upload-time = "2026-02-23T00:19:35.536Z" }, + { url = "https://files.pythonhosted.org/packages/f5/5f/f17563f28ff03c7b6799c50d01d5d856a1d55f2676f537ca8d28c7f627cd/scipy-1.17.1-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:581b2264fc0aa555f3f435a5944da7504ea3a065d7029ad60e7c3d1ae09c5464", size = 35203952, upload-time = "2026-02-23T00:19:42.259Z" }, + { url = "https://files.pythonhosted.org/packages/8d/a5/9afd17de24f657fdfe4df9a3f1ea049b39aef7c06000c13db1530d81ccca/scipy-1.17.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:beeda3d4ae615106d7094f7e7cef6218392e4465cc95d25f900bebabfded0950", size = 34979063, upload-time = "2026-02-23T00:19:47.547Z" }, + { url = "https://files.pythonhosted.org/packages/8b/13/88b1d2384b424bf7c924f2038c1c409f8d88bb2a8d49d097861dd64a57b2/scipy-1.17.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:6609bc224e9568f65064cfa72edc0f24ee6655b47575954ec6339534b2798369", size = 37598449, upload-time = "2026-02-23T00:19:53.238Z" }, + { url = "https://files.pythonhosted.org/packages/35/e5/d6d0e51fc888f692a35134336866341c08655d92614f492c6860dc45bb2c/scipy-1.17.1-cp313-cp313-win_amd64.whl", hash = "sha256:37425bc9175607b0268f493d79a292c39f9d001a357bebb6b88fdfaff13f6448", size = 36510943, upload-time = "2026-02-23T00:20:50.89Z" }, + { url = "https://files.pythonhosted.org/packages/2a/fd/3be73c564e2a01e690e19cc618811540ba5354c67c8680dce3281123fb79/scipy-1.17.1-cp313-cp313-win_arm64.whl", hash = "sha256:5cf36e801231b6a2059bf354720274b7558746f3b1a4efb43fcf557ccd484a87", size = 24545621, upload-time = "2026-02-23T00:20:55.871Z" }, + { url = "https://files.pythonhosted.org/packages/6f/6b/17787db8b8114933a66f9dcc479a8272e4b4da75fe03b0c282f7b0ade8cd/scipy-1.17.1-cp313-cp313t-macosx_10_14_x86_64.whl", hash = "sha256:d59c30000a16d8edc7e64152e30220bfbd724c9bbb08368c054e24c651314f0a", size = 31936708, upload-time = "2026-02-23T00:19:58.694Z" }, + { url = "https://files.pythonhosted.org/packages/38/2e/524405c2b6392765ab1e2b722a41d5da33dc5c7b7278184a8ad29b6cb206/scipy-1.17.1-cp313-cp313t-macosx_12_0_arm64.whl", hash = "sha256:010f4333c96c9bb1a4516269e33cb5917b08ef2166d5556ca2fd9f082a9e6ea0", size = 28570135, upload-time = "2026-02-23T00:20:03.934Z" }, + { url = "https://files.pythonhosted.org/packages/fd/c3/5bd7199f4ea8556c0c8e39f04ccb014ac37d1468e6cfa6a95c6b3562b76e/scipy-1.17.1-cp313-cp313t-macosx_14_0_arm64.whl", hash = "sha256:2ceb2d3e01c5f1d83c4189737a42d9cb2fc38a6eeed225e7515eef71ad301dce", size = 20741977, upload-time = "2026-02-23T00:20:07.935Z" }, + { url = "https://files.pythonhosted.org/packages/d9/b8/8ccd9b766ad14c78386599708eb745f6b44f08400a5fd0ade7cf89b6fc93/scipy-1.17.1-cp313-cp313t-macosx_14_0_x86_64.whl", hash = "sha256:844e165636711ef41f80b4103ed234181646b98a53c8f05da12ca5ca289134f6", size = 23029601, upload-time = "2026-02-23T00:20:12.161Z" }, + { url = "https://files.pythonhosted.org/packages/6d/a0/3cb6f4d2fb3e17428ad2880333cac878909ad1a89f678527b5328b93c1d4/scipy-1.17.1-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:158dd96d2207e21c966063e1635b1063cd7787b627b6f07305315dd73d9c679e", size = 33019667, upload-time = "2026-02-23T00:20:17.208Z" }, + { url = "https://files.pythonhosted.org/packages/f3/c3/2d834a5ac7bf3a0c806ad1508efc02dda3c8c61472a56132d7894c312dea/scipy-1.17.1-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:74cbb80d93260fe2ffa334efa24cb8f2f0f622a9b9febf8b483c0b865bfb3475", size = 35264159, upload-time = "2026-02-23T00:20:23.087Z" }, + { url = "https://files.pythonhosted.org/packages/4d/77/d3ed4becfdbd217c52062fafe35a72388d1bd82c2d0ba5ca19d6fcc93e11/scipy-1.17.1-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:dbc12c9f3d185f5c737d801da555fb74b3dcfa1a50b66a1a93e09190f41fab50", size = 35102771, upload-time = "2026-02-23T00:20:28.636Z" }, + { url = "https://files.pythonhosted.org/packages/bd/12/d19da97efde68ca1ee5538bb261d5d2c062f0c055575128f11a2730e3ac1/scipy-1.17.1-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:94055a11dfebe37c656e70317e1996dc197e1a15bbcc351bcdd4610e128fe1ca", size = 37665910, upload-time = "2026-02-23T00:20:34.743Z" }, + { url = "https://files.pythonhosted.org/packages/06/1c/1172a88d507a4baaf72c5a09bb6c018fe2ae0ab622e5830b703a46cc9e44/scipy-1.17.1-cp313-cp313t-win_amd64.whl", hash = "sha256:e30bdeaa5deed6bc27b4cc490823cd0347d7dae09119b8803ae576ea0ce52e4c", size = 36562980, upload-time = "2026-02-23T00:20:40.575Z" }, + { url = "https://files.pythonhosted.org/packages/70/b0/eb757336e5a76dfa7911f63252e3b7d1de00935d7705cf772db5b45ec238/scipy-1.17.1-cp313-cp313t-win_arm64.whl", hash = "sha256:a720477885a9d2411f94a93d16f9d89bad0f28ca23c3f8daa521e2dcc3f44d49", size = 24856543, upload-time = "2026-02-23T00:20:45.313Z" }, + { url = "https://files.pythonhosted.org/packages/cf/83/333afb452af6f0fd70414dc04f898647ee1423979ce02efa75c3b0f2c28e/scipy-1.17.1-cp314-cp314-macosx_10_14_x86_64.whl", hash = "sha256:a48a72c77a310327f6a3a920092fa2b8fd03d7deaa60f093038f22d98e096717", size = 31584510, upload-time = "2026-02-23T00:21:01.015Z" }, + { url = "https://files.pythonhosted.org/packages/ed/a6/d05a85fd51daeb2e4ea71d102f15b34fedca8e931af02594193ae4fd25f7/scipy-1.17.1-cp314-cp314-macosx_12_0_arm64.whl", hash = "sha256:45abad819184f07240d8a696117a7aacd39787af9e0b719d00285549ed19a1e9", size = 28170131, upload-time = "2026-02-23T00:21:05.888Z" }, + { url = "https://files.pythonhosted.org/packages/db/7b/8624a203326675d7746a254083a187398090a179335b2e4a20e2ddc46e83/scipy-1.17.1-cp314-cp314-macosx_14_0_arm64.whl", hash = "sha256:3fd1fcdab3ea951b610dc4cef356d416d5802991e7e32b5254828d342f7b7e0b", size = 20342032, upload-time = "2026-02-23T00:21:09.904Z" }, + { url = "https://files.pythonhosted.org/packages/c9/35/2c342897c00775d688d8ff3987aced3426858fd89d5a0e26e020b660b301/scipy-1.17.1-cp314-cp314-macosx_14_0_x86_64.whl", hash = "sha256:7bdf2da170b67fdf10bca777614b1c7d96ae3ca5794fd9587dce41eb2966e866", size = 22678766, upload-time = "2026-02-23T00:21:14.313Z" }, + { url = "https://files.pythonhosted.org/packages/ef/f2/7cdb8eb308a1a6ae1e19f945913c82c23c0c442a462a46480ce487fdc0ac/scipy-1.17.1-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:adb2642e060a6549c343603a3851ba76ef0b74cc8c079a9a58121c7ec9fe2350", size = 32957007, upload-time = "2026-02-23T00:21:19.663Z" }, + { url = "https://files.pythonhosted.org/packages/0b/2e/7eea398450457ecb54e18e9d10110993fa65561c4f3add5e8eccd2b9cd41/scipy-1.17.1-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:eee2cfda04c00a857206a4330f0c5e3e56535494e30ca445eb19ec624ae75118", size = 35221333, upload-time = "2026-02-23T00:21:25.278Z" }, + { url = "https://files.pythonhosted.org/packages/d9/77/5b8509d03b77f093a0d52e606d3c4f79e8b06d1d38c441dacb1e26cacf46/scipy-1.17.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:d2650c1fb97e184d12d8ba010493ee7b322864f7d3d00d3f9bb97d9c21de4068", size = 35042066, upload-time = "2026-02-23T00:21:31.358Z" }, + { url = "https://files.pythonhosted.org/packages/f9/df/18f80fb99df40b4070328d5ae5c596f2f00fffb50167e31439e932f29e7d/scipy-1.17.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:08b900519463543aa604a06bec02461558a6e1cef8fdbb8098f77a48a83c8118", size = 37612763, upload-time = "2026-02-23T00:21:37.247Z" }, + { url = "https://files.pythonhosted.org/packages/4b/39/f0e8ea762a764a9dc52aa7dabcfad51a354819de1f0d4652b6a1122424d6/scipy-1.17.1-cp314-cp314-win_amd64.whl", hash = "sha256:3877ac408e14da24a6196de0ddcace62092bfc12a83823e92e49e40747e52c19", size = 37290984, upload-time = "2026-02-23T00:22:35.023Z" }, + { url = "https://files.pythonhosted.org/packages/7c/56/fe201e3b0f93d1a8bcf75d3379affd228a63d7e2d80ab45467a74b494947/scipy-1.17.1-cp314-cp314-win_arm64.whl", hash = "sha256:f8885db0bc2bffa59d5c1b72fad7a6a92d3e80e7257f967dd81abb553a90d293", size = 25192877, upload-time = "2026-02-23T00:22:39.798Z" }, + { url = "https://files.pythonhosted.org/packages/96/ad/f8c414e121f82e02d76f310f16db9899c4fcde36710329502a6b2a3c0392/scipy-1.17.1-cp314-cp314t-macosx_10_14_x86_64.whl", hash = "sha256:1cc682cea2ae55524432f3cdff9e9a3be743d52a7443d0cba9017c23c87ae2f6", size = 31949750, upload-time = "2026-02-23T00:21:42.289Z" }, + { url = "https://files.pythonhosted.org/packages/7c/b0/c741e8865d61b67c81e255f4f0a832846c064e426636cd7de84e74d209be/scipy-1.17.1-cp314-cp314t-macosx_12_0_arm64.whl", hash = "sha256:2040ad4d1795a0ae89bfc7e8429677f365d45aa9fd5e4587cf1ea737f927b4a1", size = 28585858, upload-time = "2026-02-23T00:21:47.706Z" }, + { url = "https://files.pythonhosted.org/packages/ed/1b/3985219c6177866628fa7c2595bfd23f193ceebbe472c98a08824b9466ff/scipy-1.17.1-cp314-cp314t-macosx_14_0_arm64.whl", hash = "sha256:131f5aaea57602008f9822e2115029b55d4b5f7c070287699fe45c661d051e39", size = 20757723, upload-time = "2026-02-23T00:21:52.039Z" }, + { url = "https://files.pythonhosted.org/packages/c0/19/2a04aa25050d656d6f7b9e7b685cc83d6957fb101665bfd9369ca6534563/scipy-1.17.1-cp314-cp314t-macosx_14_0_x86_64.whl", hash = "sha256:9cdc1a2fcfd5c52cfb3045feb399f7b3ce822abdde3a193a6b9a60b3cb5854ca", size = 23043098, upload-time = "2026-02-23T00:21:56.185Z" }, + { url = "https://files.pythonhosted.org/packages/86/f1/3383beb9b5d0dbddd030335bf8a8b32d4317185efe495374f134d8be6cce/scipy-1.17.1-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6e3dcd57ab780c741fde8dc68619de988b966db759a3c3152e8e9142c26295ad", size = 33030397, upload-time = "2026-02-23T00:22:01.404Z" }, + { url = "https://files.pythonhosted.org/packages/41/68/8f21e8a65a5a03f25a79165ec9d2b28c00e66dc80546cf5eb803aeeff35b/scipy-1.17.1-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a9956e4d4f4a301ebf6cde39850333a6b6110799d470dbbb1e25326ac447f52a", size = 35281163, upload-time = "2026-02-23T00:22:07.024Z" }, + { url = "https://files.pythonhosted.org/packages/84/8d/c8a5e19479554007a5632ed7529e665c315ae7492b4f946b0deb39870e39/scipy-1.17.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:a4328d245944d09fd639771de275701ccadf5f781ba0ff092ad141e017eccda4", size = 35116291, upload-time = "2026-02-23T00:22:12.585Z" }, + { url = "https://files.pythonhosted.org/packages/52/52/e57eceff0e342a1f50e274264ed47497b59e6a4e3118808ee58ddda7b74a/scipy-1.17.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:a77cbd07b940d326d39a1d1b37817e2ee4d79cb30e7338f3d0cddffae70fcaa2", size = 37682317, upload-time = "2026-02-23T00:22:18.513Z" }, + { url = "https://files.pythonhosted.org/packages/11/2f/b29eafe4a3fbc3d6de9662b36e028d5f039e72d345e05c250e121a230dd4/scipy-1.17.1-cp314-cp314t-win_amd64.whl", hash = "sha256:eb092099205ef62cd1782b006658db09e2fed75bffcae7cc0d44052d8aa0f484", size = 37345327, upload-time = "2026-02-23T00:22:24.442Z" }, + { url = "https://files.pythonhosted.org/packages/07/39/338d9219c4e87f3e708f18857ecd24d22a0c3094752393319553096b98af/scipy-1.17.1-cp314-cp314t-win_arm64.whl", hash = "sha256:200e1050faffacc162be6a486a984a0497866ec54149a01270adc8a59b7c7d21", size = 25489165, upload-time = "2026-02-23T00:22:29.563Z" }, +] + +[[package]] +name = "scipy" +version = "1.18.1" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.12'", +] +dependencies = [ + { name = "numpy" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/7e/74/66de6258867beb2ef08f35f9f2ac017a52cacd5081714d239ff1a442d458/scipy-1.18.1.tar.gz", hash = "sha256:52c4b7422442aba924d03ad4019852b08a92e64ea187b933135687bfe2747307", size = 30781235, upload-time = "2026-08-21T23:28:50.599Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/18/f7/240c110c08693826b4513a52f5717d62ec7c7af72f2920821247c03b17b3/scipy-1.18.1-cp312-cp312-macosx_10_15_x86_64.whl", hash = "sha256:457fd7a2a8edeb044ab6ffbc0aa03ff6cd18491356e5e0c834d76ce621b916d1", size = 31111061, upload-time = "2026-08-21T23:23:44.522Z" }, + { url = "https://files.pythonhosted.org/packages/05/4a/78c6285577c375e7cf27277ea8ee6961224327f1e1a0c44af5f17f23635c/scipy-1.18.1-cp312-cp312-macosx_12_0_arm64.whl", hash = "sha256:e708533e8b2ae2497d65346538a7dcc92814410b25b81432eac66de0f2af8265", size = 28733332, upload-time = "2026-08-21T23:23:50.015Z" }, + { url = "https://files.pythonhosted.org/packages/a5/f6/a5b82f8abbe14d134691b8b903696f701d25a081353a29dc655c364d9e62/scipy-1.18.1-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:7bbf207c4453ce1ad2e00b17313852b33310b83090c2311bdaf97f93c0380d12", size = 20475078, upload-time = "2026-08-21T23:23:54.138Z" }, + { url = "https://files.pythonhosted.org/packages/23/22/0858a0bbd6b3e825ceb8cd9baf9eaf3b2f2b1d77727eb6be40500bcdc92f/scipy-1.18.1-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:78c0665edead396b1abb4897c41a5c1d9bf090c8a637a4c20a61678e0a264e66", size = 23108904, upload-time = "2026-08-21T23:23:57.824Z" }, + { url = "https://files.pythonhosted.org/packages/75/9a/2e71719f31eaefe0e3a1706c4a1ded94e664bfd95ffca2b219a671faee01/scipy-1.18.1-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3c085faa2cfa879c5141df483f836f4d691045a078224a670fa570fa01612d89", size = 34025113, upload-time = "2026-08-21T23:24:02.209Z" }, + { url = "https://files.pythonhosted.org/packages/df/64/ff35eb9e54894cf471ff4716abd3c81eb0a0626869217ce3e6ba4ccf17d7/scipy-1.18.1-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f55fa87b6c612ecd6b058f167c53231b1d14e412efe361d3d6e38b3631c73218", size = 35344199, upload-time = "2026-08-21T23:24:07.844Z" }, + { url = "https://files.pythonhosted.org/packages/d3/af/c5538be1792f7034c12c7db6ee67cace58253c7b87b122d68253eaf5de89/scipy-1.18.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:c35d74ce0e193ff740c2f2be2ac913ddc232fe6c1ff40b26cfecb9c670c63314", size = 35639587, upload-time = "2026-08-21T23:24:13.05Z" }, + { url = "https://files.pythonhosted.org/packages/91/4c/075e4f66471bac101141ac739e9e135549be1bae584571bd03a530c056e1/scipy-1.18.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:d2924a03db38dc2e848bca2fe9f077dafb891480b91a00a0963a8cf86dfc31c1", size = 37480330, upload-time = "2026-08-21T23:24:19.608Z" }, + { url = "https://files.pythonhosted.org/packages/39/e7/979fd14e75008623df31ba70d6bb144700f68feadcea042021c06a05bf82/scipy-1.18.1-cp312-cp312-win_amd64.whl", hash = "sha256:5e4d44984abc0020154ea81b247adeddcc3ac5527b975ff798bd1ba0adc513c2", size = 36658278, upload-time = "2026-08-21T23:24:25.463Z" }, + { url = "https://files.pythonhosted.org/packages/c7/0b/e1525354ff9d7d5feb6d1b31af6d14072e5c91e9607b421fa1ec889660b3/scipy-1.18.1-cp312-cp312-win_arm64.whl", hash = "sha256:d65d448389b8436493abcf629cc94ad0cf32aecaf06e1acca1de53cc795f2f12", size = 24400588, upload-time = "2026-08-21T23:24:30.579Z" }, + { url = "https://files.pythonhosted.org/packages/b6/55/4540ee0f9c42a9ad7109d0d1a8cc70de54c3572b01c6693a2b1c70e90ceb/scipy-1.18.1-cp313-cp313-macosx_10_15_x86_64.whl", hash = "sha256:3ab3523da44749156e1f68b464dc56af11ae4cbc5c739a49d05f32b982eca9f3", size = 31089958, upload-time = "2026-08-21T23:24:35.8Z" }, + { url = "https://files.pythonhosted.org/packages/2a/f5/769f36d14922b8071a43e95d24d18b6bdafad10d7f5cf647867e1ac052bc/scipy-1.18.1-cp313-cp313-macosx_12_0_arm64.whl", hash = "sha256:e6fb6a55cc0ba97b59a1f288fb86dc6fce8bdfc0fffcbfd015e3a954bf2a2d93", size = 28715106, upload-time = "2026-08-21T23:24:40.775Z" }, + { url = "https://files.pythonhosted.org/packages/9a/d7/21d890274f75ea37a8209d5519e72da3da90302e3b9fb8397a0918386a62/scipy-1.18.1-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:ea324d9dd34c38bfb9bec8ca4d1b407db97dbb74029f566b8e322b1b6fe56fe6", size = 20456846, upload-time = "2026-08-21T23:24:45.066Z" }, + { url = "https://files.pythonhosted.org/packages/ec/01/798430ecea2e78ec7c02663d5f71c007bb6abeca931080debd40d7fa55ea/scipy-1.18.1-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:75b00eb8fb802090aa903f4ea1c7f5a584779f967361e68b7e98e531cc2d7174", size = 23087986, upload-time = "2026-08-21T23:24:49.539Z" }, + { url = "https://files.pythonhosted.org/packages/e6/5f/4634e9d35c68496e4e34cb6946eafab044458e6cedab42b40b6588e475b6/scipy-1.18.1-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d416b16cccfd70fbf62400e84d0bb2f4e6af519a45557f1692c749b37f14b315", size = 33998146, upload-time = "2026-08-21T23:24:54.714Z" }, + { url = "https://files.pythonhosted.org/packages/41/48/6450ed9243315322bbc19ac57b9b70d66a20bf1d38d124c96bc4bf6af9ea/scipy-1.18.1-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:fdaf5ea890a6183d0565f51a61799d67081bd5b1cf03c5f4b3fd3732108625c9", size = 35312578, upload-time = "2026-08-21T23:25:00.44Z" }, + { url = "https://files.pythonhosted.org/packages/00/bd/bf5a4be6a3525676499f6dff307991739ff6fdcad1481b1aeb6745339f58/scipy-1.18.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:c825cef2f49e46753726a7181a8e199804a912b29519ada542c6ebc654951899", size = 35612621, upload-time = "2026-08-21T23:25:06.144Z" }, + { url = "https://files.pythonhosted.org/packages/bd/4e/3c45c33e00a77996c4b1cb707929f833ba7b1d522ee29f882512c330676d/scipy-1.18.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:e3b417bf8c2c7c16e8f58ad91db17783ec911ac16e7b50eb6eab6e809b4f5b07", size = 37457323, upload-time = "2026-08-21T23:25:12.483Z" }, + { url = "https://files.pythonhosted.org/packages/93/0e/e0348fbc0dbab65c114cf78957e7dfeb49f8e8b556b4d930cc12ff195e18/scipy-1.18.1-cp313-cp313-win_amd64.whl", hash = "sha256:559ed65f60c1af5a03f3912605a1b5114f522c7c32fb23c3376ae8f03219fe28", size = 36622841, upload-time = "2026-08-21T23:25:18.722Z" }, + { url = "https://files.pythonhosted.org/packages/50/a8/6a77f5f267c555108f0a864b6db714363dab567a8266422a79a385f9232b/scipy-1.18.1-cp313-cp313-win_arm64.whl", hash = "sha256:cd479fc04dd9401e3b4f49e76518768ef99c4f517a98c284eb091fd725719adf", size = 24399315, upload-time = "2026-08-21T23:25:23.458Z" }, + { url = "https://files.pythonhosted.org/packages/06/d5/d8eb4e280ddb56a4ab2c6f02ee49b56b23f6e977cf0802fd6d68dbef14f5/scipy-1.18.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:83de5453a7799afc9048b4616bd085cef126e36412f0ea2f6370c36a2a3a51e7", size = 31090936, upload-time = "2026-08-21T23:25:28.686Z" }, + { url = "https://files.pythonhosted.org/packages/2a/49/59ea385dc3a62ff498ddf3cfff7c2b41b0f9f9d3c4122b3f1dcb6d6327fe/scipy-1.18.1-cp314-cp314-macosx_12_0_arm64.whl", hash = "sha256:9554bcc6d715ee87a633a3cc8e7703c6628b100dd29cb8a2efc4c0533c7ff729", size = 28725221, upload-time = "2026-08-21T23:25:33.244Z" }, + { url = "https://files.pythonhosted.org/packages/70/e8/6b0c288c50942d78193696c9f15f9a0874f5178aa0ddf40f83d9924b3e8d/scipy-1.18.1-cp314-cp314-macosx_14_0_arm64.whl", hash = "sha256:011413b7426b75012840e35649e00fe0a2c3bae89fed433876e3a99251572efc", size = 20466839, upload-time = "2026-08-21T23:25:37.516Z" }, + { url = "https://files.pythonhosted.org/packages/4b/e0/54fd3793c729e3b936782f181b59cbb1205bf250ab605a16cb1ba61cdd5e/scipy-1.18.1-cp314-cp314-macosx_14_0_x86_64.whl", hash = "sha256:88f0e784020649f88ea48c9f5ddfa403bf9205820667c0914740b392035afb82", size = 23089121, upload-time = "2026-08-21T23:25:42.019Z" }, + { url = "https://files.pythonhosted.org/packages/0b/56/030af62bea3cf878e0028515dff78c123b01633606a879b63f42d2db99cc/scipy-1.18.1-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2d3ab0e8c69a17dd3559eab8cbb88f258e285c94d572c2719033f90f83290c89", size = 34053851, upload-time = "2026-08-21T23:25:47.998Z" }, + { url = "https://files.pythonhosted.org/packages/6b/89/2a844506d49651e9aa1af6ef95b6bd8031cb1d5a4375edec6155037e04cf/scipy-1.18.1-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ac0333bdf38309aa3dcbe7e3fa7ea29e7a2c37c6ea306a757b700ded8e4596ad", size = 35329183, upload-time = "2026-08-21T23:25:53.522Z" }, + { url = "https://files.pythonhosted.org/packages/eb/56/c7370c3640e92ac9613cbf26cb3f729f9b12ddf1727b55b94b53b24d6f48/scipy-1.18.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:911de823097db8b63f034299d12662db93344e6ffa0b881cbb57748974b70168", size = 35672551, upload-time = "2026-08-21T23:25:59.387Z" }, + { url = "https://files.pythonhosted.org/packages/24/16/ec8536f351421f8bf60a1120930638f83790f4710b8230446aca3d6159d4/scipy-1.18.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:95298364e251be3e60249facbeeca03631d3bb7584f85879516ec55ac717b81f", size = 37469416, upload-time = "2026-08-21T23:26:05.432Z" }, + { url = "https://files.pythonhosted.org/packages/52/94/d73da0d28f16c45bb9b0a5691b91610b0275c5ef0eb5e43c87cf2dc1bf31/scipy-1.18.1-cp314-cp314-win_amd64.whl", hash = "sha256:78a0d7c918e74a232394117160e7e3db503377572a45bcef8826e4ab8a35feba", size = 37362755, upload-time = "2026-08-21T23:26:11.366Z" }, + { url = "https://files.pythonhosted.org/packages/89/25/e996e4dc74e10e227b1e14db5eaf6608bb6dd33884a64851c38f18dd4249/scipy-1.18.1-cp314-cp314-win_arm64.whl", hash = "sha256:cbf38d043c1aa4ab306e1ada6ab6eddacc3322a20b7af1b30bc93254b366fe09", size = 25036090, upload-time = "2026-08-21T23:26:15.887Z" }, + { url = "https://files.pythonhosted.org/packages/fa/c9/c00213f92309d753b48903e6a451b87eb52ff5b7a16e789d1568bbf221c4/scipy-1.18.1-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:0fcb3c93519f27bb4f0c4b0f7802cdcaca7fcf93267b75edda2e9f4e8a55cbd7", size = 31485550, upload-time = "2026-08-21T23:26:20.776Z" }, + { url = "https://files.pythonhosted.org/packages/74/b2/e3067c487982d4eeab2938928529410370c06fea84a4d3f4925e7d96647d/scipy-1.18.1-cp314-cp314t-macosx_12_0_arm64.whl", hash = "sha256:ddef79fb382df40104a19bb7151b3b23e57c1778fcf857c71ceecd9bd264513f", size = 29174642, upload-time = "2026-08-21T23:26:25.395Z" }, + { url = "https://files.pythonhosted.org/packages/d5/ab/374c9fe2d1ec014e576c781a4b5d8e1ba340e8f6b4638c16f711d2b194f0/scipy-1.18.1-cp314-cp314t-macosx_14_0_arm64.whl", hash = "sha256:0e82073ecc7acc6436fac4b31674109c7e1d3e596789767eda01258a8c9e8123", size = 20916357, upload-time = "2026-08-21T23:26:30.112Z" }, + { url = "https://files.pythonhosted.org/packages/90/38/223915c88a17317cafbf8ca2a42b11c265a9fb1e804aa665544132b5fe8a/scipy-1.18.1-cp314-cp314t-macosx_14_0_x86_64.whl", hash = "sha256:8bcf3c1ba5d6456e2effd30fcbd3459b044d683fcdac79a2e6830f0bdf7de487", size = 23482611, upload-time = "2026-08-21T23:26:34.846Z" }, + { url = "https://files.pythonhosted.org/packages/c4/d1/db0948da8ca57a80b36520ef0a768b967d99f3af65f4b6f1bf6362ad4dd4/scipy-1.18.1-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:cfbf154f2ba187f2ed6cce2639efff7d105f1140573642c0161615b6d91d6a87", size = 34143202, upload-time = "2026-08-21T23:26:40.4Z" }, + { url = "https://files.pythonhosted.org/packages/87/53/39d046cc7574ed6acacb6bd5723e220107ece80bff12faaf3efc4ddeede4/scipy-1.18.1-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a1d33a7836f7ddc1993427966a0823468ec41bcbdb1a9f9942d1d7e57f803ba3", size = 35380876, upload-time = "2026-08-21T23:26:46.1Z" }, + { url = "https://files.pythonhosted.org/packages/f9/da/32e0e799d875a85ca57d9bde6c78148afcc0e38276df683d95854eadc8c3/scipy-1.18.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:7f4b8bc363b6d65ee2152bec57568e3c52639bb34c46057b09857a307ed5e21d", size = 35770885, upload-time = "2026-08-21T23:26:51.533Z" }, + { url = "https://files.pythonhosted.org/packages/88/2e/f97a666d362fee68b18f41c9c30ed502ca5c98b549749bfcb52a8b74d1eb/scipy-1.18.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:11c423f1049c5755ad4409af52a9ada1cff96fe9b50795d4af3619f292901239", size = 37525424, upload-time = "2026-08-21T23:26:56.751Z" }, + { url = "https://files.pythonhosted.org/packages/ca/d5/a9e765a84654ebba8479a1fd1b059ced1af72b168a3b2a3a46540ea38d20/scipy-1.18.1-cp314-cp314t-win_amd64.whl", hash = "sha256:c24acac1e18912761c4700239bbc1fd32f615af690f1584d49b35859be51324d", size = 37416961, upload-time = "2026-08-21T23:27:01.546Z" }, + { url = "https://files.pythonhosted.org/packages/ee/16/e79e0d1c63ef698879d85439d37e9fb434e3b804e506a6991038d086ebd9/scipy-1.18.1-cp314-cp314t-win_arm64.whl", hash = "sha256:9f2897bf7737392ad0d5213ea7b6add72a4edf5679b3153106aeb88b6507b3b9", size = 25331848, upload-time = "2026-08-21T23:27:05.884Z" }, + { url = "https://files.pythonhosted.org/packages/be/4f/1bd37c883b67163e2ca1f60977a399500e6879c15defecac62831c8d078d/scipy-1.18.1-cp315-cp315-macosx_10_15_x86_64.whl", hash = "sha256:eb0dfcf4e28a99c12c999744a2ff67c9b06200e20401c7c88186e33552a46331", size = 31091484, upload-time = "2026-08-21T23:27:11.051Z" }, + { url = "https://files.pythonhosted.org/packages/8c/c5/ba929d7feb9b2332f96827c12e0e924b61973b59b4dea383b603372c65ce/scipy-1.18.1-cp315-cp315-macosx_12_0_arm64.whl", hash = "sha256:30f464bee641fa8e282577c7dce027308403213c6ca8270bba73285c91024bc5", size = 28725057, upload-time = "2026-08-21T23:27:15.9Z" }, + { url = "https://files.pythonhosted.org/packages/a4/19/68f1c50f609d955d230e66d25d02bd3e1e167ec540232135354fb9a4b9e3/scipy-1.18.1-cp315-cp315-macosx_14_0_arm64.whl", hash = "sha256:1bca3b943fc2567ea49cd02c99abde49da4d5178ec46f624bd8255cda8755beb", size = 20466734, upload-time = "2026-08-21T23:27:20.044Z" }, + { url = "https://files.pythonhosted.org/packages/ef/6d/319fa29b73d1802fa80b32a6eaf3f5be456ef81526da2716a9493bcb5501/scipy-1.18.1-cp315-cp315-macosx_14_0_x86_64.whl", hash = "sha256:c9d18a33309122074ea483dd92dd444189166b8b2ec429fe9ed5ac73c7a0aa23", size = 23089664, upload-time = "2026-08-21T23:27:24.345Z" }, + { url = "https://files.pythonhosted.org/packages/b7/db/30992f9b51a63de671daf3888ffd18378b6cb9ec9f2c972264238ffa7fd6/scipy-1.18.1-cp315-cp315-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:82f201b4c878551d48558337aab270d3c6cca5507b8737c8d8a608d234cccde0", size = 34054035, upload-time = "2026-08-21T23:27:29.409Z" }, + { url = "https://files.pythonhosted.org/packages/91/d4/bf3e735dc0b9d5a8ff45079d2540e17d3aff7a2f0048dd8f552ffd031d2b/scipy-1.18.1-cp315-cp315-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0ac49ea97594532dd44b7136094d35f5440fa06e6d9c6384a74c01764df388c5", size = 35333883, upload-time = "2026-08-21T23:27:34.293Z" }, + { url = "https://files.pythonhosted.org/packages/19/93/12d78ce9f871fe945fca588d32644e6e63f553c2a35c564d73f3b22a3313/scipy-1.18.1-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:ceb30a00ce7c92d459819443d29ca486d882b83fb6738bdcbb2a1cce94ac5daa", size = 35673124, upload-time = "2026-08-21T23:27:39.059Z" }, + { url = "https://files.pythonhosted.org/packages/70/cd/886219313a1012a48e6ae0ec4f302c837151beb92e1ff0d709ef8fdfc488/scipy-1.18.1-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:f29633129f9fa7e88a3f0fca835de2d030bfc9643f7799e1a0c46cee24d38fc7", size = 37470753, upload-time = "2026-08-21T23:27:44.435Z" }, + { url = "https://files.pythonhosted.org/packages/17/6c/a776888ce618bee54fbde26172f0f46ac1da70d27b63861797fe78e1904b/scipy-1.18.1-cp315-cp315-win_amd64.whl", hash = "sha256:92c14f5bdbfb6216315ce33e78080474082de8b3830122ba97809bfbe65f75c0", size = 37361483, upload-time = "2026-08-21T23:27:49.334Z" }, + { url = "https://files.pythonhosted.org/packages/ab/09/97b651691322ebee97999b017ffc18a15a0b815103844c97e8da9d469731/scipy-1.18.1-cp315-cp315-win_arm64.whl", hash = "sha256:e402cf31eb68f453dbb2d36fc6d722b33f24a55d68b2ae1d92fa6305ca71c298", size = 25035883, upload-time = "2026-08-21T23:27:53.596Z" }, + { url = "https://files.pythonhosted.org/packages/ed/0f/9ec20467bbabd0d44e2a77d0fd3d124f884b4d67df92af82c91d2d6a486f/scipy-1.18.1-cp315-cp315t-macosx_10_15_x86_64.whl", hash = "sha256:2a0b02f9fc46f8520330c23d45e6560db7e3a0d927232139427637f98943e11d", size = 31474926, upload-time = "2026-08-21T23:27:57.993Z" }, + { url = "https://files.pythonhosted.org/packages/8a/58/dcb79161e56efbedc50079fcd2f5fe427a0ebb53022eb476aa73c015ad8f/scipy-1.18.1-cp315-cp315t-macosx_12_0_arm64.whl", hash = "sha256:1d73131e358976663dd969e1fb4ed1404b815cd977eaaedc3b3a133ba2d81c35", size = 29164940, upload-time = "2026-08-21T23:28:03.062Z" }, + { url = "https://files.pythonhosted.org/packages/71/d3/1eeea80c817fcb8ef7bd4a05a58824977a0e57a375cfc3d7ea7c911c01ad/scipy-1.18.1-cp315-cp315t-macosx_14_0_arm64.whl", hash = "sha256:bff0b729edd992766136b34e39cc76bc2fad905aa58897ee72a9cd000a6d8443", size = 20906742, upload-time = "2026-08-21T23:28:07.642Z" }, + { url = "https://files.pythonhosted.org/packages/54/46/e59350428b6099301a20128108c995e2eb175a43f383af9a346e38824f9b/scipy-1.18.1-cp315-cp315t-macosx_14_0_x86_64.whl", hash = "sha256:10ac20c69d880f77f375db44c22e3e6a644f9fefa291d4cd2fb9790a89fc99fd", size = 23472183, upload-time = "2026-08-21T23:28:12.109Z" }, + { url = "https://files.pythonhosted.org/packages/89/31/cc91623fa98f0621766a0f0aaaadb2c66de74a7ea7e3837164f6e4354260/scipy-1.18.1-cp315-cp315t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:33a834464fdabc0f26a45508df31b3cc5d028e04dbf6c5ed398541418e0a12fe", size = 34130796, upload-time = "2026-08-21T23:28:17.906Z" }, + { url = "https://files.pythonhosted.org/packages/fc/3e/8572ef536957ddb8aa81bb4090d9e25f257e3b4e05d97deb54319deb8a3a/scipy-1.18.1-cp315-cp315t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:49023963c193dacee096301452f223ee24d86ec5807f8df93c0f7221d119e305", size = 35374253, upload-time = "2026-08-21T23:28:23.732Z" }, + { url = "https://files.pythonhosted.org/packages/b5/c6/59fdeffb4f1435299f93d9dc8140b43ad2916e6cfc944be6c3041fcec86d/scipy-1.18.1-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:d84a09d0dad90ba6525d8ac1c2334b33e64bf3ccfe9e841f02feb867a22681e4", size = 35758543, upload-time = "2026-08-21T23:28:29.431Z" }, + { url = "https://files.pythonhosted.org/packages/cf/d9/135be205d9de8783193aff9cc3bf483a03a38e4b29432c954e8cb66ac14e/scipy-1.18.1-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:179ce34a8d0fe273d8883ba59e17e052247d08973dfcb743ca52bb1cce2d60b0", size = 37521946, upload-time = "2026-08-21T23:28:35.245Z" }, + { url = "https://files.pythonhosted.org/packages/5c/a2/5b7d5270621ab7cfa3f7766067bf95dc360b5efb6394694e8143b4156e2b/scipy-1.18.1-cp315-cp315t-win_amd64.whl", hash = "sha256:5632e3ae3d09197c446310cd5187de63e28448ce22f0f67b2b93d97503c0c230", size = 37408295, upload-time = "2026-08-21T23:28:40.724Z" }, + { url = "https://files.pythonhosted.org/packages/63/ad/741c19fcb66755ff953daf9243af8480e4bf3d7fbe57583c178c7d2b6b51/scipy-1.18.1-cp315-cp315t-win_arm64.whl", hash = "sha256:eda632a7981f69730d6281f451db9c1c370993a2c0d7ddb43e2a809a2862b83a", size = 25319710, upload-time = "2026-08-21T23:28:45.713Z" }, +] + +[[package]] +name = "six" +version = "1.17.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/94/e7/b2c673351809dca68a0e064b6af791aa332cf192da575fd474ed7d6f16a2/six-1.17.0.tar.gz", hash = "sha256:ff70335d468e7eb6ec65b95b99d3a2836546063f63acc5171de367e834932a81", size = 34031, upload-time = "2024-12-04T17:35:28.174Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b7/ce/149a00dd41f10bc29e5921b496af8b574d8413afcd5e30dfa0ed46c2cc5e/six-1.17.0-py2.py3-none-any.whl", hash = "sha256:4721f391ed90541fddacab5acf947aa0d3dc7d27b2e1e8eda2be8970586c3274", size = 11050, upload-time = "2024-12-04T17:35:26.475Z" }, +] + +[[package]] +name = "snowballstemmer" +version = "2.2.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/44/7b/af302bebf22c749c56c9c3e8ae13190b5b5db37a33d9068652e8f73b7089/snowballstemmer-2.2.0.tar.gz", hash = "sha256:09b16deb8547d3412ad7b590689584cd0fe25ec8db3be37788be3810cbf19cb1", size = 86699, upload-time = "2021-11-16T18:38:38.009Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ed/dc/c02e01294f7265e63a7315fe086dd1df7dacb9f840a804da846b96d01b96/snowballstemmer-2.2.0-py2.py3-none-any.whl", hash = "sha256:c8e1716e83cc398ae16824e5572ae04e0d9fc2c6b985fb0f900f5f0c96ecba1a", size = 93002, upload-time = "2021-11-16T18:38:34.792Z" }, +] + +[[package]] +name = "sortedcontainers" +version = "2.4.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/e8/c4/ba2f8066cceb6f23394729afe52f3bf7adec04bf9ed2c820b39e19299111/sortedcontainers-2.4.0.tar.gz", hash = "sha256:25caa5a06cc30b6b83d11423433f65d1f9d76c4c6a0c90e3379eaa43b9bfdb88", size = 30594, upload-time = "2021-05-16T22:03:42.897Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/32/46/9cb0e58b2deb7f82b84065f37f3bffeb12413f947f9388e4cac22c4621ce/sortedcontainers-2.4.0-py2.py3-none-any.whl", hash = "sha256:a163dcaede0f1c021485e957a39245190e74249897e2ae4b2aa38595db237ee0", size = 29575, upload-time = "2021-05-16T22:03:41.177Z" }, +] + +[[package]] +name = "sphinx" +version = "8.1.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "alabaster" }, + { name = "babel" }, + { name = "colorama", marker = "sys_platform == 'win32'" }, + { name = "docutils" }, + { name = "imagesize" }, + { name = "jinja2" }, + { name = "packaging" }, + { name = "pygments" }, + { name = "requests" }, + { name = "snowballstemmer" }, + { name = "sphinxcontrib-applehelp" }, + { name = "sphinxcontrib-devhelp" }, + { name = "sphinxcontrib-htmlhelp" }, + { name = "sphinxcontrib-jsmath" }, + { name = "sphinxcontrib-qthelp" }, + { name = "sphinxcontrib-serializinghtml" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/6f/6d/be0b61178fe2cdcb67e2a92fc9ebb488e3c51c4f74a36a7824c0adf23425/sphinx-8.1.3.tar.gz", hash = "sha256:43c1911eecb0d3e161ad78611bc905d1ad0e523e4ddc202a58a821773dc4c927", size = 8184611, upload-time = "2024-10-13T20:27:13.93Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/26/60/1ddff83a56d33aaf6f10ec8ce84b4c007d9368b21008876fceda7e7381ef/sphinx-8.1.3-py3-none-any.whl", hash = "sha256:09719015511837b76bf6e03e42eb7595ac8c2e41eeb9c29c5b755c6b677992a2", size = 3487125, upload-time = "2024-10-13T20:27:10.448Z" }, +] + +[[package]] +name = "sphinx-rtd-theme" +version = "3.0.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "docutils" }, + { name = "sphinx" }, + { name = "sphinxcontrib-jquery" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/91/44/c97faec644d29a5ceddd3020ae2edffa69e7d00054a8c7a6021e82f20335/sphinx_rtd_theme-3.0.2.tar.gz", hash = "sha256:b7457bc25dda723b20b086a670b9953c859eab60a2a03ee8eb2bb23e176e5f85", size = 7620463, upload-time = "2024-11-13T11:06:04.545Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/85/77/46e3bac77b82b4df5bb5b61f2de98637724f246b4966cfc34bc5895d852a/sphinx_rtd_theme-3.0.2-py2.py3-none-any.whl", hash = "sha256:422ccc750c3a3a311de4ae327e82affdaf59eb695ba4936538552f3b00f4ee13", size = 7655561, upload-time = "2024-11-13T11:06:02.094Z" }, +] + +[[package]] +name = "sphinxcontrib-applehelp" +version = "2.0.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/ba/6e/b837e84a1a704953c62ef8776d45c3e8d759876b4a84fe14eba2859106fe/sphinxcontrib_applehelp-2.0.0.tar.gz", hash = "sha256:2f29ef331735ce958efa4734873f084941970894c6090408b079c61b2e1c06d1", size = 20053, upload-time = "2024-07-29T01:09:00.465Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/5d/85/9ebeae2f76e9e77b952f4b274c27238156eae7979c5421fba91a28f4970d/sphinxcontrib_applehelp-2.0.0-py3-none-any.whl", hash = "sha256:4cd3f0ec4ac5dd9c17ec65e9ab272c9b867ea77425228e68ecf08d6b28ddbdb5", size = 119300, upload-time = "2024-07-29T01:08:58.99Z" }, +] + +[[package]] +name = "sphinxcontrib-devhelp" +version = "2.0.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f6/d2/5beee64d3e4e747f316bae86b55943f51e82bb86ecd325883ef65741e7da/sphinxcontrib_devhelp-2.0.0.tar.gz", hash = "sha256:411f5d96d445d1d73bb5d52133377b4248ec79db5c793ce7dbe59e074b4dd1ad", size = 12967, upload-time = "2024-07-29T01:09:23.417Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/35/7a/987e583882f985fe4d7323774889ec58049171828b58c2217e7f79cdf44e/sphinxcontrib_devhelp-2.0.0-py3-none-any.whl", hash = "sha256:aefb8b83854e4b0998877524d1029fd3e6879210422ee3780459e28a1f03a8a2", size = 82530, upload-time = "2024-07-29T01:09:21.945Z" }, +] + +[[package]] +name = "sphinxcontrib-htmlhelp" +version = "2.1.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/43/93/983afd9aa001e5201eab16b5a444ed5b9b0a7a010541e0ddfbbfd0b2470c/sphinxcontrib_htmlhelp-2.1.0.tar.gz", hash = "sha256:c9e2916ace8aad64cc13a0d233ee22317f2b9025b9cf3295249fa985cc7082e9", size = 22617, upload-time = "2024-07-29T01:09:37.889Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/0a/7b/18a8c0bcec9182c05a0b3ec2a776bba4ead82750a55ff798e8d406dae604/sphinxcontrib_htmlhelp-2.1.0-py3-none-any.whl", hash = "sha256:166759820b47002d22914d64a075ce08f4c46818e17cfc9470a9786b759b19f8", size = 98705, upload-time = "2024-07-29T01:09:36.407Z" }, +] + +[[package]] +name = "sphinxcontrib-jquery" +version = "4.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "sphinx" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/de/f3/aa67467e051df70a6330fe7770894b3e4f09436dea6881ae0b4f3d87cad8/sphinxcontrib-jquery-4.1.tar.gz", hash = "sha256:1620739f04e36a2c779f1a131a2dfd49b2fd07351bf1968ced074365933abc7a", size = 122331, upload-time = "2023-03-14T15:01:01.944Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/76/85/749bd22d1a68db7291c89e2ebca53f4306c3f205853cf31e9de279034c3c/sphinxcontrib_jquery-4.1-py2.py3-none-any.whl", hash = "sha256:f936030d7d0147dd026a4f2b5a57343d233f1fc7b363f68b3d4f1cb0993878ae", size = 121104, upload-time = "2023-03-14T15:01:00.356Z" }, +] + +[[package]] +name = "sphinxcontrib-jsmath" +version = "1.0.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/b2/e8/9ed3830aeed71f17c026a07a5097edcf44b692850ef215b161b8ad875729/sphinxcontrib-jsmath-1.0.1.tar.gz", hash = "sha256:a9925e4a4587247ed2191a22df5f6970656cb8ca2bd6284309578f2153e0c4b8", size = 5787, upload-time = "2019-01-21T16:10:16.347Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c2/42/4c8646762ee83602e3fb3fbe774c2fac12f317deb0b5dbeeedd2d3ba4b77/sphinxcontrib_jsmath-1.0.1-py2.py3-none-any.whl", hash = "sha256:2ec2eaebfb78f3f2078e73666b1415417a116cc848b72e5172e596c871103178", size = 5071, upload-time = "2019-01-21T16:10:14.333Z" }, +] + +[[package]] +name = "sphinxcontrib-qthelp" +version = "2.0.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/68/bc/9104308fc285eb3e0b31b67688235db556cd5b0ef31d96f30e45f2e51cae/sphinxcontrib_qthelp-2.0.0.tar.gz", hash = "sha256:4fe7d0ac8fc171045be623aba3e2a8f613f8682731f9153bb2e40ece16b9bbab", size = 17165, upload-time = "2024-07-29T01:09:56.435Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/27/83/859ecdd180cacc13b1f7e857abf8582a64552ea7a061057a6c716e790fce/sphinxcontrib_qthelp-2.0.0-py3-none-any.whl", hash = "sha256:b18a828cdba941ccd6ee8445dbe72ffa3ef8cbe7505d8cd1fa0d42d3f2d5f3eb", size = 88743, upload-time = "2024-07-29T01:09:54.885Z" }, +] + +[[package]] +name = "sphinxcontrib-serializinghtml" +version = "2.0.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/3b/44/6716b257b0aa6bfd51a1b31665d1c205fb12cb5ad56de752dfa15657de2f/sphinxcontrib_serializinghtml-2.0.0.tar.gz", hash = "sha256:e9d912827f872c029017a53f0ef2180b327c3f7fd23c87229f7a8e8b70031d4d", size = 16080, upload-time = "2024-07-29T01:10:09.332Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/52/a7/d2782e4e3f77c8450f727ba74a8f12756d5ba823d81b941f1b04da9d033a/sphinxcontrib_serializinghtml-2.0.0-py3-none-any.whl", hash = "sha256:6e2cb0eef194e10c27ec0023bfeb25badbbb5868244cf5bc5bdc04e4464bf331", size = 92072, upload-time = "2024-07-29T01:10:08.203Z" }, +] + +[[package]] +name = "stack-data" +version = "0.6.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "asttokens" }, + { name = "executing" }, + { name = "pure-eval" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/28/e3/55dcc2cfbc3ca9c29519eb6884dd1415ecb53b0e934862d3559ddcb7e20b/stack_data-0.6.3.tar.gz", hash = "sha256:836a778de4fec4dcd1dcd89ed8abff8a221f58308462e1c4aa2a3cf30148f0b9", size = 44707, upload-time = "2023-09-30T13:58:05.479Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f1/7b/ce1eafaf1a76852e2ec9b22edecf1daa58175c090266e9f6c64afcd81d91/stack_data-0.6.3-py3-none-any.whl", hash = "sha256:d5558e0c25a4cb0853cddad3d77da9891a08cb85dd9f9f91b9f8cd66e511e695", size = 24521, upload-time = "2023-09-30T13:58:03.53Z" }, +] + +[[package]] +name = "tornado" +version = "6.4.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/59/45/a0daf161f7d6f36c3ea5fc0c2de619746cc3dd4c76402e9db545bd920f63/tornado-6.4.2.tar.gz", hash = "sha256:92bad5b4746e9879fd7bf1eb21dce4e3fc5128d71601f80005afa39237ad620b", size = 501135, upload-time = "2024-11-22T03:06:38.036Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/26/7e/71f604d8cea1b58f82ba3590290b66da1e72d840aeb37e0d5f7291bd30db/tornado-6.4.2-cp38-abi3-macosx_10_9_universal2.whl", hash = "sha256:e828cce1123e9e44ae2a50a9de3055497ab1d0aeb440c5ac23064d9e44880da1", size = 436299, upload-time = "2024-11-22T03:06:20.162Z" }, + { url = "https://files.pythonhosted.org/packages/96/44/87543a3b99016d0bf54fdaab30d24bf0af2e848f1d13d34a3a5380aabe16/tornado-6.4.2-cp38-abi3-macosx_10_9_x86_64.whl", hash = "sha256:072ce12ada169c5b00b7d92a99ba089447ccc993ea2143c9ede887e0937aa803", size = 434253, upload-time = "2024-11-22T03:06:22.39Z" }, + { url = "https://files.pythonhosted.org/packages/cb/fb/fdf679b4ce51bcb7210801ef4f11fdac96e9885daa402861751353beea6e/tornado-6.4.2-cp38-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1a017d239bd1bb0919f72af256a970624241f070496635784d9bf0db640d3fec", size = 437602, upload-time = "2024-11-22T03:06:24.214Z" }, + { url = "https://files.pythonhosted.org/packages/4f/3b/e31aeffffc22b475a64dbeb273026a21b5b566f74dee48742817626c47dc/tornado-6.4.2-cp38-abi3-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:c36e62ce8f63409301537222faffcef7dfc5284f27eec227389f2ad11b09d946", size = 436972, upload-time = "2024-11-22T03:06:25.559Z" }, + { url = "https://files.pythonhosted.org/packages/22/55/b78a464de78051a30599ceb6983b01d8f732e6f69bf37b4ed07f642ac0fc/tornado-6.4.2-cp38-abi3-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bca9eb02196e789c9cb5c3c7c0f04fb447dc2adffd95265b2c7223a8a615ccbf", size = 437173, upload-time = "2024-11-22T03:06:27.584Z" }, + { url = "https://files.pythonhosted.org/packages/79/5e/be4fb0d1684eb822c9a62fb18a3e44a06188f78aa466b2ad991d2ee31104/tornado-6.4.2-cp38-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:304463bd0772442ff4d0f5149c6f1c2135a1fae045adf070821c6cdc76980634", size = 437892, upload-time = "2024-11-22T03:06:28.933Z" }, + { url = "https://files.pythonhosted.org/packages/f5/33/4f91fdd94ea36e1d796147003b490fe60a0215ac5737b6f9c65e160d4fe0/tornado-6.4.2-cp38-abi3-musllinux_1_2_i686.whl", hash = "sha256:c82c46813ba483a385ab2a99caeaedf92585a1f90defb5693351fa7e4ea0bf73", size = 437334, upload-time = "2024-11-22T03:06:30.428Z" }, + { url = "https://files.pythonhosted.org/packages/2b/ae/c1b22d4524b0e10da2f29a176fb2890386f7bd1f63aacf186444873a88a0/tornado-6.4.2-cp38-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:932d195ca9015956fa502c6b56af9eb06106140d844a335590c1ec7f5277d10c", size = 437261, upload-time = "2024-11-22T03:06:32.458Z" }, + { url = "https://files.pythonhosted.org/packages/b5/25/36dbd49ab6d179bcfc4c6c093a51795a4f3bed380543a8242ac3517a1751/tornado-6.4.2-cp38-abi3-win32.whl", hash = "sha256:2876cef82e6c5978fde1e0d5b1f919d756968d5b4282418f3146b79b58556482", size = 438463, upload-time = "2024-11-22T03:06:34.71Z" }, + { url = "https://files.pythonhosted.org/packages/61/cc/58b1adeb1bb46228442081e746fcdbc4540905c87e8add7c277540934edb/tornado-6.4.2-cp38-abi3-win_amd64.whl", hash = "sha256:908b71bf3ff37d81073356a5fadcc660eb10c1476ee6e2725588626ce7e5ca38", size = 438907, upload-time = "2024-11-22T03:06:36.71Z" }, +] + +[[package]] +name = "traitlets" +version = "5.14.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/eb/79/72064e6a701c2183016abbbfedaba506d81e30e232a68c9f0d6f6fcd1574/traitlets-5.14.3.tar.gz", hash = "sha256:9ed0579d3502c94b4b3732ac120375cda96f923114522847de4b3bb98b96b6b7", size = 161621, upload-time = "2024-04-19T11:11:49.746Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/00/c0/8f5d070730d7836adc9c9b6408dec68c6ced86b304a9b26a14df072a6e8c/traitlets-5.14.3-py3-none-any.whl", hash = "sha256:b74e89e397b1ed28cc831db7aea759ba6640cb3de13090ca145426688ff1ac4f", size = 85359, upload-time = "2024-04-19T11:11:46.763Z" }, +] + +[[package]] +name = "typing-extensions" +version = "4.12.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/df/db/f35a00659bc03fec321ba8bce9420de607a1d37f8342eee1863174c69557/typing_extensions-4.12.2.tar.gz", hash = "sha256:1a7ead55c7e559dd4dee8856e3a88b41225abfe1ce8df57b7c13915fe121ffb8", size = 85321, upload-time = "2024-06-07T18:52:15.995Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/26/9f/ad63fc0248c5379346306f8668cda6e2e2e9c95e01216d2b8ffd9ff037d0/typing_extensions-4.12.2-py3-none-any.whl", hash = "sha256:04e5ca0351e0f3f85c6853954072df659d0d13fac324d0072316b67d7794700d", size = 37438, upload-time = "2024-06-07T18:52:13.582Z" }, +] + +[[package]] +name = "tzdata" +version = "2025.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/43/0f/fa4723f22942480be4ca9527bbde8d43f6c3f2fe8412f00e7f5f6746bc8b/tzdata-2025.1.tar.gz", hash = "sha256:24894909e88cdb28bd1636c6887801df64cb485bd593f2fd83ef29075a81d694", size = 194950, upload-time = "2025-01-21T19:49:38.686Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/0f/dd/84f10e23edd882c6f968c21c2434fe67bd4a528967067515feca9e611e5e/tzdata-2025.1-py2.py3-none-any.whl", hash = "sha256:7e127113816800496f027041c570f50bcd464a020098a3b6b199517772303639", size = 346762, upload-time = "2025-01-21T19:49:37.187Z" }, +] + +[[package]] +name = "urllib3" +version = "2.3.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/aa/63/e53da845320b757bf29ef6a9062f5c669fe997973f966045cb019c3f4b66/urllib3-2.3.0.tar.gz", hash = "sha256:f8c5449b3cf0861679ce7e0503c7b44b5ec981bec0d1d3795a07f1ba96f0204d", size = 307268, upload-time = "2024-12-22T07:47:30.032Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c8/19/4ec628951a74043532ca2cf5d97b7b14863931476d117c471e8e2b1eb39f/urllib3-2.3.0-py3-none-any.whl", hash = "sha256:1cee9ad369867bfdbbb48b7dd50374c0967a0bb7710050facf0dd6911440e3df", size = 128369, upload-time = "2024-12-22T07:47:28.074Z" }, +] + +[[package]] +name = "wcwidth" +version = "0.2.13" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/6c/63/53559446a878410fc5a5974feb13d31d78d752eb18aeba59c7fef1af7598/wcwidth-0.2.13.tar.gz", hash = "sha256:72ea0c06399eb286d978fdedb6923a9eb47e1c486ce63e9b4e64fc18303972b5", size = 101301, upload-time = "2024-01-06T02:10:57.829Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/fd/84/fd2ba7aafacbad3c4201d395674fc6348826569da3c0937e75505ead3528/wcwidth-0.2.13-py2.py3-none-any.whl", hash = "sha256:3da69048e4540d84af32131829ff948f1e022c1c6bdb8d6102117aac784f6859", size = 34166, upload-time = "2024-01-06T02:10:55.763Z" }, +]