diff --git a/.black.toml b/.black.toml deleted file mode 100644 index bedc2510..00000000 --- a/.black.toml +++ /dev/null @@ -1,15 +0,0 @@ -[tool.black] -line-length = 120 -target-version = ['py37', 'py38', 'py39', 'py310', 'py311'] -exclude = ''' -/( - \.eggs - | \.git - | \.idea - | \.pytest_cache - | _build - | build - | dist - | venv -)/ -''' diff --git a/.coveragerc b/.coveragerc deleted file mode 100644 index 3d7adfa9..00000000 --- a/.coveragerc +++ /dev/null @@ -1,28 +0,0 @@ -[report] -omit = - */python?.?/* - */site-packages/nose/* - */test/* - */pypy/* - */nose/* - */.*/* - */*.egg-info/* -exclude_lines = - pragma: no cover - raise err - except ImportError - yaml = none - raise BoxError\("_box_config key must exist - raise err - if "box_class" in self.__dict__: - raise BoxError\(f"File - except OSError - raise BoxError\(f"{filename} - item._box_config["__box_heritage"] = \(\) - raise BoxKeyError\(err - (.*)is unavailable on this system - def to_ - def from_ - warnings.warn - @classmethod - no package is available to open it diff --git a/.github/workflows/pythonpublish.yml b/.github/workflows/pythonpublish.yml index e385f04b..3732cbb7 100644 --- a/.github/workflows/pythonpublish.yml +++ b/.github/workflows/pythonpublish.yml @@ -1,5 +1,8 @@ -# This workflow will upload a Python Package using Twine when a release is created -# For more information see: https://help.github.com/en/actions/language-and-framework-guides/using-python-with-github-actions#publishing-to-package-registries +# Builds and publishes to PyPI when a GitHub release is created. +# Every build job runs without secrets. A single publish job, whose only permission is +# id-token: write, uploads all distributions via PyPI Trusted Publishing (OIDC), so no PyPI +# password or token is stored in GitHub: https://docs.pypi.org/trusted-publishers/ +# All actions are pinned to full commit SHAs; the comment shows the matching release tag. name: Upload Python Package @@ -7,85 +10,121 @@ on: release: types: [ created ] -jobs: - deploy-generic: +permissions: {} +jobs: + build-generic: runs-on: ubuntu-latest + timeout-minutes: 20 + permissions: + contents: read steps: - - uses: actions/checkout@v4 + - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1 + with: + persist-credentials: false - name: Set up Python - uses: actions/setup-python@v5 + uses: actions/setup-python@6d4fd22b20465ccc0f7354476588e8df7c9ca0e0 # v7.1.0 with: - python-version: '3.14' - - - name: Install Dependencies - run: | - python -m pip install --upgrade pip - pip install setuptools wheel twine --upgrade - + python-version: '3.15' - - name: Build and Publish - env: - TWINE_USERNAME: ${{ secrets.PYPI_USERNAME }} - TWINE_PASSWORD: ${{ secrets.PYPI_PASSWORD }} + - name: Install uv + uses: astral-sh/setup-uv@68559e99cc807c1eb7e9238fd43a15bba460eec2 # v10.3.3 + # Isolated build: Cython is not part of the build requirements, so this is the pure Python sdist and wheel + - name: Build and check run: | - python setup.py sdist bdist_wheel - twine upload dist/* + uv build + uvx twine==7.0.0 check dist/* - deploy-cython: + - name: Upload distribution artifact + uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2 + with: + name: dist-generic + path: dist/* + if-no-files-found: error + + build-cython: strategy: + fail-fast: false matrix: os: [macos-latest, windows-latest] - python-version: ["3.10", "3.11", "3.12", "3.13", "3.14"] + python-version: ["3.11", "3.12", "3.13", "3.14", "3.15"] runs-on: ${{ matrix.os }} + timeout-minutes: 30 + permissions: + contents: read steps: - - uses: actions/checkout@v4 + - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1 + with: + persist-credentials: false - name: Set up Python ${{ matrix.python-version }} - uses: actions/setup-python@v5 + id: setup-python + uses: actions/setup-python@6d4fd22b20465ccc0f7354476588e8df7c9ca0e0 # v7.1.0 with: python-version: ${{ matrix.python-version }} - - name: Install dependencies + - name: Install uv + uses: astral-sh/setup-uv@68559e99cc807c1eb7e9238fd43a15bba460eec2 # v10.3.3 + - name: Install build dependencies run: | - python -m pip install --upgrade pip - pip install setuptools wheel twine Cython>=3.0.11 --upgrade - - name: Build and publish - env: - TWINE_USERNAME: ${{ secrets.PYPI_USERNAME }} - TWINE_PASSWORD: ${{ secrets.PYPI_PASSWORD }} + uv venv --python "${{ steps.setup-python.outputs.python-path }}" + uv pip install "setuptools>=77" wheel "Cython>=3.3.1" + # No build isolation so the Cython installed above is used to build the compiled wheel + - name: Build and check run: | - python setup.py bdist_wheel - twine upload dist/* + uv build --wheel --no-build-isolation + uvx twine==7.0.0 check dist/* + - name: Upload wheel artifact + uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2 + with: + name: dist-cython-${{ matrix.os }}-${{ matrix.python-version }} + path: dist/*.whl + if-no-files-found: error - deploy-cython-manylinux: + build-cython-manylinux: runs-on: ubuntu-latest + timeout-minutes: 60 + permissions: + contents: read + steps: - - uses: actions/checkout@v4 - - name: Set up Python 3.13 - uses: actions/setup-python@v5 + - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1 with: - python-version: "3.13" + persist-credentials: false + - name: Install uv + uses: astral-sh/setup-uv@68559e99cc807c1eb7e9238fd43a15bba460eec2 # v10.3.3 + # Build targets and test commands are configured in [tool.cibuildwheel] in pyproject.toml - name: Build wheels - run: | - python -m pip install --upgrade pip - pip install cibuildwheel setuptools wheel - python -m cibuildwheel --output-dir dist - env: - CIBW_BUILD: cp310-manylinux_x86_64 cp311-manylinux_x86_64 cp312-manylinux_x86_64 cp313-manylinux_x86_64 - CIBW_BEFORE_BUILD: pip install Cython>=3.0.11 setuptools wheel - CIBW_BUILD_FRONTEND: "build; args: --no-isolation" - CIBW_BEFORE_TEST: pip install -r requirements.txt -r requirements-test.txt setuptools wheel twine Cython>=3.0.11 - CIBW_BUILD_VERBOSITY: 1 - CIBW_TEST_COMMAND: pytest {package}/test -vv - - - name: Publish - env: - TWINE_USERNAME: ${{ secrets.PYPI_USERNAME }} - TWINE_PASSWORD: ${{ secrets.PYPI_PASSWORD }} - run: | - pip install twine - twine upload dist/*-manylinux*.whl + run: uvx cibuildwheel==4.3.5 --output-dir dist + + - name: Upload wheel artifact + uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2 + with: + name: dist-cython-manylinux + path: dist/*-manylinux*.whl + if-no-files-found: error + + # Publishes only after every build succeeds, so a release is never left half uploaded + publish: + needs: [ build-generic, build-cython, build-cython-manylinux ] + runs-on: ubuntu-latest + timeout-minutes: 15 + environment: + name: pypi + url: https://pypi.org/p/python-box + permissions: + id-token: write # Required for Trusted Publishing; the only permission this job has + + steps: + - name: Download all distributions + uses: actions/download-artifact@37930b1c2abaa49bbe596cd826c3c89aef350131 # v7.0.0 + with: + pattern: dist-* + path: dist + merge-multiple: true + + - name: Publish to PyPI + uses: pypa/gh-action-pypi-publish@7245906fb61fa33a13554f9d5fb856fe61758086 # v1.14.3 diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml index e06da9a7..de1e3cfb 100644 --- a/.github/workflows/tests.yml +++ b/.github/workflows/tests.yml @@ -10,50 +10,80 @@ on: branches: [ master, development, develop, test, tests ] jobs: + lint: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1 + - name: Install uv + uses: astral-sh/setup-uv@68559e99cc807c1eb7e9238fd43a15bba460eec2 # v10.3.3 + with: + enable-cache: true + - name: Ruff lint + run: uvx ruff@0.17.3 check . + - name: Ruff format + run: uvx ruff@0.17.3 format --check . + + coverage: + # Pure Python on purpose: Cython compiled modules can't be traced by coverage + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v7 + - name: Set up Python + id: setup-python + uses: actions/setup-python@v7 + with: + python-version: "3.15" + - name: Install uv + uses: astral-sh/setup-uv@68559e99cc807c1eb7e9238fd43a15bba460eec2 # v10.3.3 + with: + enable-cache: true + - name: Install dependencies + run: uv sync --python "${{ steps.setup-python.outputs.python-path }}" --group test --no-install-project + - name: Require 100% line and branch coverage + run: uv run --no-sync pytest --cov=box --cov-branch --cov-report=term-missing --cov-fail-under=100 test/ + package-checks: strategy: matrix: - python-version: ["3.10", "3.11", "3.12", "3.13", "3.14", "pypy-3.11"] + python-version: ["3.11", "3.12", "3.13", "3.14", "3.15", "pypy-3.11"] os: [ubuntu-latest, macos-latest, windows-latest] runs-on: ${{ matrix.os }} steps: - - uses: actions/checkout@v4 + - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1 - name: Set up Python ${{ matrix.python-version }} - uses: actions/setup-python@v5 + id: setup-python + uses: actions/setup-python@6d4fd22b20465ccc0f7354476588e8df7c9ca0e0 # v7.1.0 with: python-version: ${{ matrix.python-version }} -# - uses: actions/cache@v3 -# with: -# path: ~/.cache/pip -# key: package-check-${{ hashFiles('requirements.txt') }}-${{ hashFiles('requirements-test.txt') }} + - name: Install uv + uses: astral-sh/setup-uv@68559e99cc807c1eb7e9238fd43a15bba460eec2 # v10.3.3 + with: + enable-cache: true - name: Install dependencies - run: | - python -m pip install --upgrade pip - pip install -r requirements.txt - pip install -r requirements-test.txt - pip install coveralls mypy setuptools wheel twine Cython>=3.0.11 + # Cython is part of the dev group, so the build below produces a compiled wheel + run: uv sync --python "${{ steps.setup-python.outputs.python-path }}" --group dev --no-install-project - name: Run mypy if: "!startsWith(matrix.python-version, 'pypy')" - run: mypy box - - name: Build Wheel and check distribution log description + run: uv run --no-sync mypy box + - name: Build sdist and wheel and check distribution log description run: | - python setup.py sdist bdist_wheel - twine check dist/* + uv build --no-build-isolation + uv run --no-sync twine check dist/* - name: Test packaged wheel on *nix if: matrix.os != 'windows-latest' run: | - pip install dist/*.whl + uv pip install --reinstall dist/*.whl rm -rf box - python -m pytest -vv + uv run --no-sync pytest -vv - name: Test packaged wheel on Windows if: matrix.os == 'windows-latest' run: | $wheel = (Get-ChildItem dist\*.whl | Sort lastWriteTime | Select-Object -last 1).Name - pip install dist\${wheel} + uv pip install --reinstall dist\${wheel} Remove-item box -recurse -force - python -m pytest -vv + uv run --no-sync pytest -vv - name: Upload wheel artifact - uses: actions/upload-artifact@v4 + uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2 with: name: python_box_${{matrix.os}}_${{ matrix.python-version }} path: dist/*.whl @@ -61,32 +91,17 @@ jobs: package-manylinux-checks: runs-on: ubuntu-latest steps: - - uses: actions/checkout@v4 - - name: Set up Python 3.13 - uses: actions/setup-python@v5 + - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1 + - name: Install uv + uses: astral-sh/setup-uv@68559e99cc807c1eb7e9238fd43a15bba460eec2 # v10.3.3 with: - python-version: "3.13" - -# - uses: actions/cache@v3 -# with: -# path: ~/.cache/pip -# key: package-manylinux-check-${{ hashFiles('requirements.txt') }}-${{ hashFiles('requirements-test.txt') }} - + enable-cache: true + # Build targets and test commands are configured in [tool.cibuildwheel] in pyproject.toml - name: Build wheels - run: | - python -m pip install --upgrade pip - pip install cibuildwheel - python -m cibuildwheel --output-dir dist - env: - CIBW_BUILD: cp310-manylinux_x86_64 cp311-manylinux_x86_64 cp312-manylinux_x86_64 cp313-manylinux_x86_64 - CIBW_BEFORE_BUILD: pip install Cython>=3.0.11 setuptools wheel - CIBW_BUILD_FRONTEND: "build; args: --no-isolation" - CIBW_BEFORE_TEST: pip install -r requirements.txt -r requirements-test.txt setuptools wheel twine Cython>=3.0.11 - CIBW_BUILD_VERBOSITY: 1 - CIBW_TEST_COMMAND: pytest {package}/test -vv + run: uvx cibuildwheel==4.3.5 --output-dir dist - name: Upload wheel artifact - uses: actions/upload-artifact@v4 + uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2 with: name: python_box_manylinux path: dist/*-manylinux*.whl @@ -94,28 +109,27 @@ jobs: test: strategy: matrix: - python-version: ["3.10", "3.11", "3.12", "3.13", "3.14"] + python-version: ["3.11", "3.12", "3.13", "3.14", "3.15"] os: [ubuntu-latest, macos-latest, windows-latest] runs-on: ${{ matrix.os }} steps: - - uses: actions/checkout@v4 + - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1 - name: Set up Python ${{ matrix.python-version }} - uses: actions/setup-python@v5 + id: setup-python + uses: actions/setup-python@6d4fd22b20465ccc0f7354476588e8df7c9ca0e0 # v7.1.0 with: python-version: ${{ matrix.python-version }} -# - uses: actions/cache@v3 -# with: -# path: ~/.cache/pip -# key: test-${{ hashFiles('requirements.txt') }}-${{ hashFiles('requirements-test.txt') }} + - name: Install uv + uses: astral-sh/setup-uv@68559e99cc807c1eb7e9238fd43a15bba460eec2 # v10.3.3 + with: + enable-cache: true - name: Install dependencies run: | - python -m pip install --upgrade pip - pip install -r requirements.txt - pip install -r requirements-test.txt - pip install setuptools wheel Cython>=3.0.11 - python setup.py build_ext --inplace + uv sync --python "${{ steps.setup-python.outputs.python-path }}" --group dev --no-install-project + # Editable install without build isolation compiles box in place using the Cython from the dev group + uv pip install -e . --no-build-isolation - name: Test with pytest env: GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} run: | - pytest --cov=box -vv test/ + uv run --no-sync pytest --cov=box -vv test/ diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index cee0904c..51f553f0 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -1,6 +1,6 @@ repos: - repo: https://github.com/pre-commit/pre-commit-hooks - rev: v5.0.0 + rev: v6.0.0 hooks: # Identify invalid files - id: check-ast @@ -16,8 +16,6 @@ repos: # Python checks - id: check-docstring-first - id: debug-statements - - id: requirements-txt-fixer - - id: fix-encoding-pragma - id: fix-byte-order-marker # General quality checks # - id: mixed-line-ending @@ -28,31 +26,25 @@ repos: - id: end-of-file-fixer exclude: ^test/data/.+ -- repo: https://github.com/ambv/black - rev: 24.10.0 +- repo: https://github.com/astral-sh/ruff-pre-commit + rev: v0.17.3 hooks: - - id: black - args: [--config=.black.toml] + - id: ruff-check + args: [--fix] + - id: ruff-format - repo: local hooks: - - id: cythonize-check - name: Cythonize - entry: pip install -e . - language: system - types: [python] - pass_filenames: false - # cythonize must come before the pytest to make sure we update all c code - id: pytest-check name: Check pytest - entry: pytest + entry: uv run --group test pytest language: system pass_filenames: false always_run: true - repo: https://github.com/pre-commit/mirrors-mypy - rev: 'v1.13.0' + rev: 'v2.4.1' hooks: - id: mypy types: [python] - additional_dependencies: [ruamel.yaml,toml,types-toml,tomli,tomli-w,msgpack,types-PyYAML] + additional_dependencies: [ruamel.yaml, tomli-w, msgpack, types-PyYAML, toon-format] diff --git a/AUTHORS.rst b/AUTHORS.rst index 6b44851e..2b5dbf4a 100644 --- a/AUTHORS.rst +++ b/AUTHORS.rst @@ -37,6 +37,26 @@ Code contributions: - Jesper Schlegel (jesperschlegel) - J vanBemmel (jbemmel) - m-janicki +- DSeaStar (DSeaStar) +- Guo Jiarui (Jerry-val) +- Abhinav Maurya (Fire162) +- Arindam Sikder (arindamsikder) +- shguild +- fhgffy +- AryanRG (AryanRG) +- Muneeb Sheikh (muneikh) +- Gary (gary1110086) +- Vitaliy Voloshin (vitalivo) +- x0Lazarus +- Huanyi Xie (xiehuanyi) +- Likio3000 +- koriyoshi2041 +- binggao1230 +- apoorvdarshan +- chuenchen309 +- machines-6657 (machines-6657) +- Chris (ChrisJr404) +- gyanu2507 (gyanu2507) Suggestions and bug reporting: @@ -98,3 +118,6 @@ Suggestions and bug reporting: - d00m514y3r - Sébastien Weber (seb5g) - Ward Loos (wrdls) +- bwanshoom +- tan_unique (vinson0522) +- lin (theman6660) diff --git a/CHANGES.rst b/CHANGES.rst index c4a347dd..e3801a3f 100644 --- a/CHANGES.rst +++ b/CHANGES.rst @@ -1,6 +1,75 @@ Changelog ========= +Version 8.0.0 +------------- + +Breaking changes + +* Box.popitem() now removes the most recently inserted item (LIFO) like dict.popitem(), instead of the first inserted item (thanks to machines-6657) +* Removing support for Python 3.10 as it is EOL, Python 3.11+ is now required +* merge_update now raises BoxValueError for an unrecognized box_merge_lists value instead of silently replacing the list +* Box.copy() / copy.copy() / copy.deepcopy() now return the same class as the original (subclasses of Box, ConfigBox, SBox and DDBox were previously turned into a plain Box / ConfigBox / SBox) +* ConfigBox string keys are now case-insensitive for every kind of access (not only attribute lookups), and a ConfigBox no longer holds keys that differ only by case: the latest write wins, keeping its value and spelling, so ConfigBox({'Foo': 1, 'foo': 2}) is ConfigBox({'foo': 2}) +* default_box_create_on_get now defaults to False (#262): looking up a missing key returns the default without storing it, so tools that probe attributes (IPython, Spyder) no longer add keys. Assigning through a missing key still creates it (box.a.b = 1). Changing a default value in place, such as box.tags.append(1) with default_box_attr=[], is no longer kept, pass default_box_create_on_get=True for the old behavior (thanks to wtld for reporting) +* to_yaml writes keys in insertion order with PyYAML and the ruamel safe / unsafe dumpers too (the default ruamel round trip dumper already did), pass sort_keys=True to sort them (#104, thanks to philipsd6 for reporting) +* Box options are no longer named parameters of Box.__new__ / Box.__init__, they are read from keyword arguments (behavior is the same, the type stubs still list them) +* DDBox options can now be overridden, e.g. DDBox(default_box=False) +* to_yaml now writes the comments of YAML loaded with ruamel.yaml's default round trip loader (#184), and get_comment, set_comment and del_comment are new protected key names +* Build and development tooling changed (see below): installing from an sdist now needs setuptools>=77, and building the Cython version from source requires --no-build-isolation + +Changes + +* Fixing #274 default_box_create_on_get=False not creating missing parent keys on assignment, e.g. box.a.b = 1 (thanks to gyanu2507 for the fix and wrdls for reporting) +* Adding #263 "merge" option for box_merge_lists to merge lists of dictionaries element by element (thanks to ChrisJr404) +* Adding #314 case-insensitive ConfigBox keys for [] access, in, del, update, merge_update and box_dots paths, matching configparser (thanks to binggao1230) +* Adding #184 comments on keys and list items: from_yaml keeps the comments of the document and to_yaml writes them back, and get_comment / set_comment / del_comment manage them on any Box or BoxList (thanks to philipsd6 for the request and michaelaye for the push) +* Adding #296 _box_defaults class attribute so subclasses can change Box option defaults without overriding __init__ (also #223, #210, thanks to marcelloromani, 12rambau and miversen33 for reporting) +* Adding #279 camel_killer_box_keep_keys to keep the original CamelCase keys and only add snake_case attribute aliases (thanks to jacobtomlinson for the suggestion) +* Adding #123 box_dots path segments made of digits also match integer keys, e.g. box['servers.2'] for {'servers': {2: ...}} (thanks to richieadler for reporting) +* Fixing ``in`` and get() returning False / None for box_dots paths through lists, e.g. 'a[0].x' in box, and ``in`` treating substrings of string values as keys ('a.b' in Box(a='xbz')) +* Fixing IndexError setting a box_dots key ending with a dot on a default_box +* Fixing AttributeError instead of BoxKeyError when setting to_msgpack, from_msgpack, to_toon or from_toon as attributes (now protected), and setting other non property class attributes +* Fixing frozen BoxList copy.deepcopy and pickle leaving the contained Boxes unfrozen +* Fixing unpickled BoxList re-creating its Boxes with default options (box_dots, box_class, default_box and so on were lost). BoxList pickles made by earlier versions still load +* Removing the tomli and toml read fallbacks, TOML is always read with tomllib (part of Python 3.11+). Writing still uses tomli-w, or the toml package if installed +* Fixing dict | Box and dict + Box returning a Box without the right side's options (box_dots, default_box, box_class and so on) +* Fixing default_box_attr with classes such as list, int or set raising an error, they now work like defaultdict factories (list gives a BoxList). Only required parameters of a default_box_attr function have to be named key or box_instance +* Fixing ConfigBox.bool treating "off" as True, it now matches the configparser false values +* Reaching 100% line and branch test coverage, enforced in CI +* Updating development dependencies to their latest versions (pytest 9, pytest-cov 7, mypy 2, twine 7, Cython 3.3.1, pre-commit-hooks 6) +* Fixing Box(default_box=True) pop() of a missing key and argparse namespaces (hasattr then delattr) with default_box_create_on_get=False +* Adding #269 internal-only attributes for Box subclasses via _box_internal_attrs (thanks to bwanshoom and gtkacz for the suggestion) +* Adding support for Python 3.15 +* Adding manylinux Cython wheels for Python 3.14 and 3.15 +* Fixing python_requires to match supported versions +* Updating GitHub Actions to latest major versions +* Fixing #260 nested boxes losing box_dots after pickle (thanks to DSeaStar) +* Fixing #265 unclear error for malformed BoxList bracket indices with box_dots (thanks to Arindam Sikder) +* Fixing #272 frozen_box with lists could not be serialized to YAML / JSON (thanks to apoorvdarshan) +* Fixing #300 CamelCase keys in dotted lookups with camel_killer_box (thanks to Guo Jiarui) +* Fixing #305 dotted keys lost with box_dots when a non-dotted key with the same prefix follows (thanks to J vanBemmel) +* Fixing #308 subclass of Box not preserved for nested boxes after unpickling (thanks to koriyoshi2041) +* Fixing #344 frozen BoxList instances could not be pickled (thanks to Abhinav Maurya) +* Fixing frozen BoxList could be mutated via clear, ``+=`` and ``*=`` (thanks to Vitaliy Voloshin) +* Fixing BoxList.__deepcopy__ not preserving box options (thanks to chuenchen309) +* Fixing second dotted write into an existing BoxList element discarding data (thanks to binggao1230) +* Fixing dicts and lists assigned to BoxList items and slices not being converted (thanks to x0Lazarus) +* Fixing dicts and lists added with BoxList ``+=`` not being converted (thanks to lin) +* Fixing BoxList.extend(self) revisiting its own appended values (thanks to x0Lazarus) +* Fixing BoxList construction testing the truth value of the iterable (thanks to fhgffy) +* Fixing BoxList to_json / from_json multiline not working with strings (thanks to shguild) +* Fixing explicit ensure_ascii option being ignored in JSON output (thanks to fhgffy) +* Fixing Box.pop with an explicit default creating missing values with default_box (thanks to Huanyi Xie) +* Fixing Box.update not accepting a positional source and keyword overrides together like dict.update (thanks to AryanRG) +* Fixing duplicate conversion check raising when re-assigning the same key (thanks to Muneeb Sheikh) +* Fixing deleted keys not releasing their converted attribute alias (thanks to Gary) +* Fixing Box.copy() (and copy.copy / copy.deepcopy) returning a plain Box, ConfigBox or SBox instead of the same subclass +* Moving package metadata from setup.py to pyproject.toml (PEP 621), setup.py now only handles the optional Cython build +* Moving development and CI to uv (dependency groups and uv.lock replace the requirements files) and ruff (replaces black) +* Fixing optional dependency installation examples in README (thanks to Likio3000) +* Fixing #264 ruamel.yaml ScalarFloat / ScalarInt / ScalarBoolean values left as non-builtin types after from_yaml, which broke libraries expecting float / int / bool (thanks to tan_unique) + Version 7.4.1 ------------- diff --git a/CONTRIBUTING.rst b/CONTRIBUTING.rst index 8792eec9..8a689d39 100644 --- a/CONTRIBUTING.rst +++ b/CONTRIBUTING.rst @@ -18,10 +18,46 @@ Reporting Bugs - Also include Python version and Operating System. +Development Setup +----------------- + +Box uses `uv `_ to manage the development environment, and +`ruff `_ for linting and formatting (line length 120, Black compatible style). +All project metadata and tool configuration lives in ``pyproject.toml``. + +.. code:: bash + + # create the environment (all test dependencies plus the dev tools) + uv sync --group dev + + # run the tests + uv run pytest + + # lint, format and type check + uv run ruff check --fix . + uv run ruff format . + uv run mypy box + + # optional: run the checks automatically before each commit + uv run pre-commit install + +To test the Cython compiled version, install the package in the environment without build isolation +(so the Cython from the ``dev`` group is used), then run the tests again: + +.. code:: bash + + uv pip install -e . --no-build-isolation + uv run --no-sync pytest + +Build the (pure Python) source distribution and wheel with ``uv build``, or the compiled wheel for your +platform with ``uv build --no-build-isolation``. + +When you change dependencies in ``pyproject.toml`` run ``uv lock`` and commit the updated ``uv.lock``. + Pull Requests ------------- -- Follow PEP8 +- Follow PEP8 (``ruff check`` and ``ruff format --check`` should pass) - Select to merge into `develop` branch, NOT `master` diff --git a/README.rst b/README.rst index 9fc9f31b..c5e71ac7 100644 --- a/README.rst +++ b/README.rst @@ -33,7 +33,7 @@ requirements.txt .. code:: text - python-box[all]~=7.0 + python-box[all]~=8.0 As Box adheres to semantic versioning (aka API changes will only occur on between major version), it is best to use `Compatible release `_ matching using the `~=` clause. @@ -44,7 +44,7 @@ Install from command line .. code:: bash python -m pip install --upgrade pip - pip install python-box[all]~=7.0 --upgrade + pip install "python-box[all]~=8.0" --upgrade Install with selected dependencies ---------------------------------- @@ -54,13 +54,14 @@ for example, `[all]` is shorthand for: .. code:: bash - pip install python-box[ruamel.yaml,tomli_w,msgpack]~=7.0 --upgrade + pip install "python-box[ruamel.yaml,toml,msgpack]~=8.0" --upgrade -But you can also sub out `ruamel.yaml` for `PyYAML`. +But you can also sub out `ruamel.yaml` for `PyYAML`. To use ``tomli-w`` for TOML output, +select the ``tomli`` extra instead of ``toml``. Check out `more details `_ on installation details. -Box 7 is tested on python 3.7+, if you are upgrading from previous versions, please look through +Box 8 is tested on python 3.11+, if you are upgrading from previous versions, please look through `any breaking changes and new features `_. Optimized Version @@ -71,17 +72,18 @@ Loading large data sets can be up to 10x faster! If you are **not** on a x86_64 supported system you will need to do some extra work to install the optimized version. There will be an warning of "WARNING: Cython not installed, could not optimize box" during install. -You will need python development files, system compiler, and the python packages `Cython` and `wheel`. +You will need python development files, system compiler, and the python packages `Cython`, `setuptools` and `wheel`. **Linux Example:** First make sure you have python development files installed (`python3-dev` or `python3-devel` in most repos). -You will then need `Cython` and `wheel` installed and then install (or re-install with `--force`) `python-box`. +You will then need `Cython`, `setuptools` and `wheel` installed and then install (or re-install with `--force`) `python-box`. +As Cython is not a build requirement, the build has to run without isolation so it can see your installed copy. .. code:: bash - pip install Cython wheel - pip install python-box[all]~=7.0 --upgrade --force + pip install Cython "setuptools>=77" wheel + pip install "python-box[all]~=8.0" --upgrade --force --no-binary python-box --no-build-isolation If you have any issues please open a github issue with the error you are experiencing! @@ -125,6 +127,42 @@ allowing for recursive dot notation access. `Box` also includes helper functions to transform it back into a `dict`, as well as into `JSON`, `YAML`, `TOML`, or `msgpack` strings or files. +Internal Attributes on Subclasses +--------------------------------- + +If you subclass `Box` and need attributes that are *not* part of the data (a source path, a cache, a +logger...), list their names in ``_box_internal_attrs``. Setting or deleting those names with attribute access +stores them on the instance, like a normal Python object, instead of in the dictionary. + +.. code:: python + + from box import Box + + class Config(Box): + _box_internal_attrs = ("source_path", "_cache") + + def __init__(self, *args, source_path=None, **kwargs): + super().__init__(*args, **kwargs) + self.source_path = source_path + self._cache = {} + + c = Config({"name": "app"}, source_path="/etc/app.yml") + c.source_path # '/etc/app.yml' + c.to_dict() # {'name': 'app'} + "source_path" in c # False + +Internal attributes are excluded from ``to_dict``, ``to_json``, ``to_yaml``, ``to_toml``, ``to_msgpack``, ``keys()``, +iteration, ``in``, ``len``, equality and hashing. They survive ``pickle``, and are carried over by ``copy()``, +``copy.copy`` (shared, shallow) and ``copy.deepcopy`` (deep copied). They can be set and deleted even on a +``frozen_box``, since they are not data. + +Things to keep in mind: + +* Nested boxes are created through your subclass (as `box_class` defaults to it), so every nested box gets its + own fresh internal attributes from ``__init__``, they are not shared with the parent. +* Only attribute access is affected. ``c["source_path"]`` still refers to the dictionary data, and if a data key + and an internal attribute share a name, attribute access returns the internal attribute. + Thanks ====== diff --git a/box/__init__.py b/box/__init__.py index 23ebd2e1..0f14c44b 100644 --- a/box/__init__.py +++ b/box/__init__.py @@ -2,7 +2,7 @@ # -*- coding: utf-8 -*- __author__ = "Chris Griffith" -__version__ = "7.4.1" +__version__ = "8.0.0" from box.box import Box from box.box_list import BoxList diff --git a/box/box.py b/box/box.py index 82526434..e1ce2047 100644 --- a/box/box.py +++ b/box/box.py @@ -5,6 +5,7 @@ """ Improved dictionary access through dot notation with additional tools. """ + from __future__ import annotations import copy @@ -14,26 +15,25 @@ from inspect import signature from keyword import iskeyword from os import PathLike -from typing import Any, Literal - +from typing import Any import box +from box import comments as _comments from box.converters import ( BOX_PARAMETERS, _from_json, _from_msgpack, _from_toml, _from_toon, - _from_yaml, + _from_yaml_with_comments, _to_json, _to_msgpack, _to_toml, _to_toon, - _to_yaml, msgpack_available, - toon_available, toml_read_library, toml_write_library, + toon_available, yaml_available, ) from box.exceptions import BoxError, BoxKeyError, BoxTypeError, BoxValueError, BoxWarning @@ -97,14 +97,32 @@ def _recursive_tuples(iterable, box_class, recreate_tuples=False, **kwargs): return tuple(out_list) -def _parse_box_dots(bx, item, setting=False): +def _to_native_tuple(iterable): + """Convert a tuple's Box/BoxList members back to native types. + + ``frozen_box`` stores lists as tuples of Boxes, so ``to_dict`` needs to + turn those nested Boxes back into plain dicts to remain serializable. + """ + out_list = [] + for i in iterable: + if isinstance(i, Box): + out_list.append(i.to_dict()) + elif isinstance(i, box.BoxList): + out_list.append(i.to_list()) + elif isinstance(i, tuple): + out_list.append(_to_native_tuple(i)) + else: + out_list.append(i) + return tuple(out_list) + + +def _parse_box_dots(bx, item): + """Split a box_dots key at its first "." or "[". Callers only pass keys that contain one.""" for idx, char in enumerate(item): if char == "[": return item[:idx], item[idx:] elif char == ".": return item[:idx], item[idx + 1 :] - if setting and "." in item: - return item.split(".", 1) raise BoxError("Could not split box dots properly") @@ -138,6 +156,49 @@ def _get_box_config(): } +#: Every Box option and its default. Subclasses can change these defaults with ``_box_defaults``. +BOX_OPTION_DEFAULTS: dict[str, Any] = { + "default_box": False, + "default_box_attr": NO_DEFAULT, + "default_box_none_transform": True, + "default_box_create_on_get": False, + "frozen_box": False, + "camel_killer_box": False, + "camel_killer_box_keep_keys": False, + "conversion_box": True, + "modify_tuples_box": False, + "box_safe_prefix": "x", + "box_duplicates": "ignore", + "box_intact_types": (), + "box_recast": None, + "box_dots": False, + "box_dots_exclude": None, + "box_class": None, + "box_namespace": (), +} + + +def _build_box_config(cls, kwargs: dict) -> dict: + """ + Build the box config for `cls`, removing the Box options from `kwargs` so only data keys remain. + + An option passed explicitly wins, then the class ``_box_defaults``, then ``BOX_OPTION_DEFAULTS``. + """ + options = {**BOX_OPTION_DEFAULTS, **cls._box_resolved_defaults} + for name in BOX_OPTION_DEFAULTS: + if name in kwargs: + options[name] = kwargs.pop(name) + config = _get_box_config() + config.update(options) + if config["default_box_attr"] is NO_DEFAULT: + config["default_box_attr"] = cls + if config["box_class"] is None: + config["box_class"] = cls + config["box_intact_types"] = tuple(config["box_intact_types"]) + config["box_dots_exclude"] = re.compile(config["box_dots_exclude"]) if config["box_dots_exclude"] else None + return config + + def _get_property_func(obj, key): """ Try to get property helper functions of given object and property name. @@ -146,11 +207,9 @@ def _get_property_func(obj, key): :param key: property name :return: a tuple for helper functions(fget, fset, fdel). If no such property, a (None, None, None) returns """ - obj_type = type(obj) - - if not hasattr(obj_type, key): + attr = getattr(type(obj), key, None) + if not isinstance(attr, property): return None, None, None - attr = getattr(obj_type, key) return attr.fget, attr.fset, attr.fdel @@ -162,9 +221,12 @@ class Box(dict): :param default_box_attr: Specify the default replacement. WARNING: If this is not the default 'Box', it will not be recursive :param default_box_none_transform: When using default_box, treat keys with none values as absent. True by default - :param default_box_create_on_get: On lookup of a key that doesn't exist, create it if missing + :param default_box_create_on_get: On lookup of a key that doesn't exist, also store the default value. + False by default: lookups never change the Box, assigning through a missing key still creates it :param frozen_box: After creation, the box cannot be modified :param camel_killer_box: Convert CamelCase to snake_case + :param camel_killer_box_keep_keys: With camel_killer_box, keep the original keys and only add + snake_case attribute aliases for them (needs conversion_box) :param conversion_box: Check for near matching keys as attributes :param modify_tuples_box: Recreate incoming tuples with dicts into Boxes :param box_safe_prefix: Conversion box prefix for unsafe attributes @@ -175,10 +237,25 @@ class Box(dict): :param box_dots_exclude: optional regular expression for dotted keys to exclude :param box_class: change what type of class sub-boxes will be created as :param box_namespace: the namespace this (possibly nested) Box lives within + + Subclasses may set ``_box_internal_attrs`` to a tuple of attribute names that are stored on + the instance instead of in the dict data (see ``_box_internal_attrs`` below). """ _box_config: dict[str, Any] + #: Names that subclasses can list to keep "internal-only" attributes. + #: Setting or deleting one of these names with attribute access stores it on the + #: instance (``object.__setattr__``) rather than in the dict data, so it is never + #: exported, iterated, compared or hashed. See the "Internal Attributes" docs. + _box_internal_attrs: tuple[str, ...] = () + + #: Box options this class uses when they are not passed explicitly, for example + #: ``_box_defaults = {"default_box": True}``. Subclasses inherit and extend them. + #: See the "Subclassing Box" docs. + _box_defaults: dict[str, Any] = {} + _box_resolved_defaults: dict[str, Any] = {} + _protected_keys = [ "to_dict", "to_json", @@ -187,103 +264,50 @@ class Box(dict): "from_json", "from_toml", "to_toml", + "to_msgpack", + "from_msgpack", + "to_toon", + "from_toon", "merge_update", + "get_comment", + "set_comment", + "del_comment", ] + [attr for attr in dir({}) if not attr.startswith("_")] - def __new__( - cls, - *args: Any, - default_box: bool = False, - default_box_attr: Any = NO_DEFAULT, - default_box_none_transform: bool = True, - default_box_create_on_get: bool = True, - frozen_box: bool = False, - camel_killer_box: bool = False, - conversion_box: bool = True, - modify_tuples_box: bool = False, - box_safe_prefix: str = "x", - box_duplicates: str = "ignore", - box_intact_types: tuple | list = (), - box_recast: dict | None = None, - box_dots: bool = False, - box_dots_exclude: str | None = None, - box_class: dict | type[Box] | None = None, - box_namespace: tuple[str, ...] | Literal[False] = (), - **kwargs: Any, - ): + def __init_subclass__(cls, **kwargs): + super().__init_subclass__(**kwargs) + own = cls.__dict__.get("_box_defaults", {}) + unknown = sorted(set(own) - set(BOX_OPTION_DEFAULTS)) + if unknown: + raise BoxError(f"Unknown Box options in {cls.__name__}._box_defaults: {', '.join(unknown)}") + # Merged along the inheritance chain, so a subclass only lists what it changes + cls._box_resolved_defaults = {**getattr(cls, "_box_resolved_defaults", {}), **own} + + def __new__(cls, *args: Any, **kwargs: Any): """ Due to the way pickling works in python 3, we need to make sure the box config is created as early as possible. """ + config = _build_box_config(cls, kwargs) obj = super().__new__(cls, *args, **kwargs) - obj._box_config = _get_box_config() - obj._box_config.update( - { - "default_box": default_box, - "default_box_attr": cls.__class__ if default_box_attr is NO_DEFAULT else default_box_attr, - "default_box_none_transform": default_box_none_transform, - "default_box_create_on_get": default_box_create_on_get, - "conversion_box": conversion_box, - "box_safe_prefix": box_safe_prefix, - "frozen_box": frozen_box, - "camel_killer_box": camel_killer_box, - "modify_tuples_box": modify_tuples_box, - "box_duplicates": box_duplicates, - "box_intact_types": tuple(box_intact_types), - "box_recast": box_recast, - "box_dots": box_dots, - "box_dots_exclude": re.compile(box_dots_exclude) if box_dots_exclude else None, - "box_class": box_class if box_class is not None else Box, - "box_namespace": box_namespace, - } - ) + obj._box_config = config + # Pickle reconstructs via __new__ + item assignment + __setstate__. + # Item assignment happens first, while this Box still has default options, + # so nested Box/BoxList values must be stored as-is (see __convert_and_store). + obj._box_config["__unpickling"] = True return obj - def __init__( - self, - *args: Any, - default_box: bool = False, - default_box_attr: Any = NO_DEFAULT, - default_box_none_transform: bool = True, - default_box_create_on_get: bool = True, - frozen_box: bool = False, - camel_killer_box: bool = False, - conversion_box: bool = True, - modify_tuples_box: bool = False, - box_safe_prefix: str = "x", - box_duplicates: str = "ignore", - box_intact_types: tuple | list = (), - box_recast: dict | None = None, - box_dots: bool = False, - box_dots_exclude: str | None = None, - box_class: dict | type[Box] | None = None, - box_namespace: tuple[str, ...] | Literal[False] = (), - **kwargs: Any, - ): + def __init__(self, *args: Any, **kwargs: Any): super().__init__() - self._box_config = _get_box_config() - self._box_config.update( - { - "default_box": default_box, - "default_box_attr": self.__class__ if default_box_attr is NO_DEFAULT else default_box_attr, - "default_box_none_transform": default_box_none_transform, - "default_box_create_on_get": default_box_create_on_get, - "conversion_box": conversion_box, - "box_safe_prefix": box_safe_prefix, - "frozen_box": frozen_box, - "camel_killer_box": camel_killer_box, - "modify_tuples_box": modify_tuples_box, - "box_duplicates": box_duplicates, - "box_intact_types": tuple(box_intact_types), - "box_recast": box_recast, - "box_dots": box_dots, - "box_dots_exclude": re.compile(box_dots_exclude) if box_dots_exclude else None, - "box_class": box_class if box_class is not None else self.__class__, - "box_namespace": box_namespace, - } - ) + self._box_config = _build_box_config(self.__class__, kwargs) if not self._box_config["conversion_box"] and self._box_config["box_duplicates"] != "ignore": raise BoxError("box_duplicates are only for conversion_boxes") + if ( + self._box_config["camel_killer_box_keep_keys"] + and self._box_config["camel_killer_box"] + and not self._box_config["conversion_box"] + ): + raise BoxError("camel_killer_box_keep_keys needs conversion_box, it provides the snake_case aliases") if len(args) == 1: if isinstance(args[0], str): raise BoxValueError("Cannot extrapolate Box from string") @@ -299,6 +323,8 @@ def __init__( self.__setitem__(k, v) else: raise BoxValueError("First argument must be mapping or iterable") + if isinstance(args[0], Box): + args[0]._comment_copy_to(self) elif args: raise BoxTypeError(f"Box expected at most 1 argument, got {len(args)}") @@ -320,13 +346,18 @@ def __radd__(self, other: Mapping[Any, Any]): if not isinstance(other, dict): raise BoxTypeError("Box can only merge two boxes or a box and a dictionary.") - new_box = other.copy() - if not isinstance(other, Box): - new_box = self._box_config["box_class"](new_box) + new_box = other.copy() if isinstance(other, Box) else self.__new_from_plain(other) new_box.merge_update(self, _force_unfrozen=True) # type: ignore[attr-defined] new_box._box_config["frozen_box"] = self._box_config["frozen_box"] # type: ignore[attr-defined] return new_box + def __new_from_plain(self, other): + """A Box of this box's class and options (unfrozen, top level) holding a plain dict's data""" + config = self.__box_config() + config["frozen_box"] = False + config.pop("box_namespace") + return self._box_config["box_class"](other, **config) + def __iadd__(self, other: Mapping[Any, Any]): if not isinstance(other, dict): raise BoxTypeError("Box can only merge two boxes or a box and a dictionary.") @@ -345,9 +376,7 @@ def __or__(self, other: Mapping[Any, Any]): def __ror__(self, other: Mapping[Any, Any]): if not isinstance(other, dict): raise BoxTypeError("Box can only merge two boxes or a box and a dictionary.") - new_box = other.copy() - if not isinstance(other, Box): - new_box = self._box_config["box_class"](new_box) + new_box = other.copy() if isinstance(other, Box) else self.__new_from_plain(other) new_box._box_config["frozen_box"] = False # type: ignore[attr-defined] new_box.update(self) # type: ignore[attr-defined] new_box._box_config["frozen_box"] = self._box_config["frozen_box"] # type: ignore[attr-defined] @@ -395,8 +424,9 @@ def __dir__(self) -> list[str]: if key.isidentifier() and not iskeyword(key): items.add(key) + keep_keys = self._box_config["camel_killer_box_keep_keys"] and self._box_config["camel_killer_box"] for key in self.keys(): - if key not in items: + if key not in items or keep_keys: if self._box_config["conversion_box"]: key = self._safe_attr(key) if key: @@ -410,17 +440,24 @@ def __contains__(self, item): return in_me if in_me: return True - if "." not in item: + if not self.__process_dotted_key(item): return False - try: - first_item, children = _parse_box_dots(self, item) - except BoxError: + first_item, children = _parse_box_dots(self, item) + first_item = self.__dots_int_key(first_item) + if not super().__contains__(first_item): return False - else: - if not super().__contains__(first_item): + it = self[first_item] + if isinstance(it, Box): + return it.__dots_int_key(children) in it + if isinstance(it, box.BoxList): + # children is the rest of the path starting with "[", e.g. "[0].x" + try: + it.__getitem__(children, _ignore_default=True) + except (KeyError, IndexError, TypeError): return False - it = self[first_item] - return isinstance(it, Iterable) and children in it + return True + # Other values (strings, numbers) are not traversed by box_dots lookups either + return False def keys(self, dotted: bool = False): if not dotted: @@ -468,29 +505,63 @@ def get(self, key, default=NO_DEFAULT): return default return self[key] - def copy(self) -> Box: + def __copy_internals(self, new, deep=False, memo=None): + """Carry instance-only attributes listed in `_box_internal_attrs`, and comments, over to `new`.""" + self._comment_copy_to(new) + for name in self._box_internal_attrs: + if name in self.__dict__: + value = self.__dict__[name] + object.__setattr__(new, name, copy.deepcopy(value, memo) if deep else value) + return new + + def copy(self): config = self.__box_config() config.pop("box_namespace") # Detach namespace; it will be reassigned if we nest again - return Box(super().copy(), **config) + return self.__copy_internals(self.__class__(super().copy(), **config)) - def __copy__(self) -> Box: + def __copy__(self): return self.copy() - def __deepcopy__(self, memodict=None) -> Box: + def __deepcopy__(self, memodict=None): frozen = self._box_config["frozen_box"] config = self.__box_config() config["frozen_box"] = False - out = self._box_config["box_class"](**config) - memodict = memodict or {} + out = self.__class__(**config) + memodict = memodict if memodict is not None else {} memodict[id(self)] = out for k, v in self.items(): out[copy.deepcopy(k, memodict)] = copy.deepcopy(v, memodict) + self.__copy_internals(out, deep=True, memo=memodict) out._box_config["frozen_box"] = frozen return out def __setstate__(self, state): self._box_config = state["_box_config"] self.__dict__.update(state) + self._box_config["__created"] = True + self._box_config["__unpickling"] = False + + def __dots_int_key(self, item): + """ + A segment of a box_dots path made of digits also matches the int key with that value, so + "a.2" reaches {"a": {2: ...}} (#123). Only used for path segments, a str key of the same + value wins, and plain (non dotted) keys are never mapped. + """ + if ( + self._box_config["box_dots"] + and isinstance(item, str) + and item.isascii() + and item.lstrip("-").isdigit() + and not dict.__contains__(self, item) + ): + as_int = int(item) + if dict.__contains__(self, as_int): + return as_int + return item + + def __camel_destructive(self): + """camel_killer_box renames keys to snake_case unless camel_killer_box_keep_keys is set""" + return self._box_config["camel_killer_box"] and not self._box_config["camel_killer_box_keep_keys"] def __process_dotted_key(self, item): if self._box_config["box_dots"] and isinstance(item, str): @@ -500,7 +571,7 @@ def __process_dotted_key(self, item): ) return False - def __get_default(self, item, attr=False): + def __get_default(self, item): if item in ("getdoc", "shape") and _is_ipython(): return None default_value = self._box_config["default_box_attr"] @@ -508,47 +579,54 @@ def __get_default(self, item, attr=False): value = self._box_config["box_class"](**self.__box_config(extra_namespace=item)) elif isinstance(default_value, dict): value = self._box_config["box_class"](**self.__box_config(extra_namespace=item), **default_value) - elif isinstance(default_value, list): + elif isinstance(default_value, list) or default_value is list: value = box.BoxList(**self.__box_config(extra_namespace=item)) elif isinstance(default_value, Callable): + # Parameters named key / box_instance receive the missing key and this box. Any other + # parameter must be optional, so plain factories such as int, set or a lambda work too. args = [] kwargs = {} - p_sigs = [ - p.name - for p in signature(default_value).parameters.values() - if p.kind in (p.POSITIONAL_ONLY, p.POSITIONAL_OR_KEYWORD) - ] - k_sigs = [p.name for p in signature(default_value).parameters.values() if p.kind is p.KEYWORD_ONLY] - for name in p_sigs: - if name not in ("key", "box_instance"): - raise BoxError("default_box_attr can only have the arguments 'key' and 'box_instance'") - if "key" in p_sigs: - args.append(item) - if "box_instance" in p_sigs: - args.insert(p_sigs.index("box_instance"), self) - if "key" in k_sigs: - kwargs["key"] = item - if "box_instance" in k_sigs: - kwargs["box_instance"] = self + try: + params = list(signature(default_value).parameters.values()) + except (TypeError, ValueError): # pragma: no cover (callables without a readable signature) + params = [] + for param in params: + if param.kind in (param.VAR_POSITIONAL, param.VAR_KEYWORD): + continue + if param.name in ("key", "box_instance"): + passed = item if param.name == "key" else self + if param.kind is param.POSITIONAL_ONLY: + args.append(passed) + else: + kwargs[param.name] = passed + elif param.default is param.empty: + raise BoxError( + "default_box_attr can only have the required arguments 'key' and 'box_instance', " + f"not {param.name!r}" + ) value = default_value(*args, **kwargs) elif hasattr(default_value, "copy"): value = default_value.copy() else: value = default_value if self._box_config["default_box_create_on_get"]: - if not attr or not (item.startswith("_") and item.endswith("_")): - if self.__process_dotted_key(item): - first_item, children = _parse_box_dots(self, item, setting=True) - if first_item in self.keys(): - if hasattr(self[first_item], "__setitem__"): - self[first_item].__setitem__(children, value) - else: - super().__setitem__( - first_item, self._box_config["box_class"](**self.__box_config(extra_namespace=first_item)) - ) - self[first_item].__setitem__(children, value) - else: - super().__setitem__(item, value) + if self.__process_dotted_key(item): + first_item, children = _parse_box_dots(self, item) + # An existing first_item only gets here when its value can't be looked into + # (for example an int), so there is nowhere to store the default + if first_item not in self.keys(): + self._flush_pending_parent() + super().__setitem__( + first_item, self._box_config["box_class"](**self.__box_config(extra_namespace=first_item)) + ) + self[first_item].__setitem__(children, value) + else: + super().__setitem__(item, value) + elif isinstance(value, Box) and not self.__process_dotted_key(item): + # Lookups stay ephemeral, but a later assignment on this child + # should create the missing parent keys (see _flush_pending_parent). + # A strong reference is required: intermediate ephemeral parents are otherwise garbage collected. + value._box_config["__pending_parent"] = (self, item) return value def __box_config(self, extra_namespace: Any = NO_NAMESPACE) -> dict: @@ -573,6 +651,7 @@ def __recast(self, item, value): return value def __convert_and_store(self, item, value): + self._flush_pending_parent() if self._box_config["conversion_box"]: safe_key = self._safe_attr(item) self._box_config["__safe_keys"][safe_key] = item @@ -581,8 +660,27 @@ def __convert_and_store(self, item, value): # If the value has already been converted or should not be converted, return it as-is if self._box_config["box_intact_types"] and isinstance(value, self._box_config["box_intact_types"]): return super().__setitem__(item, value) + # Pickle sets items before __setstate__, so this Box still has default + # options. Nested Box/BoxList objects already carry the correct config + # from their own unpickle; recreating them here would drop box_dots etc. + if self._box_config.get("__unpickling") and isinstance(value, (Box, box.BoxList)): + return super().__setitem__(item, value) # This is the magic sauce that makes sub dictionaries into new box objects if isinstance(value, dict): + # If box_dots is enabled and the key already exists as a Box (possibly created from dotted keys), + # merge the new dict into the existing Box instead of overwriting it + # This fixes issue #305 where dotted keys are lost when a non-dotted key with the same prefix comes after + if ( + self._box_config["box_dots"] + and item in self + and isinstance(self[item], Box) + and not self._box_config["__created"] + ): + # Merge the new dict into the existing Box by setting each key-value pair + # This ensures proper conversion of nested structures + for k, v in value.items(): + self[item].__setitem__(k, v) + return # We always re-create even if it was already a Box object to pass down configurations correctly value = self._box_config["box_class"](value, **self.__box_config(extra_namespace=item)) elif isinstance(value, list) and not isinstance(value, box.BoxList): @@ -614,16 +712,19 @@ def __getitem__(self, item, _ignore_default=False): new_box[x] = self[x] return new_box if self.__process_dotted_key(item): - try: - first_item, children = _parse_box_dots(self, item) - except BoxError: - if self._box_config["default_box"] and not _ignore_default: - return self.__get_default(item) - raise BoxKeyError(str(item)) from _exception_cause(err) + first_item, children = _parse_box_dots(self, item) + first_item = self.__dots_int_key(first_item) + if first_item not in self.keys() and self.__camel_destructive(): + first_item = _camel_killer(first_item) if first_item in self.keys(): - if hasattr(self[first_item], "__getitem__"): - return self[first_item][children] - if self._box_config["camel_killer_box"] and isinstance(item, str): + child = self[first_item] + if isinstance(child, Box): + children = child.__dots_int_key(children) + if hasattr(child, "__getitem__"): + if _ignore_default and isinstance(child, (Box, box.BoxList)): + return child.__getitem__(children, _ignore_default=True) + return child[children] + if self.__camel_destructive() and isinstance(item, str): converted = _camel_killer(item) if converted in self.keys(): return super().__getitem__(converted) @@ -631,7 +732,7 @@ def __getitem__(self, item, _ignore_default=False): return self.__get_default(item) raise BoxKeyError(str(err)) from _exception_cause(err) except TypeError as err: - if isinstance(item, slice): + if isinstance(item, slice): # pragma: no cover (Python 3.11, slices became hashable in 3.12) new_box = self._box_config["box_class"](**self.__box_config()) for x in list(super().keys())[item.start : item.stop : item.step]: new_box[x] = self[x] @@ -645,8 +746,6 @@ def __getattr__(self, item): except KeyError: value = object.__getattribute__(self, item) except AttributeError as err: - if item == "__getstate__": - raise BoxKeyError(item) from _exception_cause(err) if item == "_box_config": raise BoxError("_box_config key must exist") from _exception_cause(err) if self._box_config["conversion_box"]: @@ -656,20 +755,132 @@ def __getattr__(self, item): if self._box_config["default_box"]: if item.startswith("_") and item.endswith("_"): raise BoxKeyError(f"{item}: Does not exist and internal methods are never defaulted") - return self.__get_default(item, attr=True) + return self.__get_default(item) raise BoxKeyError(str(err)) from _exception_cause(err) return value + def _flush_pending_parent(self): + """ + With `default_box_create_on_get=False` a missing key returns an ephemeral child Box that is + not stored in its parent. The first time something is actually written to that child, attach it + (and any ephemeral ancestors) to the parent so `b.a.b = 1` creates `a`. + + Nothing is attached if the key has been given a real value since the child was handed out: + the stale child is left detached rather than overwriting data, so writes to it are lost + just like any other ephemeral lookup. + """ + pending = self._box_config.pop("__pending_parent", None) + if pending is None: + return + parent, key = pending + parent._flush_pending_parent() + if dict.__contains__(parent, key): + return + if parent._box_config["frozen_box"] and parent._box_config["__created"]: + raise BoxError("Box is frozen") + if parent._box_config["conversion_box"]: + parent._box_config["__safe_keys"][parent._safe_attr(key)] = key + dict.__setitem__(parent, key, self) + + def _comment_store(self, create: bool = True) -> Any: + store = self._box_config.get("__comments") + if store is None and create: + store = self._box_config["__comments"] = {} + return store + + def _comment_document(self, create: bool = True) -> Any: + document = self._box_config.get("__comments_document") + if document is None and create: + document = self._box_config["__comments_document"] = {} + return document + + def _comment_check_frozen(self): + if self._box_config["frozen_box"] and self._box_config["__created"]: + raise BoxError("Box is frozen") + + def _comment_resolve(self, key): + """The stored key a key from YAML or the comment API refers to (camel_killer renames keys).""" + if dict.__contains__(self, key): + return key + if isinstance(key, str) and self.__camel_destructive(): + converted = _camel_killer(key) + if dict.__contains__(self, converted): + return converted + return key + + def _comment_owner(self, key): + """(container, key) that holds the comment for `key`, following box_dots paths.""" + if key is None: + return self, None + resolved = self._comment_resolve(key) + if dict.__contains__(self, resolved): + return self, resolved + if self.__process_dotted_key(key): + first, children = _parse_box_dots(self, key) + first = self._comment_resolve(self.__dots_int_key(first)) + if dict.__contains__(self, first): + child = dict.__getitem__(self, first) + if isinstance(child, Box): + return child._comment_owner(child.__dots_int_key(children)) + if isinstance(child, box.BoxList): + return child._comment_owner(children) + raise BoxKeyError(f"{key!r} is not in the Box, comments can only be attached to existing keys") + + def _comment_copy_to(self, other): + store = self._box_config.get("__comments") + if store: + other._comment_store().update( + {k: copy.deepcopy(v) for k, v in store.items() if dict.__contains__(other, k)} + ) + document = self._box_config.get("__comments_document") + if document: + other._comment_document().update(copy.deepcopy(document)) + + # ---- Comments (#184): kept outside the data, written by to_yaml with ruamel.yaml ---- + + def get_comment(self, key: Any = None) -> dict | None: + """ + Return the comments of `key` as ``{"before": text, "eol": text}`` (a position without a comment + is left out), or None. ``key=None`` returns the document comments ``{"start": ..., "end": ...}``. + With box_dots, `key` can be a dotted path. + """ + return _comments.get_comment(self, key) + + def set_comment(self, key: Any, text: Any, position: str | None = None) -> None: + """ + Attach a comment to an existing key. `position` is "eol" (default, on the key's line) or + "before" (lines above the key, may contain newlines). ``key=None`` sets a document comment, + position "start" (default) or "end". An empty `text` removes the comment at that position. + """ + _comments.set_comment(self, key, text, position) + + def del_comment(self, key: Any = None) -> None: + """Remove every comment of `key` (``None``: the document comments).""" + _comments.del_comment(self, key) + + def __getstate__(self): + # Ephemeral-child bookkeeping (a reference to the parent) must never be pickled + state = self.__dict__.copy() + config = state.get("_box_config") + if config is not None and "__pending_parent" in config: + state["_box_config"] = {k: v for k, v in config.items() if k != "__pending_parent"} + return state + def __setitem__(self, key, value): if key != "_box_config" and self._box_config["frozen_box"] and self._box_config["__created"]: raise BoxError("Box is frozen") if self.__process_dotted_key(key): - first_item, children = _parse_box_dots(self, key, setting=True) + first_item, children = _parse_box_dots(self, key) + first_item = self.__dots_int_key(first_item) if first_item in self.keys(): - if hasattr(self[first_item], "__setitem__"): - return self[first_item].__setitem__(children, value) + child = self[first_item] + if isinstance(child, Box): + children = child.__dots_int_key(children) + if hasattr(child, "__setitem__"): + return child.__setitem__(children, value) elif self._box_config["default_box"]: - if children[0] == "[": + self._flush_pending_parent() + if children.startswith("["): super().__setitem__(first_item, box.BoxList(**self.__box_config(extra_namespace=first_item))) else: super().__setitem__( @@ -679,8 +890,8 @@ def __setitem__(self, key, value): else: raise BoxKeyError(f"'{self.__class__}' object has no attribute {first_item}") value = self.__recast(key, value) - if key not in self.keys() and self._box_config["camel_killer_box"]: - if self._box_config["camel_killer_box"] and isinstance(key, str): + if key not in self.keys() and self.__camel_destructive(): + if isinstance(key, str): key = _camel_killer(key) if self._box_config["conversion_box"] and self._box_config["box_duplicates"] != "ignore": self._conversion_checks(key) @@ -689,6 +900,8 @@ def __setitem__(self, key, value): def __setattr__(self, key, value): if key == "_box_config": return object.__setattr__(self, key, value) + if key in self._box_internal_attrs: + return object.__setattr__(self, key, value) if self._box_config["frozen_box"] and self._box_config["__created"]: raise BoxError("Box is frozen") if key in self._protected_keys: @@ -708,14 +921,15 @@ def __delitem__(self, key): if self._box_config["frozen_box"]: raise BoxError("Box is frozen") if key not in self.keys() and self.__process_dotted_key(key): - try: - first_item, children = _parse_box_dots(self, key) - except BoxError: - raise BoxKeyError(str(key)) from None - if hasattr(self[first_item], "__delitem__"): - return self[first_item].__delitem__(children) - if key not in self.keys() and self._box_config["camel_killer_box"]: - if self._box_config["camel_killer_box"] and isinstance(key, str): + first_item, children = _parse_box_dots(self, key) + first_item = self.__dots_int_key(first_item) + child = self[first_item] + if isinstance(child, Box): + children = child.__dots_int_key(children) + if hasattr(child, "__delitem__"): + return child.__delitem__(children) + if key not in self.keys() and self.__camel_destructive(): + if isinstance(key, str): for each_key in self: if _camel_killer(key) == each_key: key = each_key @@ -724,8 +938,18 @@ def __delitem__(self, key): super().__delitem__(key) except KeyError as err: raise BoxKeyError(str(err)) from _exception_cause(err) + store = self._box_config.get("__comments") + if store: + store.pop(key, None) + if self._box_config["conversion_box"]: + safe_key = self._safe_attr(key) + safe_keys = self._box_config["__safe_keys"] + if safe_key in safe_keys and safe_keys[safe_key] == key: + del safe_keys[safe_key] def __delattr__(self, item): + if item in self._box_internal_attrs: + return object.__delattr__(self, item) if self._box_config["frozen_box"]: raise BoxError("Box is frozen") if item == "_box_config": @@ -746,8 +970,11 @@ def __delattr__(self, item): safe_key = self._safe_attr(item) if safe_key in self._box_config["__safe_keys"]: self.__delitem__(self._box_config["__safe_keys"][safe_key]) - del self._box_config["__safe_keys"][safe_key] return + if self._box_config["default_box"] and not self._box_config["default_box_create_on_get"]: + # Every attribute of a default_box looks present (hasattr is True) without being + # stored, so deleting a missing one is a no-op. argparse.parse_args relies on this. + return raise BoxKeyError(str(err)) from _exception_cause(err) def pop(self, key, *args): @@ -758,7 +985,7 @@ def pop(self, key, *args): if len(args) != 1: raise BoxError('pop() takes only one optional argument "default"') try: - item = self[key] + item = self.__getitem__(key, _ignore_default=True) except KeyError: return args[0] else: @@ -769,7 +996,9 @@ def pop(self, key, *args): except KeyError: raise BoxKeyError(f"{key}") from None else: - del self[key] + if key in self: + del self[key] + # else: a default_box returned a default without storing it, there is nothing to remove return item def clear(self): @@ -777,12 +1006,13 @@ def clear(self): raise BoxError("Box is frozen") super().clear() self._box_config["__safe_keys"].clear() + self._box_config.pop("__comments", None) def popitem(self): if self._box_config["frozen_box"]: raise BoxError("Box is frozen") try: - key = next(self.__iter__()) + key = next(reversed(super().keys())) # O(1), most recently inserted like dict except StopIteration: raise BoxKeyError("Empty box") from None return key, self.pop(key) @@ -815,13 +1045,15 @@ def to_dict(self) -> dict: out_dict[k] = v.to_dict() elif isinstance(v, box.BoxList): out_dict[k] = v.to_list() + elif isinstance(v, tuple): + out_dict[k] = _to_native_tuple(v) return out_dict def update(self, *args, **kwargs): if self._box_config["frozen_box"]: raise BoxError("Box is frozen") - if (len(args) + int(bool(kwargs))) > 1: - raise BoxTypeError(f"update expected at most 1 argument, got {len(args) + int(bool(kwargs))}") + if len(args) > 1: + raise BoxTypeError(f"update expected at most 1 argument, got {len(args)}") single_arg = next(iter(args), None) if single_arg: if hasattr(single_arg, "keys"): @@ -834,9 +1066,40 @@ def update(self, *args, **kwargs): self.__convert_and_store(k, kwargs[k]) def merge_update(self, *args, **kwargs): + """ + Recursively update the Box, merging nested dictionaries instead of + overwriting them like the built-in ``dict.update``. + + The ``box_merge_lists`` keyword controls how lists sharing a key are + combined: + + * ``None`` (default) - the incoming list replaces the existing one + * ``"extend"`` - the incoming items are appended to the existing list + * ``"unique"`` - only incoming items not already present are appended + * ``"merge"`` - lists are merged element by element, recursing into + dictionaries that share the same index so their keys are combined. + Lists nested directly inside lists are merged the same way, any other + value at a shared index is replaced by the incoming one, and extra + incoming elements are appended. If the existing value is not a list, + the incoming list simply replaces it. + + Any other value raises ``BoxValueError``. Note that merging is done in place + and is not atomic, if an error is raised (for example the Box is frozen) + part of the update may already have been applied. + + .. code-block:: python + + box_one = Box({"data": [{"a": 1}, {"b": 2}]}) + box_one.merge_update({"data": [{"c": 3}]}, box_merge_lists="merge") + # Box({'data': [{'a': 1, 'c': 3}, {'b': 2}]}) + + :param box_merge_lists: strategy used to merge lists, see above + """ merge_type = None if "box_merge_lists" in kwargs: merge_type = kwargs.pop("box_merge_lists") + if merge_type not in (None, False, "extend", "unique", "merge"): + raise BoxValueError(f'box_merge_lists must be None, "extend", "unique" or "merge", got {merge_type!r}') force_unfrozen = kwargs.pop("_force_unfrozen", False) was_frozen = self._box_config["frozen_box"] @@ -845,6 +1108,22 @@ def merge_update(self, *args, **kwargs): try: + def merge_lists(target, incoming): + # Element by element: dicts at the same index are merged recursively, lists at the + # same index are merged the same way, anything else is replaced by the incoming + # value, and incoming elements beyond the end of `target` are appended. + for index, item in enumerate(incoming): + if index >= len(target): + target.append(item) + continue + current = target[index] + if isinstance(current, Box) and isinstance(item, dict): + current.merge_update(item, box_merge_lists=merge_type, _force_unfrozen=force_unfrozen) + elif isinstance(current, list) and isinstance(item, list): + merge_lists(current, item) + else: + target[index] = item + def convert_and_set(k, v): intact_type = self._box_config["box_intact_types"] and isinstance( v, self._box_config["box_intact_types"] @@ -866,6 +1145,9 @@ def convert_and_set(k, v): if item not in self[k]: self[k].append(item) return + if merge_type == "merge" and k in self and isinstance(self[k], list): + merge_lists(self[k], v) + return self.__setitem__(k, v) if (len(args) + int(bool(kwargs))) > 1: @@ -890,10 +1172,6 @@ def setdefault(self, item, default=None): if item in self: return self[item] - if self._box_config["box_dots"]: - if item in _get_dot_paths(self): - return self[item] - if isinstance(default, dict): default = self._box_config["box_class"](default, **self.__box_config(extra_namespace=item)) if isinstance(default, list): @@ -903,6 +1181,10 @@ def setdefault(self, item, default=None): def _safe_attr(self, attr): """Convert a key into something that is accessible as an attribute""" + if self._box_config["camel_killer_box_keep_keys"] and self._box_config["camel_killer_box"]: + # Keys keep their spelling, the attribute alias is the snake_case form + if isinstance(attr, str): + attr = _camel_killer(attr) if isinstance(attr, str): # By assuming most people are using string first we get substantial speed ups if attr.isidentifier() and not iskeyword(attr): @@ -919,7 +1201,7 @@ def _safe_attr(self, attr): return attr if sum(1 for character in attr if character.isidentifier() and not iskeyword(character)) == 0: - attr = f'{self.__box_config()["box_safe_prefix"]}{attr}' + attr = f"{self.__box_config()['box_safe_prefix']}{attr}" if attr.isidentifier() and not iskeyword(attr): return attr @@ -942,10 +1224,10 @@ def _safe_attr(self, attr): except (ValueError, IndexError): pass else: - out = f'{self.__box_config()["box_safe_prefix"]}{out}' + out = f"{self.__box_config()['box_safe_prefix']}{out}" if iskeyword(out): - out = f'{self.__box_config()["box_safe_prefix"]}{out}' + out = f"{self.__box_config()['box_safe_prefix']}{out}" return out @@ -957,8 +1239,8 @@ def _conversion_checks(self, item): """ safe_item = self._safe_attr(item) - if safe_item in self._box_config["__safe_keys"]: - dups = [f"{item}({safe_item})", f'{self._box_config["__safe_keys"][safe_item]}({safe_item})'] + if safe_item in self._box_config["__safe_keys"] and self._box_config["__safe_keys"][safe_item] != item: + dups = [f"{item}({safe_item})", f"{self._box_config['__safe_keys'][safe_item]}({safe_item})"] if self._box_config["box_duplicates"].startswith("warn"): warnings.warn(f"Duplicate conversion attributes exist: {dups}", BoxWarning) else: @@ -1032,10 +1314,12 @@ def to_yaml( :param encoding: File encoding :param errors: How to handle encoding errors :param width: Line width for YAML output + :param sort_keys: True sorts keys alphabetically, the default False keeps insertion order :param yaml_kwargs: additional arguments to pass to yaml.dump :return: string of YAML (if no filename provided) """ - return _to_yaml( + return _comments.dump_yaml( + self, self.to_dict(), filename=filename, default_flow_style=default_flow_style, @@ -1069,12 +1353,17 @@ def from_yaml( if arg in BOX_PARAMETERS: box_args[arg] = kwargs.pop(arg) - data = _from_yaml(yaml_string=yaml_string, filename=filename, encoding=encoding, errors=errors, **kwargs) + data, comments = _from_yaml_with_comments( + yaml_string=yaml_string, filename=filename, encoding=encoding, errors=errors, **kwargs + ) if not data: - return cls(**box_args) - if not isinstance(data, dict): + result = cls(**box_args) + elif not isinstance(data, dict): raise BoxError(f"yaml data not returned as a dictionary but rather a {type(data).__name__}") - return cls(data, **box_args) + else: + result = cls(data, **box_args) + _comments.apply_comments(result, comments) + return result else: diff --git a/box/box.pyi b/box/box.pyi index 05f09067..b9d2a2a8 100644 --- a/box/box.pyi +++ b/box/box.pyi @@ -1,9 +1,12 @@ -from _typeshed import Incomplete from collections.abc import Generator, Mapping from os import PathLike -from typing import Any, Literal +from typing import Any, Literal, Self + +from _typeshed import Incomplete class Box(dict): + _box_internal_attrs: tuple[str, ...] + _box_defaults: dict[str, Any] def __new__( cls, *args: Any, @@ -13,6 +16,7 @@ class Box(dict): default_box_create_on_get: bool = ..., frozen_box: bool = ..., camel_killer_box: bool = ..., + camel_killer_box_keep_keys: bool = ..., conversion_box: bool = ..., modify_tuples_box: bool = ..., box_safe_prefix: str = ..., @@ -34,6 +38,7 @@ class Box(dict): default_box_create_on_get: bool = ..., frozen_box: bool = ..., camel_killer_box: bool = ..., + camel_killer_box_keep_keys: bool = ..., conversion_box: bool = ..., modify_tuples_box: bool = ..., box_safe_prefix: str = ..., @@ -59,9 +64,9 @@ class Box(dict): def keys(self, dotted: bool = ...): ... def items(self, dotted: bool = ...): ... def get(self, key, default=...): ... - def copy(self) -> Box: ... - def __copy__(self) -> Box: ... - def __deepcopy__(self, memodict: Incomplete | None = ...) -> Box: ... + def copy(self) -> Self: ... + def __copy__(self) -> Self: ... + def __deepcopy__(self, memodict: Incomplete | None = ...) -> Self: ... def __getitem__(self, item, _ignore_default: bool = ...): ... def __getattr__(self, item): ... def __setitem__(self, key, value): ... @@ -75,6 +80,9 @@ class Box(dict): def __reversed__(self) -> Generator: ... def to_dict(self) -> dict: ... def update(self, *args, **kwargs) -> None: ... + def get_comment(self, key: Any = ...) -> dict[str, str] | None: ... + def set_comment(self, key: Any, text: str | None, position: str | None = ...) -> None: ... + def del_comment(self, key: Any = ...) -> None: ... def merge_update(self, *args, **kwargs) -> None: ... def setdefault(self, item, default: Incomplete | None = ...): ... def to_json(self, filename: str | PathLike | None = ..., encoding: str = ..., errors: str = ..., **json_kwargs): ... diff --git a/box/box_list.py b/box/box_list.py index 72609ff9..8de6b2f0 100644 --- a/box/box_list.py +++ b/box/box_list.py @@ -5,12 +5,14 @@ from __future__ import annotations import copy +import copyreg import re from collections.abc import Iterable from os import PathLike from typing import Any import box +from box import comments as _comments from box.converters import ( BOX_PARAMETERS, _from_csv, @@ -18,21 +20,25 @@ _from_msgpack, _from_toml, _from_toon, - _from_yaml, + _from_yaml_with_comments, _to_csv, _to_json, _to_msgpack, _to_toml, _to_toon, - _to_yaml, msgpack_available, - toon_available, toml_read_library, + toon_available, yaml_available, ) -from box.exceptions import BoxError, BoxTypeError +from box.exceptions import BoxError, BoxKeyError, BoxTypeError _list_pos_re = re.compile(r"\[(\d+)\]") +_comment_index_re = re.compile(r"\[(-?\d+)\]") # the comment API also takes negative indexes + + +def _frozen_box_list_method(*args, **kwargs): + raise BoxError("BoxList is frozen") class BoxList(list): @@ -53,25 +59,29 @@ def __init__(self, iterable: Iterable | None = None, box_class: type[box.Box] = self.box_options = box_options self.box_options["box_class"] = box_class self.box_org_ref = iterable - if iterable: + # 2026-10-10: Iteration does not require a truth value. + if iterable is not None: for x in iterable: self.append(x) + if isinstance(iterable, BoxList) and iterable is not self: + iterable._comment_copy_to(self) self.box_org_ref = None if box_options.get("frozen_box"): + for method in ["append", "clear", "extend", "insert", "pop", "remove", "reverse", "sort"]: + self.__setattr__(method, _frozen_box_list_method) - def frozen(*args, **kwargs): - raise BoxError("BoxList is frozen") - - for method in ["append", "extend", "insert", "pop", "remove", "reverse", "sort"]: - self.__setattr__(method, frozen) - - def __getitem__(self, item): + def __getitem__(self, item, _ignore_default=False): if self.box_options.get("box_dots") and isinstance(item, str) and item.startswith("["): list_pos = _list_pos_re.search(item) + if list_pos is None: + raise BoxTypeError(f"Invalid list index: {item!r}") value = super().__getitem__(int(list_pos.groups()[0])) if len(list_pos.group()) == len(item): return value - return value.__getitem__(item[len(list_pos.group()) :].lstrip(".")) + children = item[len(list_pos.group()) :].lstrip(".") + if _ignore_default and isinstance(value, (box.Box, BoxList)): + return value.__getitem__(children, _ignore_default=True) + return value.__getitem__(children) if isinstance(item, tuple): result = self for idx in item: @@ -87,31 +97,64 @@ def __delitem__(self, key): raise BoxError("BoxList is frozen") if self.box_options.get("box_dots") and isinstance(key, str) and key.startswith("["): list_pos = _list_pos_re.search(key) + if list_pos is None: + raise BoxTypeError(f"Invalid list index: {key!r}") pos = int(list_pos.groups()[0]) if len(list_pos.group()) == len(key): return super().__delitem__(pos) if hasattr(self[pos], "__delitem__"): return self[pos].__delitem__(key[len(list_pos.group()) :].lstrip(".")) # type: ignore + length = len(self) super().__delitem__(key) + self._comment_after_delete(key, length) def __setitem__(self, key, value): if self.box_options.get("frozen_box"): raise BoxError("BoxList is frozen") if self.box_options.get("box_dots") and isinstance(key, str) and key.startswith("["): list_pos = _list_pos_re.search(key) + if list_pos is None: + raise BoxTypeError(f"Invalid list index: {key!r}") pos = int(list_pos.groups()[0]) if pos >= len(self) and self.box_options.get("default_box"): self.extend([None] * (pos - len(self) + 1)) if len(list_pos.group()) == len(key): - return super().__setitem__(pos, value) + return super().__setitem__(pos, self._convert(value)) children = key[len(list_pos.group()) :].lstrip(".") if self.box_options.get("default_box"): - if children[0] == "[": - super().__setitem__(pos, box.BoxList(**self.box_options)) - else: + # Only replace the element at ``pos`` with a fresh container when it is + # not already the right one; otherwise a second dotted write into an + # existing element (e.g. ``a[0].y`` after ``a[0].x``) would discard the + # data already stored there. Mirrors the guard in Box.__setitem__. + current = super().__getitem__(pos) + if children.startswith("["): + if not isinstance(current, box.BoxList): + super().__setitem__(pos, box.BoxList(**self.box_options)) + elif not isinstance(current, box.Box): super().__setitem__(pos, self.box_options.get("box_class")(**self.box_options)) return super().__getitem__(pos).__setitem__(children, value) - super().__setitem__(key, value) + if isinstance(key, slice): + + def converted_items(): + for item in value: + yield self._convert(item) + + # Let list validate the slice before consuming replacement values. + super().__setitem__(key, converted_items()) + self.__dict__.pop("_box_comments", None) # items moved, their comments can't follow + return + super().__setitem__(key, self._convert(value)) + + def __iadd__(self, value): # type: ignore[misc] # list accepts any iterable for +=, not only lists + if self.box_options.get("frozen_box"): + raise BoxError("BoxList is frozen") + self.extend(value) + return self + + def __imul__(self, value): # type: ignore[misc] + if self.box_options.get("frozen_box"): + raise BoxError("BoxList is frozen") + return super().__imul__(value) def _is_intact_type(self, obj): if self.box_options.get("box_intact_types") and isinstance(obj, self.box_options["box_intact_types"]): @@ -137,11 +180,134 @@ def append(self, p_object): super().append(self._convert(p_object)) def extend(self, iterable): + if iterable is self: + iterable = list(self) for item in iterable: self.append(item) def insert(self, index, p_object): + length = len(self) super().insert(index, self._convert(p_object)) + if self.__dict__.get("_box_comments"): + at = min(max(index + length, 0) if index < 0 else index, length) + self._comment_reindex(lambda k: k + 1 if k >= at else k) + + def pop(self, index=-1): + length = len(self) + value = super().pop(index) + self._comment_after_delete(index, length) + return value + + def remove(self, value): + self.pop(self.index(value)) + + def clear(self): + super().clear() + self.__dict__.pop("_box_comments", None) + + def reverse(self): + super().reverse() + last = len(self) - 1 + self._comment_reindex(lambda k: last - k) + + def sort(self, *, key=None, reverse=False): + if not self.__dict__.get("_box_comments"): + return super().sort(key=key, reverse=reverse) + # Work out where every item goes (same stable order as list.sort) so comments follow them + sort_key = key or (lambda x: x) + order = sorted(range(len(self)), key=lambda i: sort_key(list.__getitem__(self, i)), reverse=reverse) + new_position = {old: new for new, old in enumerate(order)} + super().sort(key=key, reverse=reverse) + self._comment_reindex(new_position.get) + + # ---- Comments (#184), by item index ---- + + def _comment_store(self, create: bool = True) -> Any: + store = self.__dict__.get("_box_comments") + if store is None and create: + store = self.__dict__["_box_comments"] = {} + return store + + def _comment_document(self, create: bool = True) -> Any: + document = self.__dict__.get("_box_comments_document") + if document is None and create: + document = self.__dict__["_box_comments_document"] = {} + return document + + def _comment_check_frozen(self): + if self.box_options.get("frozen_box"): + raise BoxError("BoxList is frozen") + + def _comment_reindex(self, mapping): + store = self.__dict__.get("_box_comments") + if store: + moved = {} + for index, comment in store.items(): + new_index = mapping(index) + if new_index is not None: + moved[new_index] = comment + self.__dict__["_box_comments"] = moved + + def _comment_after_delete(self, key, length): + if not self.__dict__.get("_box_comments"): + return + if isinstance(key, slice): + self.__dict__.pop("_box_comments", None) + return + gone = key + length if key < 0 else key + self._comment_reindex(lambda k: None if k == gone else (k - 1 if k > gone else k)) + + def _comment_owner(self, key): + """(container, index) that holds the comment for `key`, following box_dots paths.""" + if key is None: + return self, None + if isinstance(key, int) and not isinstance(key, bool): + index = key + len(self) if key < 0 else key + if 0 <= index < len(self): + return self, index + elif isinstance(key, str) and key.startswith("["): + list_pos = _comment_index_re.match(key) + if list_pos is not None: + index = int(list_pos.groups()[0]) + index = index + len(self) if index < 0 else index + rest = key[len(list_pos.group()) :].lstrip(".") + if 0 <= index < len(self): + if not rest: + return self, index + child = list.__getitem__(self, index) + if hasattr(child, "_comment_owner"): + return child._comment_owner(rest) + raise BoxKeyError(f"{key!r} is not in the BoxList, comments can only be attached to existing items") + + def _comment_copy_to(self, other): + store = self.__dict__.get("_box_comments") + if store: + other._comment_store().update({k: copy.deepcopy(v) for k, v in store.items() if k < len(other)}) + document = self.__dict__.get("_box_comments_document") + if document: + other._comment_document().update(copy.deepcopy(document)) + + # ---- Comments (#184): kept outside the data, written by to_yaml with ruamel.yaml ---- + + def get_comment(self, key: Any = None) -> dict | None: + """ + Return the comments of `key` as ``{"before": text, "eol": text}`` (a position without a comment + is left out), or None. ``key=None`` returns the document comments ``{"start": ..., "end": ...}``. + With box_dots, `key` can be a dotted path. + """ + return _comments.get_comment(self, key) + + def set_comment(self, key: Any, text: Any, position: str | None = None) -> None: + """ + Attach a comment to an existing key. `position` is "eol" (default, on the key's line) or + "before" (lines above the key, may contain newlines). ``key=None`` sets a document comment, + position "start" (default) or "end". An empty `text` removes the comment at that position. + """ + _comments.set_comment(self, key, text, position) + + def del_comment(self, key: Any = None) -> None: + """Remove every comment of `key` (``None``: the document comments).""" + _comments.del_comment(self, key) def _dotted_helper(self) -> list[str]: keys = [] @@ -166,16 +332,41 @@ def __str__(self): return str(self.to_list()) def __copy__(self): - return self.__class__((x for x in self), **self.box_options) + out = self.__class__((x for x in self), **self.box_options) + self._comment_copy_to(out) + return out def __deepcopy__(self, memo=None): - out = self.__class__() + out = self.__class__(**{**self.box_options, "frozen_box": False}) memo = memo or {} memo[id(self)] = out - for k in self: - out.append(copy.deepcopy(k, memo=memo)) + items = [copy.deepcopy(k, memo=memo) for k in self] + # Filling through __init__ applies the options (frozen included) to the copied items + out.__init__(items, **self.box_options) + self._comment_copy_to(out) return out + def __reduce_ex__(self, protocol): + # The default list pickling appends the items before restoring box_options, which + # re-created every item with default options. Keep the items in the state instead, + # so __setstate__ restores the options first. Self references still work because + # pickle memoizes the new list before the state is saved. + state = {"box_options": self.box_options, "items": list(self)} + for name in ("_box_comments", "_box_comments_document"): + if self.__dict__.get(name): + state[name] = self.__dict__[name] + return copyreg.__newobj__, (self.__class__,), state + + def __setstate__(self, state): + if "items" not in state: + # Pickled by Box 7 or earlier: the items were already appended + self.__dict__.update(state) + return + self.__init__(state["items"], **state["box_options"]) + for name in ("_box_comments", "_box_comments_document"): + if name in state: + self.__dict__[name] = state[name] + def __hash__(self) -> int: # type: ignore[override] if self.box_options.get("frozen_box"): hashing = 98765 @@ -210,14 +401,18 @@ def to_json( :param filename: If provided will save to file :param encoding: File encoding :param errors: How to handle encoding errors - :param multiline: Put each item in list onto it's own line + :param multiline: Put each item in list onto its own line, in a string or file :param json_kwargs: additional arguments to pass to json.dump(s) :return: string of JSON or return of `json.dump` """ - if filename and multiline: + if multiline: lines = [_to_json(item, filename=None, encoding=encoding, errors=errors, **json_kwargs) for item in self] - with open(filename, "w", encoding=encoding, errors=errors) as f: - f.write("\n".join(lines)) + text = "\n".join(lines) + if filename: + with open(filename, "w", encoding=encoding, errors=errors) as f: + f.write(text) + else: + return text else: return _to_json(self.to_list(), filename=filename, encoding=encoding, errors=errors, **json_kwargs) @@ -239,7 +434,7 @@ def from_json( :param filename: filename to open and pass to `json.load` :param encoding: File encoding :param errors: How to handle encoding errors - :param multiline: One object per line + :param multiline: One object per line, in a string or file :param kwargs: parameters to pass to `Box()` or `json.loads` :return: BoxList object from json data """ @@ -275,10 +470,12 @@ def to_yaml( :param encoding: File encoding :param errors: How to handle encoding errors :param width: Line width for YAML output + :param sort_keys: True sorts keys alphabetically, the default False keeps insertion order :param yaml_kwargs: additional arguments to pass to yaml.dump :return: string of YAML or return of `yaml.dump` """ - return _to_yaml( + return _comments.dump_yaml( + self, self.to_list(), filename=filename, default_flow_style=default_flow_style, @@ -312,12 +509,17 @@ def from_yaml( if arg in BOX_PARAMETERS: box_args[arg] = kwargs.pop(arg) - data = _from_yaml(yaml_string=yaml_string, filename=filename, encoding=encoding, errors=errors, **kwargs) + data, comments = _from_yaml_with_comments( + yaml_string=yaml_string, filename=filename, encoding=encoding, errors=errors, **kwargs + ) if not data: - return cls(**box_args) - if not isinstance(data, list): + result = cls(**box_args) + elif not isinstance(data, list): raise BoxError(f"yaml data not returned as a list but rather a {type(data).__name__}") - return cls(data, **box_args) + else: + result = cls(data, **box_args) + _comments.apply_comments(result, comments) + return result else: diff --git a/box/box_list.pyi b/box/box_list.pyi index a9e769ee..ff97496a 100644 --- a/box/box_list.pyi +++ b/box/box_list.pyi @@ -1,14 +1,23 @@ +from collections.abc import Iterable +from os import PathLike as PathLike +from typing import Any + import box from box.converters import ( BOX_PARAMETERS as BOX_PARAMETERS, +) +from box.converters import ( msgpack_available as msgpack_available, +) +from box.converters import ( toml_read_library as toml_read_library, +) +from box.converters import ( toml_write_library as toml_write_library, +) +from box.converters import ( yaml_available as yaml_available, ) -from collections.abc import Iterable -from os import PathLike as PathLike -from typing import Any class BoxList(list): def __new__(cls, *args: Any, **kwargs: Any): ... @@ -24,6 +33,9 @@ class BoxList(list): def __copy__(self) -> BoxList: ... def __deepcopy__(self, memo: Any | None = ...) -> BoxList: ... def __hash__(self) -> int: ... # type: ignore[override] + def get_comment(self, key: Any = ...) -> dict[str, str] | None: ... + def set_comment(self, key: Any, text: str | None, position: str | None = ...) -> None: ... + def del_comment(self, key: Any = ...) -> None: ... def to_list(self) -> list: ... def _dotted_helper(self) -> list[str]: ... def to_json( diff --git a/box/comments.py b/box/comments.py new file mode 100644 index 00000000..8f2cf632 --- /dev/null +++ b/box/comments.py @@ -0,0 +1,340 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +""" +Comments attached to Box keys and BoxList items (#184). + +Every Box and BoxList keeps the comments for its own keys or indexes, outside the data, in a +store of ``{key: {"before": [lines], "eol": str | None}}``. The outermost container can also hold +document comments, ``{"start": [lines], "end": [lines]}``. + +YAML loaded with the ruamel.yaml round trip loader fills the stores, ``to_yaml`` writes them +back. ruamel attaches a comment line above a key to the previous key's token while parsing, so +``extract_comments`` walks the document in order and hands those trailing lines to the next key. +""" + +from __future__ import annotations + +import re +from typing import Any + +from box.converters import _ruamel_to_builtin +from box.exceptions import BoxValueError + +__all__ = [ + "extract_comments", + "apply_comments", + "has_comments", + "commented_tree", + "dump_yaml", + "get_comment", + "set_comment", + "del_comment", +] + +POSITIONS = ("before", "eol") +# Every character YAML treats as a line break. A comment line must never contain one, or the text +# after it would be read back as YAML content. +_LINE_BREAKS = re.compile("\r\n|[\r\n\x85\u2028\u2029]") +_CONTROL = re.compile("[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]") +DOCUMENT_POSITIONS = ("start", "end") + + +def _token_lines(value: str) -> list[str]: + """Comment token text to comment lines without the "#", blank lines kept as "".""" + out = [] + for line in _LINE_BREAKS.split(value): + line = line.strip() + out.append(line[1:].lstrip() if line.startswith("#") else line) + return out + + +def _text_to_lines(text: str) -> list[str]: + return [line[1:].lstrip() if line.strip().startswith("#") else line for line in _LINE_BREAKS.split(text)] + + +def normalize(position: Any, text: Any, document: bool = False) -> Any: + """Validate a comment set through the API and turn it into its stored form.""" + allowed = DOCUMENT_POSITIONS if document else POSITIONS + if position not in allowed: + raise BoxValueError(f"position must be one of {', '.join(repr(p) for p in allowed)}, not {position!r}") + if text is None or text == "": + return None + if not isinstance(text, str): + raise BoxValueError(f"comment must be a string, not {type(text).__name__}") + if _CONTROL.search(text): + raise BoxValueError("comments can't contain control characters") + if position == "eol": + if _LINE_BREAKS.search(text): + raise BoxValueError("an end of line comment must be a single line") + return _text_to_lines(text)[0] + return _text_to_lines(text) + + +def public(entry: dict | None) -> dict | None: + """Stored comment entry to what get_comment returns: strings, missing positions as None.""" + if not entry: + return None + return {k: ("\n".join(v) if isinstance(v, list) else v) for k, v in entry.items()} + + +def get_comment(obj, key) -> dict | None: + owner, key = obj._comment_owner(key) + if key is None: + return public(owner._comment_document(create=False)) + store = owner._comment_store(create=False) + return public(store.get(key)) if store else None + + +def set_comment(obj, key, text, position=None) -> None: + owner, key = obj._comment_owner(key) + owner._comment_check_frozen() + document = key is None + position = position or ("start" if document else "eol") + value = normalize(position, text, document=document) + if document: + entry = owner._comment_document() + else: + store = owner._comment_store() + entry = store.setdefault(key, {}) + if value is None: + entry.pop(position, None) + else: + entry[position] = value + if not document and not entry: + del store[key] + + +def del_comment(obj, key) -> None: + owner, key = obj._comment_owner(key) + owner._comment_check_frozen() + if key is None: + owner._comment_document().clear() + else: + store = owner._comment_store(create=False) + if store: + store.pop(key, None) + + +def extract_comments(root: Any) -> dict | None: + """ + Collect the comments of a document loaded with the ruamel.yaml round trip loader. + + :return: ``{"start": lines, "end": lines, "keys": {path: {"before": lines, "eol": text}}}``, + or None when the data carries no comments (other loaders, or a document without any). + """ + try: + from ruamel.yaml.comments import CommentedMap, CommentedSeq + except ImportError: # pragma: no cover (depends on installed packages) + return None + if not isinstance(root, (CommentedMap, CommentedSeq)): + return None + + model: dict = {"start": None, "end": None, "keys": {}} + seen: set[int] = set() + pending: list[str] = [] + + def entry(path): + return model["keys"].setdefault(path, {"before": [], "eol": None}) + + def take_lines(tokens): + for token in tokens or []: + if token is not None and id(token) not in seen: + seen.add(id(token)) + pending.extend(_token_lines(token.value)[:-1]) + + def handle(token, path): + if token is None or id(token) in seen: + return + seen.add(id(token)) + value = token.value + if value.startswith("\n"): + rest = value[1:] + else: + # The first line is the end of line comment, the following lines belong to the next key + first, _, rest = value.partition("\n") + entry(path)["eol"] = first.strip()[1:].strip() + if rest: + pending.extend(_token_lines(rest)[:-1]) # comment tokens end with a newline + + root_comment = getattr(root.ca, "comment", None) + if root_comment and len(root_comment) > 1 and root_comment[1]: + model["start"] = [line for token in root_comment[1] for line in _token_lines(token.value)[:-1]] + seen.update(id(token) for token in root_comment[1]) + + def walk(node, path): + if isinstance(node, CommentedMap): + items = node.items() + is_map = True + elif isinstance(node, CommentedSeq): + items = enumerate(node) + is_map = False + else: + return + node_comment = getattr(node.ca, "comment", None) + if path and node_comment and len(node_comment) > 1: + take_lines(node_comment[1]) + for key, value in items: + item_path = path + (_ruamel_to_builtin(key),) + if pending: + entry(item_path)["before"].extend(pending) + pending.clear() + tokens = node.ca.items.get(key) + if tokens: + if is_map: + handle(tokens[2], item_path) + take_lines(tokens[3]) # comment lines between "key:" and its nested value + else: + handle(tokens[0], item_path) + walk(value, item_path) + + walk(root, ()) + if pending: + model["end"] = list(pending) + if not model["start"] and not model["end"] and not model["keys"]: + return None + return model + + +def _resolve_key(container, key): + """The key in `container` the YAML key ended up as, or a sentinel when it isn't there.""" + if isinstance(container, list): + return key if isinstance(key, int) and 0 <= key < len(container) else _MISSING + if dict.__contains__(container, key): + return key + found = container._comment_resolve(key) # only Box / BoxList containers get here + return found if dict.__contains__(container, found) else _MISSING + + +_MISSING = object() + + +def apply_comments(root, model: dict | None) -> None: + """Store the comments of an extracted model on the Box / BoxList tree built from the same document.""" + if not model: + return + for position in DOCUMENT_POSITIONS: + if model.get(position): + root._comment_document()[position] = list(model[position]) + for path, comment in model["keys"].items(): + node = root + for segment in path[:-1]: + found = _resolve_key(node, segment) + if found is _MISSING: + node = None + break + node = list.__getitem__(node, found) if isinstance(node, list) else dict.__getitem__(node, found) + if not hasattr(node, "_comment_store"): + node = None + break + if node is None: + continue # the key moved or disappeared when the Box was built (box_dots, camel_killer, ...) + key = _resolve_key(node, path[-1]) + if key is _MISSING: + continue + stored = {} + if comment["before"]: + stored["before"] = list(comment["before"]) + if comment["eol"]: + stored["eol"] = comment["eol"] + if stored: + node._comment_store()[key] = stored + + +def has_comments(obj, _seen=None) -> bool: + """True when any Box / BoxList in the tree has a key, item or document comment.""" + store = getattr(obj, "_comment_store", None) + if store is None: + return False + if obj._comment_store(create=False) or obj._comment_document(create=False): + return True + seen = _seen if _seen is not None else set() + if id(obj) in seen: + return False + seen.add(id(obj)) + values = obj.values() if isinstance(obj, dict) else obj + return any(has_comments(value, seen) for value in values) + + +def _add_eol_comment(out, key, text): + """End of line comment two spaces after the value, wherever it is (ruamel otherwise aligns it + with a neighbouring comment, or uses one space when there is none).""" + try: + from ruamel.yaml.error import CommentMark + from ruamel.yaml.tokens import CommentToken + + out._yaml_add_eol_comment([CommentToken(f" # {text}", CommentMark(0)), None], key=key) + except (ImportError, AttributeError, TypeError): # pragma: no cover (other ruamel versions) + out.yaml_add_eol_comment(text, key) + + +def _set_ruamel_comment(out, key, comment, indent): + # ruamel quirk: on a CommentedSeq the end of line comment must be set before the before comment + if comment.get("eol"): + _add_eol_comment(out, key, comment["eol"]) + if comment.get("before"): + out.yaml_set_comment_before_after_key(key, before="\n".join(comment["before"]), indent=indent) + + +def commented_tree(obj, plain, column=0, _seen=None): + """ + Turn `plain` (the to_dict / to_list output of `obj`) into ruamel CommentedMap / CommentedSeq + objects carrying the comments stored on `obj` and its nested boxes. + + `column` is where this container's keys (or list dashes) start with ruamel's default layout: + nested mappings are indented by 2, sequences start at their parent key's column. + """ + from ruamel.yaml.comments import CommentedMap, CommentedSeq + + seen = _seen if _seen is not None else set() + if isinstance(plain, (dict, list)): + if id(plain) in seen: + return plain # self references are written as they are + seen = seen | {id(plain)} + if isinstance(plain, dict): + out = CommentedMap() + for key, value in plain.items(): + child = dict.get(obj, key) if isinstance(obj, dict) else None + out[key] = commented_tree(child, value, column if isinstance(value, list) else column + 2, seen) + keys = list(out) + elif isinstance(plain, list): + out = CommentedSeq() + for index, value in enumerate(plain): + child = list.__getitem__(obj, index) if isinstance(obj, list) and index < len(obj) else None + out.append(commented_tree(child, value, column + 2, seen)) + keys = list(range(len(out))) + else: + return plain + store = obj._comment_store(create=False) if hasattr(obj, "_comment_store") else None + if store: + for key in keys: + if key in store: + _set_ruamel_comment(out, key, store[key], column) + return out + + +def _document_lines(obj, position) -> str: + document = obj._comment_document(create=False) if hasattr(obj, "_comment_document") else None + if not document or not document.get(position): + return "" + return "".join((f"# {line}" if line else "") + "\n" for line in document[position]) + + +def dump_yaml(obj, plain, filename=None, encoding: str = "utf-8", errors: str = "strict", **yaml_kwargs): + """ + to_yaml for Box and BoxList: with comments and the ruamel round trip dumper, write them out, + otherwise dump `plain` exactly as before. + """ + from box import converters + + use_comments = converters.ruamel_available and yaml_kwargs.get("ruamel_typ", "rt") == "rt" and has_comments(obj) + if not use_comments: + return converters._to_yaml(plain, filename=filename, encoding=encoding, errors=errors, **yaml_kwargs) + body = converters._to_yaml(commented_tree(obj, plain), encoding=encoding, errors=errors, **yaml_kwargs) + # Document comments are written as text: ruamel drops a blank line after a start comment + text = _document_lines(obj, "start") + body + _document_lines(obj, "end") + if not filename: + return text + converters._exists(filename, create=True) + with open(filename, "w", encoding=encoding, errors=errors) as f: + f.write(text) + return None diff --git a/box/config_box.py b/box/config_box.py index 5f8ad55f..5d5ed876 100644 --- a/box/config_box.py +++ b/box/config_box.py @@ -2,7 +2,8 @@ # -*- coding: utf-8 -*- from __future__ import annotations -from box.box import Box +from box.box import Box, _parse_box_dots +from box.exceptions import BoxError, BoxTypeError class ConfigBox(Box): @@ -16,19 +17,212 @@ class ConfigBox(Box): cns.bool('my_bool') # True cns.int('my_int') # 5 cns.list('my_list', mod=lambda x: int(x)) # [5, 4, 3, 3, 2] + + String keys are case-insensitive, like configparser options. Lookups, ``in``, + deletion and attribute access find a key whatever its case: + + cns = ConfigBox(HOST='localhost') + cns.host, cns['Host'], 'host' in cns # 'localhost', 'localhost', True + + A ConfigBox never holds two keys that differ only by case. Writing a key that + matches an existing one replaces it, and the latest write always wins: both its + value and its spelling are kept, and the key moves to the end like a new key. + + ConfigBox({'Foo': 1, 'foo': 2}) # ConfigBox({'foo': 2}) + + Only ``str`` keys are matched this way, other keys must match exactly. """ _protected_keys = dir(Box) + ["bool", "int", "float", "list", "getboolean", "getfloat", "getint"] - def __getattr__(self, item): + # Case-insensitive key matching. + # + # `__ci_index` in the box config maps key.lower() to the stored key, so a miss costs a dict + # lookup rather than a scan of every key. `__ci_len` is the dict size the index was last in + # sync with. Writes and deletes made through ConfigBox keep the index current. Any other + # write (Box internals storing directly on the dict) changes the size, which makes the next + # lookup rebuild the index. + + def _ci_index(self): + config = self._box_config + index = config.get("__ci_index") + if index is None or config.get("__ci_len") != dict.__len__(self): + index = {} + for key in dict.keys(self): + if isinstance(key, str): + index[key.lower()] = key + config["__ci_index"] = index + config["__ci_len"] = dict.__len__(self) + return index + + def _ci_key(self, key): + """Return the stored key equal to `key` ignoring case, or None. Only str keys are matched.""" + if not isinstance(key, str): + return None + if dict.__contains__(self, key): + return key + found = self._ci_index().get(key.lower()) + if found is not None and dict.__contains__(self, found): + return found + return None + + def _ci_resolve(self, key): + """Return the key to use for `key`: the stored spelling if one matches, `key` otherwise.""" + if not isinstance(key, str) or dict.__contains__(self, key): + return key + found = self._ci_key(key) + if found is not None: + return found + config = self._box_config + if config["box_dots"] and ("." in key or "[" in key): + if config["box_dots_exclude"] and config["box_dots_exclude"].match(key): + return key + # Match the first segment of a dotted path, nested ConfigBoxes match the rest + first, rest = _parse_box_dots(self, key) + found = self._ci_key(first) + if found is not None and found != first: + return f"{found}{rest}" if rest.startswith("[") else f"{found}.{rest}" + return key + + def _ci_after_write(self, key, len_before, was_present): + """Update the index after `key` was written or deleted through ConfigBox.""" + config = self._box_config + index = config.get("__ci_index") + if index is None: + return + if config.get("__ci_len") != len_before: + config["__ci_index"] = None + return + present = dict.__contains__(self, key) + if isinstance(key, str): + lowered = key.lower() + if present: + index[lowered] = key + elif index.get(lowered) == key: + del index[lowered] + expected = len_before + int(present and not was_present) - int(was_present and not present) + if dict.__len__(self) == expected: + config["__ci_len"] = expected + else: + # Something besides `key` changed (for example a dotted write), rebuild on next use + config["__ci_index"] = None + + def _ci_check_frozen(self): + if self._box_config["frozen_box"] and self._box_config["__created"]: + raise BoxError("Box is frozen") + + def _ci_take_over(self, key, keep_value=False): """ - Config file keys are stored in lower case, be a little more - loosey goosey + Remove a stored key that differs from `key` only by case, so `key` replaces it. + With keep_value its value is stored again under the new spelling. """ - try: - return super().__getattr__(item) - except AttributeError: - return super().__getattr__(item.lower()) + existing = self._ci_key(key) + if existing is None or existing == key: + return + self._ci_check_frozen() + comments = self._box_config.get("__comments") + if comments and existing in comments: + comments[key] = comments.pop(existing) # the comment stays with the key under its new spelling + value = dict.__getitem__(self, existing) + len_before = dict.__len__(self) + dict.__delitem__(self, existing) + if self._box_config["conversion_box"]: + safe_keys = self._box_config["__safe_keys"] + safe_key = self._safe_attr(existing) + if safe_keys.get(safe_key) == existing: + del safe_keys[safe_key] + self._ci_after_write(existing, len_before, True) + if keep_value: + len_before = dict.__len__(self) + if self._box_config["conversion_box"]: + self._box_config["__safe_keys"][self._safe_attr(key)] = key + dict.__setitem__(self, key, value) + self._ci_after_write(key, len_before, False) + + def _comment_resolve(self, key): + found = self._ci_key(key) + return found if found is not None else super()._comment_resolve(key) + + def __getitem__(self, item, _ignore_default=False): + return super().__getitem__(self._ci_resolve(item), _ignore_default=_ignore_default) + + def __contains__(self, item): + if super().__contains__(item): + return True + resolved = self._ci_resolve(item) + return resolved != item and super().__contains__(resolved) + + def __setitem__(self, key, value): + if key != "_box_config": + self._ci_check_frozen() + if isinstance(key, str) and not dict.__contains__(self, key): + resolved = self._ci_resolve(key) + if resolved != key and not dict.__contains__(self, resolved): + # Dotted path whose first segment matched, the nested box handles the rest + key = resolved + else: + self._ci_take_over(key) + len_before = dict.__len__(self) + was_present = dict.__contains__(self, key) + super().__setitem__(key, value) + self._ci_after_write(key, len_before, was_present) + + def __delitem__(self, key): + key = self._ci_resolve(key) + len_before = dict.__len__(self) + was_present = dict.__contains__(self, key) + super().__delitem__(key) + self._ci_after_write(key, len_before, was_present) + + def update(self, *args, **kwargs): + if self._box_config["frozen_box"]: + raise BoxError("Box is frozen") + if len(args) > 1: + raise BoxTypeError(f"update expected at most 1 argument, got {len(args)}") + pairs = [] + single_arg = next(iter(args), None) + if single_arg: + if hasattr(single_arg, "keys"): + pairs.extend((k, single_arg[k]) for k in single_arg) + else: + pairs.extend(single_arg) + pairs.extend(kwargs.items()) + # One pair at a time so a later spelling of the same key replaces an earlier one + for k, v in pairs: + self._ci_take_over(k) + len_before = dict.__len__(self) + was_present = dict.__contains__(self, k) + super().update(((k, v),)) + self._ci_after_write(k, len_before, was_present) + + def merge_update(self, *args, **kwargs): + # Give existing keys the incoming spelling first, so the merge itself then matches exactly + if not kwargs.get("_force_unfrozen"): + self._ci_check_frozen() + if len(args) == 1 and args[0]: + if hasattr(args[0], "keys"): + incoming = list(args[0].keys()) + else: + args = (list(args[0]),) # may be a one-shot iterator, it is read twice + incoming = [k for k, _ in args[0]] + else: + incoming = [] + incoming.extend(k for k in kwargs if k not in ("box_merge_lists", "_force_unfrozen")) + for k in incoming: + self._ci_take_over(k, keep_value=True) + return super().merge_update(*args, **kwargs) + + def _flush_pending_parent(self): + pending = self._box_config.get("__pending_parent") + if pending is not None: + parent, key = pending + if isinstance(parent, ConfigBox) and parent._ci_key(key) not in (None, key): + # The key was given a value (under another spelling) since this child was handed + # out, so the child is stale and is not attached. Ancestors still are, like Box. + self._box_config.pop("__pending_parent", None) + parent._flush_pending_parent() + return + super()._flush_pending_parent() def __dir__(self) -> list[str]: return super().__dir__() + ["bool", "int", "float", "list", "getboolean", "getfloat", "getint"] @@ -51,7 +245,8 @@ def bool(self, item, default=None): if isinstance(item, (bool, int)): return bool(item) - if isinstance(item, str) and item.lower() in ("n", "no", "false", "f", "0"): + # The configparser false values, plus "n" and "f" + if isinstance(item, str) and item.strip().lower() in ("n", "no", "false", "f", "0", "off"): return False return True if item else False @@ -125,9 +320,3 @@ def getfloat(self, item, default=None): def __repr__(self): return f"{self.__class__.__name__}({str(self.to_dict())})" - - def copy(self): - return ConfigBox(super().copy()) - - def __copy__(self): - return ConfigBox(super().copy()) diff --git a/box/config_box.pyi b/box/config_box.pyi index 6d72f275..05fe00a5 100644 --- a/box/config_box.pyi +++ b/box/config_box.pyi @@ -1,15 +1,21 @@ -from box.box import Box as Box +import builtins from typing import Any +from box.box import Box as Box + class ConfigBox(Box): - def __getattr__(self, item: Any): ... def __dir__(self) -> list[str]: ... def bool(self, item: Any, default: Any | None = ...): ... def int(self, item: Any, default: Any | None = ...): ... def float(self, item: Any, default: Any | None = ...): ... - def list(self, item: Any, default: Any | None = ..., spliter: str = ..., strip: bool = ..., mod: Any | None = ...): ... # type: ignore + def list( + self, + item: Any, + default: Any | None = ..., + spliter: str = ..., + strip: builtins.bool = ..., + mod: Any | None = ..., + ): ... def getboolean(self, item: Any, default: Any | None = ...): ... def getint(self, item: Any, default: Any | None = ...): ... def getfloat(self, item: Any, default: Any | None = ...): ... - def copy(self) -> ConfigBox: ... - def __copy__(self) -> ConfigBox: ... diff --git a/box/converters.py b/box/converters.py index bb91ba6c..335196f4 100644 --- a/box/converters.py +++ b/box/converters.py @@ -3,14 +3,13 @@ from __future__ import annotations # Abstract converter functions for use in any Box class - import csv import json -from collections.abc import Callable +import tomllib from io import StringIO from os import PathLike from pathlib import Path -from typing import Any +from typing import IO, Any from box.exceptions import BoxError @@ -19,23 +18,21 @@ msgpack_available = True try: - from ruamel.yaml import version_info, YAML -except ImportError: + from ruamel.yaml import YAML, version_info +except ImportError: # pragma: no cover (depends on installed packages) ruamel_available = False else: - if version_info[1] < 17: + if version_info[1] < 17: # pragma: no cover (depends on installed packages) ruamel_available = False try: import yaml -except ImportError: +except ImportError: # pragma: no cover (depends on installed packages) pyyaml_available = False MISSING_PARSER_ERROR = "No YAML Parser available, please install ruamel.yaml>=0.17 or PyYAML" -toml_read_library: Any | None = None toml_write_library: Any | None = None -toml_decode_error: Callable | None = None __all__ = [ "_to_json", @@ -53,51 +50,25 @@ ] -class BoxTomlDecodeError(BoxError): - """Toml Decode Error""" - - -try: - import toml -except ImportError: - pass -else: - toml_read_library = toml - toml_write_library = toml - toml_decode_error = toml.TomlDecodeError - - class BoxTomlDecodeError(BoxError, toml.TomlDecodeError): # type: ignore - """Toml Decode Error""" - - -try: - import tomllib -except ImportError: - pass -else: - toml_read_library = tomllib - toml_decode_error = tomllib.TOMLDecodeError - - class BoxTomlDecodeError(BoxError, tomllib.TOMLDecodeError): # type: ignore - """Toml Decode Error""" - +# Reading uses tomllib, which is always available on the supported Python versions (3.11+) +toml_read_library = tomllib +toml_decode_error = tomllib.TOMLDecodeError -try: - import tomli -except ImportError: - pass -else: - toml_read_library = tomli - toml_decode_error = tomli.TOMLDecodeError - class BoxTomlDecodeError(BoxError, tomli.TOMLDecodeError): # type: ignore - """Toml Decode Error""" +class BoxTomlDecodeError(BoxError, tomllib.TOMLDecodeError): # type: ignore + """Toml Decode Error""" +# Writing needs tomli-w, or the older toml package as a fallback try: import tomli_w -except ImportError: - pass +except ImportError: # pragma: no cover (depends on installed packages) + try: + import toml + except ImportError: + pass + else: + toml_write_library = toml else: toml_write_library = tomli_w @@ -111,7 +82,8 @@ class BoxTomlDecodeError(BoxError, tomli.TOMLDecodeError): # type: ignore toon_available = True try: - from toon_format import encode as toon_encode, decode as toon_decode + from toon_format import decode as toon_decode + from toon_format import encode as toon_encode except ImportError: toon_available = False @@ -124,6 +96,7 @@ class BoxTomlDecodeError(BoxError, tomli.TOMLDecodeError): # type: ignore "default_box_create_on_get", "frozen_box", "camel_killer_box", + "camel_killer_box_keep_keys", "conversion_box", "modify_tuples_box", "box_safe_prefix", @@ -156,12 +129,13 @@ def _exists(filename: str | PathLike, create: bool = False) -> Path: def _to_json( obj, filename: str | PathLike | None = None, encoding: str = "utf-8", errors: str = "strict", **json_kwargs ): + json_kwargs.setdefault("ensure_ascii", False) if filename: _exists(filename, create=True) with open(filename, "w", encoding=encoding, errors=errors) as f: - json.dump(obj, f, ensure_ascii=False, **json_kwargs) + json.dump(obj, f, **json_kwargs) else: - return json.dumps(obj, ensure_ascii=False, **json_kwargs) + return json.dumps(obj, **json_kwargs) def _from_json( @@ -182,8 +156,15 @@ def _from_json( ] else: data = json.load(f, **kwargs) - elif json_string: - data = json.loads(json_string, **kwargs) + elif json_string or (multiline and json_string is not None): + if multiline: + data = [ + json.loads(line.strip(), **kwargs) + for line in StringIO(json_string, newline=None) + if line.strip() and not line.strip().startswith("#") + ] + else: + data = json.loads(json_string, **kwargs) else: raise BoxError("from_json requires a string or filename") return data @@ -198,39 +179,71 @@ def _to_yaml( ruamel_typ: str = "rt", ruamel_attrs: dict | None = None, width: int = 120, + sort_keys: bool = False, **yaml_kwargs, ): + """ + Keys are written in insertion order. ``sort_keys=True`` sorts them alphabetically instead + (PyYAML and the ruamel ``safe`` / ``unsafe`` dumpers, the default ruamel ``rt`` dumper never sorts). + """ + if not ruamel_available and not pyyaml_available: + raise BoxError(MISSING_PARSER_ERROR) + + def ruamel_dump(stream): + yaml_dumper = YAML(typ=ruamel_typ) + yaml_dumper.default_flow_style = default_flow_style + yaml_dumper.width = width + if hasattr(yaml_dumper.representer, "sort_base_mapping_type_on_output"): # pragma: no branch (older ruamel) + yaml_dumper.representer.sort_base_mapping_type_on_output = sort_keys + for attr, value in ruamel_attrs.items(): + setattr(yaml_dumper, attr, value) + return yaml_dumper.dump(obj, stream=stream, **yaml_kwargs) + + def pyyaml_dump(stream=None): + return yaml.dump( + obj, stream=stream, default_flow_style=default_flow_style, width=width, sort_keys=sort_keys, **yaml_kwargs + ) + if not ruamel_attrs: ruamel_attrs = {} if filename: _exists(filename, create=True) with open(filename, "w", encoding=encoding, errors=errors) as f: if ruamel_available: - yaml_dumper = YAML(typ=ruamel_typ) - yaml_dumper.default_flow_style = default_flow_style - yaml_dumper.width = width - for attr, value in ruamel_attrs.items(): - setattr(yaml_dumper, attr, value) - return yaml_dumper.dump(obj, stream=f, **yaml_kwargs) - elif pyyaml_available: - return yaml.dump(obj, stream=f, default_flow_style=default_flow_style, width=width, **yaml_kwargs) - else: - raise BoxError(MISSING_PARSER_ERROR) - - else: - if ruamel_available: - yaml_dumper = YAML(typ=ruamel_typ) - yaml_dumper.default_flow_style = default_flow_style - yaml_dumper.width = width - for attr, value in ruamel_attrs.items(): - setattr(yaml_dumper, attr, value) - with StringIO() as string_stream: - yaml_dumper.dump(obj, stream=string_stream, **yaml_kwargs) - return string_stream.getvalue() - elif pyyaml_available: - return yaml.dump(obj, default_flow_style=default_flow_style, width=width, **yaml_kwargs) - else: - raise BoxError(MISSING_PARSER_ERROR) + return ruamel_dump(f) + return pyyaml_dump(f) + if ruamel_available: + with StringIO() as string_stream: + ruamel_dump(string_stream) + return string_stream.getvalue() + return pyyaml_dump() + + +def _ruamel_to_builtin(obj): + """Convert ruamel.yaml numeric and boolean scalar types to plain Python builtins. + + ScalarFloat/ScalarInt survive Box.to_dict() and break serializers + that only accept builtin float/int (issue #264). + + Only numbers and booleans are converted. ruamel string types (literal and folded + blocks, quoted strings) are left alone so to_yaml keeps their formatting, and + ScalarBoolean (used for anchored booleans) is not an int subclass, so it is checked + explicitly rather than falling through to int. + """ + if isinstance(obj, dict): + return {_ruamel_to_builtin(k): _ruamel_to_builtin(v) for k, v in obj.items()} + if isinstance(obj, list): + return [_ruamel_to_builtin(v) for v in obj] + if type(obj).__module__.startswith("ruamel"): + from ruamel.yaml.scalarbool import ScalarBoolean + + if isinstance(obj, (bool, ScalarBoolean)): + return bool(obj) + if isinstance(obj, int): + return int(obj) + if isinstance(obj, float): + return float(obj) + return obj def _from_yaml( @@ -242,6 +255,29 @@ def _from_yaml( ruamel_attrs: dict | None = None, **kwargs, ): + return _ruamel_to_builtin( + _load_yaml(yaml_string, filename, encoding, errors, ruamel_typ=ruamel_typ, ruamel_attrs=ruamel_attrs, **kwargs) + ) + + +def _from_yaml_with_comments(*args, **kwargs): + """Like _from_yaml, also returning the comments found in the document (see box.comments).""" + from box.comments import extract_comments + + raw = _load_yaml(*args, **kwargs) + return _ruamel_to_builtin(raw), extract_comments(raw) + + +def _load_yaml( + yaml_string: str | None = None, + filename: str | PathLike | None = None, + encoding: str = "utf-8", + errors: str = "strict", + ruamel_typ: str = "rt", + ruamel_attrs: dict | None = None, + **kwargs, +): + """Load YAML as the parser returns it (ruamel round trip types included).""" if not ruamel_attrs: ruamel_attrs = {} if filename: @@ -279,22 +315,14 @@ def _to_toml(obj, filename: str | PathLike | None = None, encoding: str = "utf-8 if filename: _exists(filename, create=True) if toml_write_library.__name__ == "toml": # type: ignore + # The toml package writes text, tomli-w writes bytes with open(filename, "w", encoding=encoding, errors=errors) as f: - try: - toml_write_library.dump(obj, f) # type: ignore - except toml_decode_error as err: # type: ignore - raise BoxTomlDecodeError(err) from err + toml_write_library.dump(obj, f) # type: ignore else: with open(filename, "wb") as f: - try: - toml_write_library.dump(obj, f) # type: ignore - except toml_decode_error as err: # type: ignore - raise BoxTomlDecodeError(err) from err + toml_write_library.dump(obj, f) # type: ignore else: - try: - return toml_write_library.dumps(obj) # type: ignore - except toml_decode_error as err: # type: ignore - raise BoxTomlDecodeError(err) from err + return toml_write_library.dumps(obj) # type: ignore def _from_toml( @@ -305,12 +333,8 @@ def _from_toml( ): if filename: _exists(filename) - if toml_read_library.__name__ == "toml": # type: ignore - with open(filename, "r", encoding=encoding, errors=errors) as f: - data = toml_read_library.load(f) # type: ignore - else: - with open(filename, "rb") as f: - data = toml_read_library.load(f) # type: ignore + with open(filename, "rb") as f: + data = toml_read_library.load(f) elif toml_string: data = toml_read_library.loads(toml_string) # type: ignore else: @@ -374,6 +398,7 @@ def _to_csv( if list(row.keys()) != csv_column_names: raise BoxError("BoxList must contain the same dictionary structure for every item to convert to csv") + out_data: IO[str] if filename: _exists(filename, create=True) out_data = open(filename, "w", encoding=encoding, errors=errors, newline="") diff --git a/box/converters.pyi b/box/converters.pyi index 975b9027..933dbc3a 100644 --- a/box/converters.pyi +++ b/box/converters.pyi @@ -3,6 +3,8 @@ from os import PathLike from typing import Any yaml_available: bool +ruamel_available: bool +pyyaml_available: bool toml_available: bool msgpack_available: bool toon_available: bool @@ -11,6 +13,10 @@ toml_read_library: Any | None toml_write_library: Any | None toml_decode_error: Callable | None +def _exists(filename: str | PathLike, create: bool = ...) -> Any: ... +def _ruamel_to_builtin(obj: Any) -> Any: ... +def _load_yaml(*args: Any, **kwargs: Any) -> Any: ... +def _from_yaml_with_comments(*args: Any, **kwargs: Any) -> tuple[Any, dict | None]: ... def _to_json(obj, filename: str | PathLike | None = ..., encoding: str = ..., errors: str = ..., **json_kwargs): ... def _from_json( json_string: str | None = ..., @@ -29,6 +35,7 @@ def _to_yaml( ruamel_typ: str = ..., ruamel_attrs: dict | None = ..., width: int = ..., + sort_keys: bool = ..., **yaml_kwargs, ): ... def _from_yaml( diff --git a/box/from_file.py b/box/from_file.py index 3fb7a6e5..f6f2650b 100644 --- a/box/from_file.py +++ b/box/from_file.py @@ -2,7 +2,6 @@ # -*- coding: utf-8 -*- from __future__ import annotations -import sys from collections.abc import Callable from json import JSONDecodeError from os import PathLike @@ -10,7 +9,7 @@ from box.box import Box from box.box_list import BoxList -from box.converters import msgpack_available, toon_available, toml_read_library, yaml_available, toml_decode_error +from box.converters import msgpack_available, toml_decode_error, toml_read_library, toon_available, yaml_available from box.exceptions import BoxError try: @@ -92,7 +91,7 @@ def _to_toon(file, encoding, errors, **kwargs): return BoxList.from_toon(filename=file, encoding=encoding, errors=errors, **kwargs) -converters = { +converters: dict[str, Callable] = { "json": _to_json, "jsn": _to_json, "yaml": _to_yaml, @@ -103,7 +102,7 @@ def _to_toon(file, encoding, errors, **kwargs): "msgpack": _to_msgpack, "pack": _to_msgpack, "csv": _to_csv, -} # type: dict[str, Callable] +} def box_from_file( @@ -155,8 +154,7 @@ def box_from_string(content: str, string_type: str = "json") -> Box | BoxList: return Box.from_toml(toml_string=content) except toml_decode_error: # type: ignore raise BoxError("File is not TOML as expected") - except BoxError: - return BoxList.from_toml(toml_string=content) + # A TOML document is always a table, so unlike the other formats it is never a BoxList elif string_type == "yaml": try: return Box.from_yaml(yaml_string=content) diff --git a/box/from_file.pyi b/box/from_file.pyi index bae0c57f..8d1d7da4 100644 --- a/box/from_file.pyi +++ b/box/from_file.pyi @@ -1,8 +1,9 @@ -from box.box import Box as Box -from box.box_list import BoxList as BoxList from os import PathLike from typing import Any +from box.box import Box as Box +from box.box_list import BoxList as BoxList + def box_from_file( file: str | PathLike, file_type: str = ..., diff --git a/box/shorthand_box.py b/box/shorthand_box.py index aecfcc54..a7e424f0 100644 --- a/box/shorthand_box.py +++ b/box/shorthand_box.py @@ -46,24 +46,8 @@ def toml(self) -> str: def __repr__(self): return f"{self.__class__.__name__}({self})" - def copy(self) -> SBox: - return SBox(super(SBox, self).copy()) - - def __copy__(self) -> SBox: - return SBox(super(SBox, self).copy()) - class DDBox(SBox): - def __init__(self, *args, **kwargs): - kwargs["box_dots"] = True - kwargs["default_box"] = True - super().__init__(*args, **kwargs) + """SBox with box_dots and default_box turned on by default""" - def __new__(cls, *args, **kwargs): - obj = super().__new__(cls, *args, **kwargs) - obj._box_config["box_dots"] = True - obj._box_config["default_box"] = True - return obj - - def __repr__(self) -> str: - return f"{self.__class__.__name__}({self})" + _box_defaults = {"box_dots": True, "default_box": True} diff --git a/box/shorthand_box.pyi b/box/shorthand_box.pyi index be577f26..1f390873 100644 --- a/box/shorthand_box.pyi +++ b/box/shorthand_box.pyi @@ -9,7 +9,5 @@ class SBox(Box): def yaml(self) -> str: ... @property def toml(self) -> str: ... - def copy(self) -> SBox: ... - def __copy__(self) -> SBox: ... class DDBox(Box): ... diff --git a/pyproject.toml b/pyproject.toml new file mode 100644 index 00000000..423145bd --- /dev/null +++ b/pyproject.toml @@ -0,0 +1,147 @@ +[build-system] +# Cython is intentionally NOT listed here: a normal install (pip install python-box from an sdist) builds the +# pure Python version. To build the compiled version, install Cython in the build environment and build with +# `--no-isolation` (see CONTRIBUTING.rst). +requires = ["setuptools>=77"] +build-backend = "setuptools.build_meta" + +[project] +name = "python-box" +dynamic = ["version"] +description = "Advanced Python dictionaries with dot notation access" +readme = { file = "README.rst", content-type = "text/x-rst" } +license = "MIT" +license-files = ["LICENSE"] +authors = [{ name = "Chris Griffith", email = "chris@cdgriffith.com" }] +requires-python = ">=3.11" +dependencies = [] +classifiers = [ + "Programming Language :: Python", + "Programming Language :: Python :: 3", + "Programming Language :: Python :: 3.11", + "Programming Language :: Python :: 3.12", + "Programming Language :: Python :: 3.13", + "Programming Language :: Python :: 3.14", + "Programming Language :: Python :: 3.15", + "Programming Language :: Python :: Implementation :: CPython", + "Development Status :: 5 - Production/Stable", + "Natural Language :: English", + "Intended Audience :: Developers", + "Operating System :: OS Independent", + "Topic :: Utilities", + "Topic :: Software Development", + "Topic :: Software Development :: Libraries :: Python Modules", +] + +[project.urls] +Homepage = "https://github.com/cdgriffith/Box" +Changelog = "https://github.com/cdgriffith/Box/blob/master/CHANGES.rst" +Issues = "https://github.com/cdgriffith/Box/issues" + +[project.optional-dependencies] +all = ["ruamel.yaml>=0.19.1", "toml", "msgpack"] +yaml = ["ruamel.yaml>=0.19.1"] +"ruamel.yaml" = ["ruamel.yaml>=0.19.1"] +PyYAML = ["PyYAML"] +tomli = ["tomli-w"] +toml = ["toml"] +msgpack = ["msgpack"] + +[tool.setuptools] +packages = ["box"] +include-package-data = true + +[tool.setuptools.package-data] +box = ["py.typed", "*.pyi"] + +[tool.setuptools.dynamic] +version = { attr = "box.__version__" } + +[dependency-groups] +# Everything the test suite needs (also used by cibuildwheel via `test-groups`) +test = [ + "coverage>=7.17.1", + "msgpack>=1.2.4", + "pytest>=9.2.0", + "pytest-cov>=7.1.0", + "ruamel.yaml>=0.19.1", + "tomli-w>=1.2.0", + "toon-format>=1.2.0", + "types-PyYAML>=6.0.12.20261103", +] +# Development tooling: linting, type checking, building and releasing +dev = [ + { include-group = "test" }, + "build>=1.6.1", + "Cython>=3.3.1", + "mypy>=2.4.1", + "pre-commit>=4.7.0", + "ruff>=0.17.3", + "setuptools>=84.2.1", + "twine>=7.0.0", + "wheel>=0.48.0", +] + +[tool.ruff] +line-length = 120 +target-version = "py311" +extend-exclude = ["build", "dist", ".idea"] + +[tool.ruff.format] +# Black compatible defaults (double quotes, magic trailing comma, 88 -> 120 columns above) +quote-style = "double" +indent-style = "space" +skip-magic-trailing-comma = false +line-ending = "auto" + +[tool.ruff.lint] +# Deliberately conservative: pycodestyle, pyflakes and import sorting only +select = ["E", "F", "W", "I"] + +[tool.ruff.lint.per-file-ignores] +# The package imports are order sensitive (circular imports) and re-exported on purpose +"box/__init__.py" = ["F401", "I001"] + +[tool.ruff.lint.isort] +# "test" is also a stdlib module name, make sure our test package is sorted with the first party code +known-first-party = ["box", "test"] + +[tool.cibuildwheel] +build = "cp311-manylinux_x86_64 cp312-manylinux_x86_64 cp313-manylinux_x86_64 cp314-manylinux_x86_64 cp315-manylinux_x86_64" +# Cython (and setuptools) must be present in the build environment, so build without isolation +before-build = "pip install 'Cython>=3.3.1' setuptools wheel" +build-frontend = { name = "build", args = ["--no-isolation"] } +build-verbosity = 1 +test-groups = ["test"] +test-command = "pytest {package}/test -vv" + +[tool.coverage.report] +omit = [ + "*/python?.?/*", + "*/site-packages/nose/*", + "*/test/*", + "*/pypy/*", + "*/nose/*", + "*/.*/*", + "*/*.egg-info/*", +] +exclude_lines = [ + "pragma: no cover", + "raise err", + "except ImportError", + "yaml = none", + 'raise BoxError\("_box_config key must exist', + "raise err", + "if \"box_class\" in self.__dict__:", + 'raise BoxError\(f"File', + "except OSError", + 'raise BoxError\(f"{filename}', + 'item._box_config["__box_heritage"] = \(\)', + 'raise BoxKeyError\(err', + "(.*)is unavailable on this system", + "def to_", + "def from_", + "warnings.warn", + "@classmethod", + "no package is available to open it", +] diff --git a/requirements-dev.txt b/requirements-dev.txt deleted file mode 100644 index 0a430f90..00000000 --- a/requirements-dev.txt +++ /dev/null @@ -1,7 +0,0 @@ -# Files needed for pre-commit hooks -black>=23.1.0 -Cython>=3.0.11 -mypy>=1.0.1 -pre-commit>=2.21.0 -setuptools>=75.6.0 -toon_format @ git+https://github.com/toon-format/toon-python.git diff --git a/requirements-test.txt b/requirements-test.txt deleted file mode 100644 index 071ec6d2..00000000 --- a/requirements-test.txt +++ /dev/null @@ -1,10 +0,0 @@ -coverage>=7.6.9 -msgpack>=1.0 -pytest>=7.1.3 -pytest-cov<6.0.0 -ruamel.yaml>=0.19.1 -tomli>=1.2.3; python_version < '3.11' -tomli-w>=1.0.0 -toon_format @ git+https://github.com/toon-format/toon-python.git -types-PyYAML>=6.0.3 -wheel>=0.34.2 diff --git a/requirements.txt b/requirements.txt deleted file mode 100644 index 8a77de28..00000000 --- a/requirements.txt +++ /dev/null @@ -1,4 +0,0 @@ -msgpack>=1.0.0 -ruamel.yaml>=0.19.1 -tomli>=1.2.3; python_version < '3.11' -tomli-w diff --git a/setup.py b/setup.py index 3898da70..c9b9a544 100644 --- a/setup.py +++ b/setup.py @@ -1,81 +1,29 @@ #!/usr/bin/env python # -*- coding: utf-8 -*- +""" +All package metadata lives in pyproject.toml. + +This file only exists to optionally compile the library with Cython. If Cython is +installed in the build environment the modules are compiled, otherwise a pure Python +package is built (which is what happens with the default isolated build). +""" -# Must import multiprocessing as a fix for issues with testing, experienced on win10 -import multiprocessing # noqa: F401 -import os -import re -from pathlib import Path import sys -import shutil +from pathlib import Path from setuptools import setup -root = os.path.abspath(os.path.dirname(__file__)) +root = Path(__file__).resolve().parent try: from Cython.Build import cythonize except ImportError: - extra = None + ext_modules = [] + print("WARNING: Cython not installed, could not optimize box.", file=sys.stderr) else: - extra = cythonize( - [str(file.relative_to(root)) for file in Path(root, "box").glob("*.py") if file.name != "__init__.py"], + ext_modules = cythonize( + [str(file.relative_to(root)) for file in (root / "box").glob("*.py") if file.name != "__init__.py"], compiler_directives={"language_level": 3}, ) -with open(os.path.join(root, "box", "__init__.py"), "r") as init_file: - init_content = init_file.read() - -attrs = dict(re.findall(r"__([a-z]+)__ *= *['\"](.+)['\"]", init_content)) - -with open("README.rst", "r") as readme_file: - long_description = readme_file.read() - -setup( - name="python-box", - version=attrs["version"], - url="https://github.com/cdgriffith/Box", - license="MIT", - author=attrs["author"], - install_requires=[], - author_email="chris@cdgriffith.com", - description="Advanced Python dictionaries with dot notation access", - long_description=long_description, - long_description_content_type="text/x-rst", - py_modules=["box"], - packages=["box"], - ext_modules=extra, - python_requires=">=3.9", - include_package_data=True, - platforms="any", - classifiers=[ - "Programming Language :: Python", - "Programming Language :: Python :: 3", - "Programming Language :: Python :: 3.10", - "Programming Language :: Python :: 3.11", - "Programming Language :: Python :: 3.12", - "Programming Language :: Python :: 3.13", - "Programming Language :: Python :: 3.14", - "Programming Language :: Python :: Implementation :: CPython", - "Development Status :: 5 - Production/Stable", - "Natural Language :: English", - "Intended Audience :: Developers", - "License :: OSI Approved :: MIT License", - "Operating System :: OS Independent", - "Topic :: Utilities", - "Topic :: Software Development", - "Topic :: Software Development :: Libraries :: Python Modules", - ], - extras_require={ - "all": ["ruamel.yaml>=0.19.1", "toml", "msgpack"], - "yaml": ["ruamel.yaml>=0.19.1"], - "ruamel.yaml": ["ruamel.yaml>=0.19.1"], - "PyYAML": ["PyYAML"], - "tomli": ["tomli; python_version < '3.11'", "tomli-w"], - "toml": ["toml"], - "msgpack": ["msgpack"], - }, -) - -if not extra: - print("WARNING: Cython not installed, could not optimize box.", file=sys.stderr) +setup(ext_modules=ext_modules) diff --git a/test/test_box.py b/test/test_box.py index e5c56e0b..143f4b0c 100644 --- a/test/test_box.py +++ b/test/test_box.py @@ -7,9 +7,18 @@ import pickle import platform import shutil +import warnings +from io import StringIO from multiprocessing import Queue from pathlib import Path -from io import StringIO + +import pytest +from ruamel.yaml import YAML + +from box import Box, BoxError, BoxKeyError, BoxList, ConfigBox, DDBox, SBox +from box.box import _camel_killer, _get_dot_paths, _recursive_tuples # type: ignore +from box.converters import BOX_PARAMETERS +from box.exceptions import BoxWarning from test.common import ( data_json_file, data_yaml_file, @@ -24,12 +33,9 @@ tmp_yaml_file, ) -import pytest -from ruamel.yaml import YAML -from box import Box, BoxError, BoxKeyError, BoxList, ConfigBox, SBox, DDBox -from box.box import _get_dot_paths, _camel_killer, _recursive_tuples # type: ignore -from box.converters import BOX_PARAMETERS +class _SubclassBox(Box): + """Module-level Box subclass so its instances are picklable in tests.""" def mp_queue_test(q): @@ -54,6 +60,37 @@ def temp_dir_cleanup(self): yield shutil.rmtree(str(tmp_dir), ignore_errors=True) + @pytest.mark.parametrize("removal", ["item", "attribute", "converted_attribute", "pop", "popitem"]) + def test_removed_key_releases_conversion_alias(self, removal): + bx = Box({"a b": 1}, box_duplicates="error") + if removal == "item": + del bx["a b"] + elif removal == "attribute": + delattr(bx, "a b") + elif removal == "converted_attribute": + del bx.a_b + elif removal == "pop": + bx.pop("a b") + else: + bx.popitem() + + bx["a-b"] = 2 + assert bx.to_dict() == {"a-b": 2} + assert bx.a_b == 2 + with pytest.raises(BoxError): + bx["a b"] = 3 + + def test_deleting_none_key_after_conversion_alias_owner(self): + bx = Box({None: 1, "None": 2}) + del bx["None"] + del bx[None] + assert bx.to_dict() == {} + + def test_deleting_colliding_key_keeps_other_conversion_alias(self): + bx = Box({"a b": 1, "a-b": 2}) + del bx["a b"] + assert bx.a_b == 2 + def test_safe_attrs(self): assert Box()._safe_attr("BAD!KEY!1") == "BAD_KEY_1" assert Box(camel_killer_box=True)._safe_attr("BAD!KEY!2") == "bad_key_2" @@ -268,6 +305,47 @@ def test_update(self): assert a.key1.gg == 4 assert "new" not in a.key1.keys() + @pytest.mark.parametrize("source_type", [dict, list, iter]) + def test_update_source_and_keywords(self, source_type): + pairs = [("mode", "source"), ("service", {"timeout": 10})] + overrides = {"mode": "override", "workers": [{"id": 1}]} + expected = {"keep": True} + expected.update(source_type(pairs), **overrides) + bx = Box(keep=True) + + assert bx.update(source_type(pairs), **overrides) is None + + assert bx.to_dict() == expected + assert isinstance(bx.service, Box) + assert bx.service.timeout == 10 + assert isinstance(bx.workers, BoxList) + assert isinstance(bx.workers[0], Box) + assert bx.workers[0].id == 1 + + def test_update_empty_source_and_keywords(self): + bx = Box(keep=True) + + assert bx.update({}, mode="override") is None + + assert bx.to_dict() == {"keep": True, "mode": "override"} + + @pytest.mark.parametrize("kwargs", [{}, {"mode": "override"}]) + def test_update_rejects_multiple_sources(self, kwargs): + bx = Box(keep=True) + + with pytest.raises(TypeError, match="update expected at most 1 argument"): + bx.update({"first": 1}, {"second": 2}, **kwargs) + + assert bx.to_dict() == {"keep": True} + + def test_update_source_and_keywords_frozen(self): + bx = Box(keep=True, frozen_box=True) + + with pytest.raises(BoxError, match="Box is frozen"): + bx.update({"first": 1}, mode="override") + + assert bx.to_dict() == {"keep": True} + def test_merge_update(self): a = Box(test_dict) a.grand = 1000 @@ -349,6 +427,15 @@ def test_from_json_file(self): assert isinstance(bx, Box) assert bx.widget.window.height == 500 + def test_from_yaml_invalid_bracket_key(self): + key = r"^[^_^\d][\w]*$" + yaml_string = f"'{key}': {{}}" + with pytest.raises(BoxError) as error: + Box.from_yaml(yaml_string, default_box=True, box_dots=True) + assert "Invalid list index" in str(error.value) + assert repr(key[1:]) in str(error.value) + assert Box.from_yaml(yaml_string, default_box=True, box_dots=False).to_dict() == {key: {}} + def test_from_yaml_file(self): bx = Box.from_yaml(filename=data_yaml_file) assert isinstance(bx, Box) @@ -369,6 +456,61 @@ def test_from_yaml(self): assert bx.key1 == "value1" assert bx.Key_2 == Box() + def test_from_yaml_box_dots_dotted_key_before_non_dotted(self): + """ + Test for issue #305: Dotted keys read from YAML are lost with box_dots / default_box + when the dotted key appears before a non-dotted key with the same prefix. + + Previously a.b: c followed by a: {d: e} caused a.b to be lost. + """ + # Create a temporary YAML file with dotted key before non-dotted key + yaml_content = """a.b: c +a: + d: e +""" + yaml_file = Path(tmp_dir, "test_dotted_before.yml") + yaml_file.write_text(yaml_content) + + # Test without box_dots/default_box - should preserve both keys as separate entries + bx1 = Box.from_yaml(filename=yaml_file) + assert "a.b" in bx1 + assert bx1["a.b"] == "c" + assert "a" in bx1 + assert bx1["a"]["d"] == "e" + + # Test with box_dots=True and default_box=True + # a.b should be merged into a, so a.b == "c" and a.d == "e" + bx2 = Box.from_yaml(filename=yaml_file, box_dots=True, default_box=True) + assert "a" in bx2 + assert bx2["a"]["d"] == "e" + assert "b" in bx2["a"], "Bug #305: a.b key is lost when it appears before a: in YAML" + assert bx2["a"]["b"] == "c" + + # Test reverse order (non-dotted before dotted) - this should work correctly + yaml_content_reverse = """a: + d: e +a.b: c +""" + yaml_file_reverse = Path(tmp_dir, "test_dotted_after.yml") + yaml_file_reverse.write_text(yaml_content_reverse) + + bx3 = Box.from_yaml(filename=yaml_file_reverse, box_dots=True, default_box=True) + assert "a" in bx3 + assert bx3["a"]["d"] == "e" + # In reverse order, the dotted key should be properly merged + assert "b" in bx3["a"] + assert bx3["a"]["b"] == "c" + + def test_from_yaml_builtin_scalars(self): + bx = Box.from_yaml("Float: 0.1\nCount: 4\nFlag: true\n") + assert type(bx.Float) is float + assert type(bx.Count) is int + assert type(bx.Flag) is bool + dumped = bx.to_dict() + assert type(dumped["Float"]) is float + assert type(dumped["Count"]) is int + assert dumped["Float"] == 0.1 + def test_bad_from_json(self): with pytest.raises(BoxError): Box.from_json() @@ -435,6 +577,22 @@ def test_frozen(self): assert hash(bx3) + def test_frozen_box_with_lists_is_serializable(self): + # frozen_box stores lists as tuples of Boxes; to_dict must convert the + # nested Boxes back to native dicts so serialization works. See #272. + bx = Box({"a": [{"b": 123}, {"b": 222}], "c": [[{"d": 2}], [3, 4]]}, frozen_box=True) + + native = bx.to_dict() + assert isinstance(native["a"], tuple) + assert native["a"][0] == {"b": 123} + assert not isinstance(native["a"][0], Box) + assert not isinstance(native["c"][0][0], Box) + + # These used to raise RepresenterError / serialization errors. + yaml = YAML(typ="safe") + assert yaml.load(bx.to_yaml()) == {"a": [{"b": 123}, {"b": 222}], "c": [[{"d": 2}], [3, 4]]} + assert json.loads(bx.to_json()) == {"a": [{"b": 123}, {"b": 222}], "c": [[{"d": 2}], [3, 4]]} + def test_hashing(self): bx1 = Box(t=3, g=4, frozen_box=True) bx2 = Box(g=4, t=3, frozen_box=True) @@ -471,13 +629,13 @@ def test_default_box(self): bx4 = Box(default_box=True, default_box_attr=None) assert bx4.who_is_there is None - bx5 = Box(default_box=True, default_box_attr=[]) + bx5 = Box(default_box=True, default_box_attr=[], default_box_create_on_get=True) assert isinstance(bx5.empty_list_please, list) assert len(bx5.empty_list_please) == 0 bx5.empty_list_please.append(1) assert bx5.empty_list_please[0] == 1 - bx6 = Box(default_box=True, default_box_attr=[]) + bx6 = Box(default_box=True, default_box_attr=[], default_box_create_on_get=True) my_list = bx6.get("new_list") my_list.append(5) assert bx6.get("new_list")[0] == 5 @@ -539,6 +697,47 @@ def test_default_and_camel_killer_box(self): assert isinstance(killer_default_box.does_not_exist, Box) assert isinstance(killer_default_box["does_not_exist"], Box) + @pytest.mark.parametrize("default_box", [False, True]) + @pytest.mark.parametrize("conversion_box", [False, True]) + def test_camel_killer_box_dotted_lookup(self, default_box, conversion_box): + bx = Box( + {"someKey": [{"innerKey": "value"}], "otherKey": {"innerKey": "value"}}, + camel_killer_box=True, + box_dots=True, + default_box=default_box, + conversion_box=conversion_box, + ) + + for key in ( + "some_key[0].inner_key", + "some_key[0].innerKey", + "someKey[0].innerKey", + "SomeKey[0].InnerKey", + "other_key.inner_key", + "otherKey.innerKey", + "OtherKey.InnerKey", + ): + assert bx[key] == "value" + assert bx.to_dict() == {"some_key": [{"inner_key": "value"}], "other_key": {"inner_key": "value"}} + + @pytest.mark.parametrize("camel_killer_box, box_dots", [(False, True), (True, False)]) + def test_camel_killer_box_dotted_lookup_disabled(self, camel_killer_box, box_dots): + bx = Box({"some_key": {"inner_key": "value"}}, camel_killer_box=camel_killer_box, box_dots=box_dots) + + with pytest.raises(BoxKeyError): + bx["someKey.innerKey"] + assert bx.to_dict() == {"some_key": {"inner_key": "value"}} + + def test_camel_killer_box_dotted_lookup_exact_key(self): + bx = Box({"someKey": {"innerKey": "converted"}}, camel_killer_box=True, box_dots=True) + bx.update({"someKey": {"innerKey": "exact"}}) + + assert bx["someKey.innerKey"] == "exact" + assert bx["some_key.innerKey"] == "converted" + + bx.update({"someKey.innerKey": "literal"}) + assert bx["someKey.innerKey"] == "literal" + def test_box_modify_tuples(self): bx = Box(extended_test_dict, modify_tuples_box=True) assert bx.tuples_galore[0].item == 3 @@ -630,6 +829,26 @@ def test_duplicate_errors(self): with pytest.raises(BoxError): my_box["^a"] = 3 + @pytest.mark.parametrize("policy", ["error", "warn"]) + @pytest.mark.parametrize("use_attribute", [False, True]) + def test_duplicate_checks_allow_reassigning_same_key(self, policy, use_attribute): + my_box = Box({"a b": 1}, box_duplicates=policy) + with warnings.catch_warnings(): + warnings.simplefilter("error", BoxWarning) + if use_attribute: + my_box.a_b = 2 + else: + my_box["a b"] = 2 + assert my_box.to_dict() == {"a b": 2} + assert my_box.a_b == 2 + if policy == "error": + with pytest.raises(BoxError): + my_box["a-b"] = 3 + assert my_box.to_dict() == {"a b": 2} + else: + with pytest.warns(BoxWarning): + my_box["a-b"] = 3 + def test_copy(self): my_box = Box(movie_data, camel_killer_box=True) bb = my_box.copy() @@ -686,6 +905,17 @@ def test_pickle(self): assert bx == loaded2 loaded2.box_options = bx.box_options + def test_pickle_preserves_subclass_on_nested_access(self): + if platform.python_implementation() == "PyPy": + pytest.skip("Pickling does not work correctly on PyPy") + # Unpickling goes through __new__ + __setstate__ but not __init__, so + # box_class must be set from cls in __new__ too. Otherwise nested boxes + # created on access after unpickling fall back to the base Box (#308). + b = _SubclassBox({"a": {"b": 1}}) + loaded = pickle.loads(pickle.dumps(b)) + assert isinstance(loaded, _SubclassBox) + assert type(loaded.a) is _SubclassBox + def test_pickle_default_box(self): if platform.python_implementation() == "PyPy": pytest.skip("Pickling does not work correctly on PyPy") @@ -693,6 +923,37 @@ def test_pickle_default_box(self): loaded = pickle.loads(pickle.dumps(bb)) assert bb == loaded + def test_pickle_preserves_nested_box_dots(self): + """Nested boxes must keep box_dots after pickle (#260).""" + if platform.python_implementation() == "PyPy": + pytest.skip("Pickling does not work correctly on PyPy") + original = Box( + { + "l1": { + "time_range_selected_utc": { + "left": "2023-03-01 10:00:00", + "right": "2023-06-01 10:00:00", + } + } + }, + box_dots=True, + conversion_box=False, + ) + assert original["l1.time_range_selected_utc.right"] == "2023-06-01 10:00:00" + + loaded = pickle.loads(pickle.dumps(original)) + assert loaded._box_config["box_dots"] is True + assert loaded.l1._box_config["box_dots"] is True + assert loaded.l1.time_range_selected_utc._box_config["box_dots"] is True + assert loaded["l1.time_range_selected_utc.right"] == "2023-06-01 10:00:00" + assert loaded["l1.time_range_selected_utc.left"] == "2023-03-01 10:00:00" + + # Normal construction still reapplies parent options onto a nested Box + inner = Box({"b": 1}, box_dots=False) + outer = Box({"a": inner}, box_dots=True) + assert outer.a._box_config["box_dots"] is True + assert outer["a.b"] == 1 + def test_conversion_dup_only(self): with pytest.raises(BoxError): Box(movie_data, conversion_box=False, box_duplicates="error") @@ -882,7 +1143,8 @@ def test_pop(self): assert bx.pop("c", True) is not True def test_pop_items(self): - bx = Box(a=4) + bx = Box(a=4, b=5) + assert bx.popitem() == ("b", 5) assert bx.popitem() == ("a", 4) with pytest.raises(BoxKeyError): assert bx.popitem() @@ -953,7 +1215,7 @@ def test_dots_exclusion(self): box_dots=True, box_dots_exclude=r"[0-9]+\.[0-9]+\.[0-9]+\.[0-9]+", ) - assert bx["0.0.0.1"] == True + assert bx["0.0.0.1"] == True # noqa: E712 with pytest.raises(BoxKeyError): del bx["0"] @@ -1274,7 +1536,7 @@ def test_box_safe_references(self): assert id(a) != id(b.a) def test_default_box_restricted_calls(self): - a = Box(default_box=True) + a = Box(default_box=True, default_box_create_on_get=True) with pytest.raises(BoxKeyError): a._test_thing_ assert len(list(a.keys())) == 0 @@ -1290,11 +1552,11 @@ def test_default_box_restricted_calls(self): assert len(list(a.keys())) == 2 def test_default_dots(self): - bx1 = Box(default_box=True, box_dots=True) + bx1 = Box(default_box=True, box_dots=True, default_box_create_on_get=True) bx1["a.a.a"] assert bx1 == {"a": {"a": {"a": {}}}} - a = Box(default_box=True, box_dots=True) + a = Box(default_box=True, box_dots=True, default_box_create_on_get=True) a["a."] a["a.."] assert a == {"a": {"": {"": {}}}} @@ -1328,6 +1590,27 @@ def test_merge_list_options(self): {"app": {"S3": {"S3Service": [{"bucket": "bucket001"}, {"expirationDate": "2099-10-25"}]}}} ), box1 + def test_merge_list_merge_option(self): + # Lists of dictionaries are merged element by element + box1 = Box({"data": [{"foo": 1, "foobar": 20}, {"bar": 2}]}) + box1.merge_update({"data": [{"foo": 1, "baz": 10}]}, box_merge_lists="merge") + assert box1 == Box({"data": [{"foo": 1, "foobar": 20, "baz": 10}, {"bar": 2}]}), box1 + + # Extra incoming elements are appended, nested dictionaries recurse + box2 = Box({"app": {"servers": [{"name": "web", "tags": {"a": 1}}]}}) + box2.merge_update({"app": {"servers": [{"tags": {"b": 2}}, {"name": "db"}]}}, box_merge_lists="merge") + assert box2 == Box({"app": {"servers": [{"name": "web", "tags": {"a": 1, "b": 2}}, {"name": "db"}]}}), box2 + + # Non-dict elements at a shared index are overwritten + box3 = Box({"nums": [1, 2, 3]}) + box3.merge_update({"nums": [9, 8]}, box_merge_lists="merge") + assert box3.nums == [9, 8, 3] + + # Falls back to assignment when the existing value is not a list + box4 = Box({"data": 5}) + box4.merge_update({"data": [{"a": 1}]}, box_merge_lists="merge") + assert box4 == Box({"data": [{"a": 1}]}), box4 + def test_box_from_empty_yaml(self): out = Box.from_yaml("---") assert out == Box() @@ -1345,7 +1628,7 @@ def test_setdefault_simple(self): assert box["b"] == 2 assert box["c"] == "test" assert isinstance(box["d"], Box) - assert box["d"]["e"] == True + assert box["d"]["e"] == True # noqa: E712 assert isinstance(box["f"], BoxList) assert box["f"][1] == 2 @@ -1360,7 +1643,7 @@ def test_setdefault_dots(self): assert box.b == 2 assert box.c.e == "test" assert isinstance(box["d"], Box) - assert box.d.e == True + assert box.d.e == True # noqa: E712 assert isinstance(box["f"], BoxList) assert box.f[1] == 2 @@ -1412,7 +1695,7 @@ def test_box_greek(self): assert a == Box({"σeq": 1, "μeq": 2}) def test_box_default_not_create_on_get(self): - box = Box(default_box=True) + box = Box(default_box=True, default_box_create_on_get=True) assert box.a.b.c == Box() @@ -1427,6 +1710,15 @@ def test_box_default_not_create_on_get(self): assert box2 == Box() + box2.foo.bar = 1 + assert box2.foo.bar == 1 + assert box2 == Box({"foo": {"bar": 1}}) + + box3 = Box(default_box=True, default_box_create_on_get=False) + box3.a.b.c = "nested" + assert box3.a.b.c == "nested" + assert box3["a"]["b"]["c"] == "nested" + def test_box_property_support(self): class BoxWithProperty(Box): def __init__(self, *args, **kwargs): @@ -1455,7 +1747,7 @@ def field(self): assert box.field == 5 assert box._field == 5 del box.field - assert not "_field" in box + assert "_field" not in box def test_box_namespace(self): bx = Box(default_box=True) @@ -1506,3 +1798,598 @@ def func(box_instance, key): my_box = DDBox(default_box_attr=func) assert my_box.a == {"bi": "{}", "key": "a"} + + +@pytest.mark.parametrize("create_on_get", [True, False]) +@pytest.mark.parametrize("default", [None, 0, [], {"fallback": True}]) +def test_pop_explicit_default_without_autovivification(create_on_get, default): + calls = [] + + def factory(): + calls.append(None) + return "generated" + + value = Box(default_box=True, default_box_attr=factory, default_box_create_on_get=create_on_get) + assert value.pop("missing", default) is default + assert value == {} + assert calls == [] + value.present = 1 + assert value.pop("present", default) == 1 + assert value == {} + + +def test_pop_explicit_default_dotted_path(): + value = Box({"nested": {}}, default_box=True, box_dots=True) + default = object() + assert value.pop("nested.missing", default) is default + assert value.to_dict() == {"nested": {}} + + +def test_pop_explicit_default_camel_case_key(): + value = Box({"actualKey": 1}, default_box=True, camel_killer_box=True) + assert value.pop("actualKey", None) == 1 + assert value == {} + + +@pytest.mark.parametrize("path", ["items[0].missing", "items[1][0].missing"]) +def test_pop_explicit_default_dotted_list_path(path): + value = Box({"items": [{}, [{}]]}, default_box=True, box_dots=True) + default = object() + assert value.pop(path, default) is default + assert value.to_dict() == {"items": [{}, [{}]]} + + +class _InternalBox(Box): + _box_internal_attrs = ("source_path", "_cache") + + def __init__(self, *args, source_path=None, **kwargs): + super().__init__(*args, **kwargs) + self.source_path = source_path + self._cache = {} + + +class _InternalConfigBox(ConfigBox): + _box_internal_attrs = ("meta",) + + +class _InternalSBox(SBox): + _box_internal_attrs = ("meta",) + + +def _make_internal(): + c = _InternalBox({"name": "app", "db": {"host": "x"}}, source_path="/etc/app.yml") + c._cache["hits"] = 1 + c.normal = "data" + return c + + +class TestInternalAttrs: + def test_not_in_data(self): + c = _make_internal() + assert c.source_path == "/etc/app.yml" + assert c.to_dict() == {"name": "app", "db": {"host": "x"}, "normal": "data"} + assert "source_path" not in c and "_cache" not in c + assert list(c) == ["name", "db", "normal"] + assert list(c.keys()) == ["name", "db", "normal"] + assert len(c) == 3 + assert c == {"name": "app", "db": {"host": "x"}, "normal": "data"} + assert c.__dict__["source_path"] == "/etc/app.yml" + + def test_exports(self): + c = _make_internal() + assert "source_path" not in c.to_json() and "_cache" not in c.to_json() + assert "source_path" not in c.to_yaml() + assert "source_path" not in c.to_toml() + assert "source_path" not in str(c) and "source_path" not in repr(c) + assert b"source_path" not in c.to_msgpack() + assert _InternalBox.from_json(c.to_json()).to_dict() == c.to_dict() + + def test_copy_variants(self): + c = _make_internal() + for name, clone in [ + ("copy", copy.copy(c)), + ("deepcopy", copy.deepcopy(c)), + (".copy()", c.copy()), + ("pickle", pickle.loads(pickle.dumps(c))), + ]: + assert type(clone) is _InternalBox, name + assert clone.source_path == "/etc/app.yml", name + assert clone._cache == {"hits": 1}, name + assert clone.to_dict() == c.to_dict(), name + assert copy.copy(c)._cache is c._cache + assert c.copy()._cache is c._cache + assert copy.deepcopy(c)._cache is not c._cache + assert type(pickle.loads(pickle.dumps(c)).db) is _InternalBox + + def test_deepcopy_memo(self): + shared = {"x": 1} + c = _InternalBox(a=1) + c._cache = {"one": shared, "two": shared} + d = copy.deepcopy(c) + assert d._cache["one"] is d._cache["two"] + assert d._cache["one"] is not shared + o2 = copy.deepcopy([c, c]) + assert o2[0] is o2[1] + assert o2[0]._cache["one"] is o2[0]._cache["two"] + + def test_deepcopy_self_reference_in_internal(self): + c = _InternalBox(a=1) + c._cache = {"owner": c} + d = copy.deepcopy(c) + assert d._cache["owner"] is d + + def test_copy_does_not_share_assignment(self): + c = _make_internal() + d = c.copy() + d.source_path = "other" + assert c.source_path == "/etc/app.yml" + + def test_unset_internal_is_not_copied(self): + class Plain(Box): + _box_internal_attrs = ("source_path",) + + c = Plain(a=1) + c.source_path = 1 + del c.source_path + assert "source_path" not in c.copy().__dict__ + assert "source_path" not in copy.deepcopy(c).__dict__ + + def test_delete(self): + c = _make_internal() + del c.source_path + assert not hasattr(c, "source_path") + with pytest.raises(AttributeError): + del c.source_path + assert c.to_dict()["name"] == "app" + + def test_frozen(self): + f = _InternalBox({"a": 1}, frozen_box=True) + f._cache["x"] = 1 + f.source_path = "ok" + assert f.source_path == "ok" + del f.source_path + with pytest.raises(BoxError): + f.a = 2 + with pytest.raises(BoxError): + del f.a + assert hash(f) == hash(_InternalBox({"a": 1}, frozen_box=True)) + g = f.copy() + assert g._cache == {"x": 1} + with pytest.raises(BoxError): + g.a = 3 + h = copy.deepcopy(f) + with pytest.raises(BoxError): + h.a = 3 + h.source_path = "still ok" + + def test_nested_fresh_internals(self): + c = _make_internal() + assert type(c.db) is _InternalBox + assert c.db.source_path is None + assert c.db._cache == {} + c.db._cache["k"] = 1 + assert c._cache == {"hits": 1} + c.new = {"deep": {"x": 1}} + assert type(c.new.deep) is _InternalBox and c.new.deep._cache == {} + + def test_name_collision(self): + c = _InternalBox({"source_path": "data-value"}, source_path="attr-value") + assert c.source_path == "attr-value" + assert c["source_path"] == "data-value" + assert c.to_dict() == {"source_path": "data-value"} + assert "source_path" in c + + def test_item_assignment_is_data(self): + c = _InternalBox() + c["source_path"] = 5 + assert c.to_dict() == {"source_path": 5} + assert c.source_path is None + + def test_internal_checked_before_protected_keys(self): + class Weird(Box): + _box_internal_attrs = ("items",) + + w = Weird(a=1) + w.items = "mine" + assert w.__dict__["items"] == "mine" + assert w.to_dict() == {"a": 1} + del w.items + + def test_no_internals_unaffected(self): + assert Box._box_internal_attrs == () + b = Box(a=1) + b.source_path = 3 + assert b.to_dict() == {"a": 1, "source_path": 3} + assert "source_path" not in b.__dict__ + del b.source_path + assert "source_path" not in b + assert type(copy.copy(b)) is Box and type(copy.deepcopy(b)) is Box + + def test_equality_and_hash_ignore_internals(self): + a = _InternalBox({"a": 1}, frozen_box=True, source_path="one") + b = _InternalBox({"a": 1}, frozen_box=True, source_path="two") + assert a == b and hash(a) == hash(b) + + def test_box_options_preserved_on_copy(self): + c = _InternalBox({"a-b": 1}, camel_killer_box=True, box_dots=True, source_path="p") + d = c.copy() + assert d._box_config["box_dots"] is True + assert d.source_path == "p" + assert copy.deepcopy(c)._box_config["camel_killer_box"] is True + + def test_configbox_subclass(self): + c = _InternalConfigBox({"key": "1"}) + c.meta = {"m": 1} + assert c.to_dict() == {"key": "1"} + for clone in (c.copy(), copy.copy(c), copy.deepcopy(c), pickle.loads(pickle.dumps(c))): + assert type(clone) is _InternalConfigBox + assert clone.meta == {"m": 1} + assert clone.int("key") == 1 + assert copy.copy(c).meta is c.meta + assert copy.deepcopy(c).meta is not c.meta + + def test_sbox_subclass(self): + c = _InternalSBox({"a": 1}) + c.meta = [1] + assert c.to_dict() == {"a": 1} + for clone in (c.copy(), copy.copy(c), copy.deepcopy(c), pickle.loads(pickle.dumps(c))): + assert type(clone) is _InternalSBox + assert clone.meta == [1] + + +def test_copy_preserves_subclass(): + class Sub(Box): + pass + + s = Sub({"a": {"b": 1}}, default_box=True) + assert type(s.copy()) is Sub + assert type(copy.copy(s)) is Sub + assert type(copy.deepcopy(s)) is Sub + assert s.copy()._box_config["default_box"] is True + assert type(Box(a=1).copy()) is Box + + +def test_copy_preserves_configbox_sbox_ddbox_types(): + for cls in (ConfigBox, SBox, DDBox): + b = cls({"a": 1}) + assert type(b.copy()) is cls + assert type(copy.copy(b)) is cls + assert type(copy.deepcopy(b)) is cls + assert b.copy() == b + + +def test_popitem_is_lifo_like_dict(): + for cls in (Box, ConfigBox, SBox): + bx = cls(a=1, b=2, c=3) + ref = {"a": 1, "b": 2, "c": 3} + while ref: + assert bx.popitem() == ref.popitem() + with pytest.raises(BoxKeyError): + bx.popitem() + + +def test_popitem_lifo_nested_value_and_reinsert(): + bx = Box(a=1, b={"x": 1}, c=3) + del bx["a"] + bx["a"] = 9 # re-inserted keys move to the end + assert bx.popitem() == ("a", 9) + assert bx.popitem() == ("c", 3) + key, value = bx.popitem() + assert key == "b" and isinstance(value, Box) + + +def test_popitem_frozen_and_alias_cleanup(): + with pytest.raises(BoxError): + Box(a=1, frozen_box=True).popitem() + bx = Box({"a b": 1, "c": 2}) + assert bx.popitem() == ("c", 2) + assert not hasattr(bx, "c") + assert bx.a_b == 1 + + +def test_merge_lists_merge_nested_lists_of_lists(): + bx = Box({"m": [[{"a": 1}, 2], [3]]}) + bx.merge_update({"m": [[{"b": 2}, 9, 10], [4], [5]]}, box_merge_lists="merge") + assert bx.to_dict() == {"m": [[{"a": 1, "b": 2}, 9, 10], [4], [5]]} + assert isinstance(bx.m[0][0], Box) and isinstance(bx.m[2], BoxList) + + +def test_merge_lists_merge_list_vs_dict_and_scalar_replace(): + bx = Box({"m": [{"a": 1}, [1], 5]}) + bx.merge_update({"m": [[1, 2], {"b": 1}, {"c": 1}]}, box_merge_lists="merge") + assert bx.to_dict() == {"m": [[1, 2], {"b": 1}, {"c": 1}]} + + +def test_merge_lists_merge_with_plain_list_and_boxlist_values(): + bx = Box({"m": [{"a": 1}]}) + bx.merge_update({"m": BoxList([{"b": 2}])}, box_merge_lists="merge") + bx.merge_update({"m": ({"c": 3},)}, box_merge_lists="merge") # tuple is not a list: replaced + assert bx.m == ({"c": 3},) + bx2 = Box({"m": [{"a": 1}]}) + bx2.merge_update(m=[{"b": 2}], box_merge_lists="merge") + assert bx2.to_dict() == {"m": [{"a": 1, "b": 2}]} + + +def test_merge_lists_merge_empty_lists(): + bx = Box({"m": [{"a": 1}]}) + bx.merge_update({"m": []}, box_merge_lists="merge") + assert bx.to_dict() == {"m": [{"a": 1}]} + bx.merge_update({"new": [{"x": 1}]}, box_merge_lists="merge") + assert bx.to_dict() == {"m": [{"a": 1}], "new": [{"x": 1}]} + + +def test_merge_lists_merge_frozen(): + bx = Box({"m": [{"a": 1}]}, frozen_box=True) + with pytest.raises(BoxError): + bx.merge_update({"m": [{"b": 2}]}, box_merge_lists="merge") + with pytest.raises(BoxError): + bx.merge_update({"m": [{"a": 1}, {"b": 2}]}, box_merge_lists="merge") + assert bx.to_dict() == {"m": ({"a": 1},)} # frozen boxes store lists as tuples + + +@pytest.mark.parametrize("bad", ["Merge", "replace", True, 1, ""]) +def test_merge_lists_invalid_value(bad): + from box.exceptions import BoxValueError + + bx = Box({"m": [1]}) + with pytest.raises(BoxValueError): + bx.merge_update({"m": [2]}, box_merge_lists=bad) + assert bx.to_dict() == {"m": [1]} + + +def test_merge_lists_valid_values_still_work(): + for mode, expected in (("extend", [1, 1]), ("unique", [1]), (None, [1]), (False, [1])): + bx = Box({"m": [1]}) + bx.merge_update({"m": [1]}, box_merge_lists=mode) + assert bx.m == expected, mode + + +def test_merge_lists_merge_deep_dict_in_list_in_dict(): + bx = Box({"a": {"l": [{"b": {"l2": [{"x": 1}]}}]}}) + bx.merge_update({"a": {"l": [{"b": {"l2": [{"y": 2}, {"z": 3}]}}]}}, box_merge_lists="merge") + assert bx.to_dict() == {"a": {"l": [{"b": {"l2": [{"x": 1, "y": 2}, {"z": 3}]}}]}} + + +def test_merge_lists_merge_intact_dict_type(): + class MyDict(dict): + pass + + bx = Box({"m": [MyDict(a=1)]}, box_intact_types=(MyDict,)) + bx.merge_update({"m": [{"b": 2}]}, box_merge_lists="merge") + assert bx.m[0] == {"b": 2} + + +def _no_create_box(**kwargs): + return Box(default_box=True, default_box_create_on_get=False, **kwargs) + + +class TestCreateOnSetWithoutCreateOnGet: + def test_issue_274(self): + b = _no_create_box() + assert b.foo.bar == Box() + assert b == {} + b.foo.bar = 1 + assert b.to_dict() == {"foo": {"bar": 1}} + + def test_reads_never_create(self): + b = _no_create_box() + b.x.y.z + b["a"]["b"] + assert b == {} + + def test_deep_assignment_and_item_forms(self): + b = _no_create_box() + b.a.b.c.d = 1 + b["e"]["f"] = 2 + b.g.h.update({"i": 3}) + b.j.k.setdefault("l", 4) + b.m.merge_update({"n": 5}) + assert b.to_dict() == { + "a": {"b": {"c": {"d": 1}}}, + "e": {"f": 2}, + "g": {"h": {"i": 3}}, + "j": {"k": {"l": 4}}, + "m": {"n": 5}, + } + + def test_failed_operations_do_not_create(self): + b = _no_create_box() + del b.x.nothing # a missing attribute of a default_box looks present, deleting it is a no-op + with pytest.raises(BoxKeyError): + b.x.items = 1 # protected key + b.x.update({}) + assert b == {} + + def test_children_do_not_leak_bookkeeping(self): + b = _no_create_box() + child = b.x + assert "__pending_parent" in child._box_config + assert child.to_dict() == {} and repr(child) == "Box({})" + for clone in (copy.copy(child), copy.deepcopy(child), pickle.loads(pickle.dumps(child))): + assert "__pending_parent" not in clone._box_config + clone.z = 1 + assert b == {} + # box options handed to new children never include internal "__" keys + child.sub.q = 1 + assert child.to_dict() == {"sub": {"q": 1}} + assert not any(k.startswith("__pending") for k in child.sub._box_config["box_namespace"] if isinstance(k, str)) + # pickling a flushed child does not drag the old parent reference along + assert "__pending_parent" not in pickle.loads(pickle.dumps(b.x))._box_config + + def test_pickled_child_does_not_pickle_parent(self): + b = _no_create_box() + b.big = list(range(5000)) + child = b.x + assert len(pickle.dumps(child)) < 2000 + + def test_stale_child_does_not_clobber_scalar(self): + b = _no_create_box() + c = b.x + b.x = 5 + c.y = 1 + assert b.to_dict() == {"x": 5} + + def test_stale_child_does_not_clobber_dict(self): + b = _no_create_box() + c = b.x + b.x = {"q": 1} + c.y = 1 + assert b.to_dict() == {"x": {"q": 1}} + assert c.to_dict() == {"y": 1} + + def test_two_children_first_write_wins(self): + b = _no_create_box() + c1, c2 = b.x, b.x + c1.a = 1 + c2.b = 2 # stale: x already exists, detached child is not merged + assert b.to_dict() == {"x": {"a": 1}} + + def test_real_child_deleted_stays_detached(self): + b = _no_create_box() + b.x.y = 1 + c = b.x # a real, stored child + del b["x"] + c.z = 2 + assert b.to_dict() == {} + + def test_ephemeral_chain_with_stale_ancestor(self): + b = _no_create_box() + deep = b.a.b + b.a = {"keep": 1} + deep.c = 1 + assert b.to_dict() == {"a": {"keep": 1}} + + def test_frozen_is_never_mutated(self): + f = _no_create_box(frozen_box=True) + child = f.x + with pytest.raises(BoxError): + child.y = 1 + with pytest.raises(BoxError): + child["y"] = 1 + with pytest.raises(BoxError): + child.update(y=1) + assert f == {} + + def test_box_dots(self): + b = _no_create_box(box_dots=True) + b["a.b.c"] = 1 + b.d.e = 2 + assert b.to_dict() == {"a": {"b": {"c": 1}}, "d": {"e": 2}} + # dotted lookups stay ephemeral and never create a literal dotted key + c = b["z.y"] + c.k = 1 + assert "z.y" not in b.keys() + assert b.to_dict() == {"a": {"b": {"c": 1}}, "d": {"e": 2}} + + def test_conversion_box_alias_registered(self): + b = _no_create_box() + b["my key"].v = 1 + assert b.to_dict() == {"my key": {"v": 1}} + assert b.my_key.v == 1 + + def test_inside_boxlist(self): + b = _no_create_box(items_list=[{}]) + b.items_list[0].x.y = 1 + assert b.to_dict() == {"items_list": [{"x": {"y": 1}}]} + + def test_default_box_attr_dict(self): + b = _no_create_box(default_box_attr={"d": 1}) + b.x.d = 2 + assert b.to_dict() == {"x": {"d": 2}} + + def test_subclass_keeps_type(self): + class Sub(Box): + pass + + b = Sub(default_box=True, default_box_create_on_get=False) + b.x.y = 1 + assert type(b.x) is Sub + + def test_create_on_get_true_stores_on_lookup(self): + b = Box(default_box=True, default_box_create_on_get=True) + b.a.b + assert b.to_dict() == {"a": {"b": {}}} + assert "__pending_parent" not in b.a._box_config + + def test_create_on_get_is_off_by_default(self): + b = Box(default_box=True) + assert b._box_config["default_box_create_on_get"] is False + assert b.a.b == Box() + assert b.to_dict() == {} + b.a.b = 1 + assert b.to_dict() == {"a": {"b": 1}} + + def test_ipython_style_probing_does_not_add_keys(self): + # IPython / Spyder look up attributes such as size and compute on objects (#262) + b = Box(default_box=True) + for name in ("size", "compute", "shape", "_repr_html_"): + hasattr(b, name) + assert b.to_dict() == {} + + def test_in_place_change_of_default_value_is_not_kept(self): + # Documented trade off of the default: store the value first, or use default_box_create_on_get=True + b = Box(default_box=True, default_box_attr=[]) + b.tags.append(1) + assert b.to_dict() == {} + b.tags = b.tags + [1] + assert b.to_dict() == {"tags": [1]} + + def test_pop_and_delattr_of_missing_key(self): + b = Box(default_box=True) + assert b.pop("missing") == Box() + assert hasattr(b, "_unrecognized_args") # what argparse.parse_args does with a namespace + delattr(b, "_unrecognized_args") + assert b.to_dict() == {} + with pytest.raises(KeyError): + Box().pop("missing") + with pytest.raises(AttributeError): + delattr(Box(), "missing") + + def test_argparse_namespace(self): + import argparse + + parser = argparse.ArgumentParser() + parser.add_argument("--name", default="x") + args = parser.parse_args(["--name", "y"], namespace=Box(default_box=True)) + assert args.to_dict() == {"name": "y"} + + def test_no_default_box_unchanged(self): + with pytest.raises(BoxKeyError): + Box().x.y = 1 + + +class TestRuamelScalarConversion: + """from_yaml returns builtin numbers and bools without disturbing strings (#264, PR #321).""" + + def test_anchored_boolean_stays_bool(self): + bx = Box.from_yaml("a: &x true\nb: *x\nc: false\n") + assert bx.a is True and bx.b is True and bx.c is False + + def test_anchored_boolean_round_trips_as_bool(self): + assert Box.from_yaml("a: &x true\nb: *x\n").to_yaml() == "a: true\nb: true\n" + assert Box.from_yaml("a: &x true\n").to_json() == '{"a": true}' + + def test_multiline_string_dump_unchanged(self): + bx = Box.from_yaml("lit: |\n line1\n line2\n") + assert bx.to_yaml() == "lit: |\n line1\n line2\n" + + def test_preserve_quotes_attr_still_effective(self): + bx = Box.from_yaml("a: 'x'\n", ruamel_attrs={"preserve_quotes": True}) + assert bx.to_yaml() == "a: 'x'\n" + + def test_numbers_become_builtin(self): + bx = Box.from_yaml("f: 1.10\ni: 0x1F\nu: 1_000\no: 0o17\nb: 0b101\n") + assert [type(v) for v in bx.values()] == [float, int, int, int, int] + + def test_keys_are_builtin(self): + bx = Box.from_yaml("1.5: a\n", conversion_box=False) + assert [type(k) for k in bx.keys()] == [float] + + def test_pyyaml_backend_unaffected(self, monkeypatch): + import box.converters as cv + + if not cv.pyyaml_available: + pytest.skip("PyYAML is not installed") + monkeypatch.setattr(cv, "ruamel_available", False) + bx = Box.from_yaml("a: 1.10\nb: true\n") + assert bx.to_dict() == {"a": 1.1, "b": True} diff --git a/test/test_box_defaults.py b/test/test_box_defaults.py new file mode 100644 index 00000000..bb2b7888 --- /dev/null +++ b/test/test_box_defaults.py @@ -0,0 +1,94 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +"""Subclasses can change Box option defaults with _box_defaults (#296, #223, #210).""" + +import copy +import pickle + +import pytest + +from box import Box, BoxError, BoxList, ConfigBox, DDBox + + +class DefaultBox(Box): + _box_defaults = {"default_box": True} + + +class FrozenDefaultBox(DefaultBox): + _box_defaults = {"frozen_box": True} + + +class TestBoxDefaults: + def test_defaults_apply(self): + b = DefaultBox() + assert b.missing == DefaultBox() + assert b._box_config["default_box"] is True + assert Box()._box_config["default_box"] is False + + def test_explicit_option_wins(self): + b = DefaultBox(default_box=False) + with pytest.raises(AttributeError): + b.missing + + def test_nested_boxes_keep_class_and_options(self): + b = DefaultBox({"a": {"b": {"c": 1}}, "l": [{"x": 1}]}) + assert type(b.a) is DefaultBox and type(b.a.b) is DefaultBox + assert type(b.l[0]) is DefaultBox + assert b.a.b.missing == DefaultBox() + b.new.deep = 1 + assert type(b.new) is DefaultBox + assert b.to_dict() == {"a": {"b": {"c": 1}}, "l": [{"x": 1}], "new": {"deep": 1}} + + def test_explicit_option_carries_to_nested_boxes(self): + b = DefaultBox({"a": {"b": 1}}, default_box=False) + with pytest.raises(AttributeError): + b.a.missing + + def test_inherited_and_extended(self): + b = FrozenDefaultBox({"a": 1}) + assert b._box_config["default_box"] is True + assert b._box_config["frozen_box"] is True + with pytest.raises(BoxError): + b.a = 2 + assert DefaultBox._box_resolved_defaults == {"default_box": True} + + def test_unknown_option_is_rejected_at_class_creation(self): + with pytest.raises(BoxError, match="defualt_box"): + + class Typo(Box): + _box_defaults = {"defualt_box": True} + + def test_no_init_override_needed(self): + # The pattern people tried in #296 / #223 fails, this is the replacement + class MyConfig(Box): + _box_defaults = {"default_box": True, "box_dots": True} + + config = MyConfig() + config["server.host"] = "localhost" + assert config.to_dict() == {"server": {"host": "localhost"}} + + def test_copy_pickle_and_conversions_keep_defaults(self): + b = DefaultBox({"a": {"b": 1}}) + for other in (b.copy(), copy.deepcopy(b), pickle.loads(pickle.dumps(b)), DefaultBox.from_json(b.to_json())): + assert type(other) is DefaultBox + assert other.a.missing == DefaultBox() + + def test_box_list_conversion(self): + bl = BoxList([{"a": 1}], box_class=DefaultBox) + assert type(bl[0]) is DefaultBox + assert bl[0].missing == DefaultBox() + + def test_ddbox_uses_defaults_and_can_be_overridden(self): + dd = DDBox({"a": {"b": 1}}) + assert dd["a.b"] == 1 + assert dd.x == DDBox() + assert DDBox(default_box=False)._box_config["default_box"] is False + + def test_other_subclasses_unchanged(self): + assert ConfigBox()._box_config["default_box"] is False + assert ConfigBox._box_resolved_defaults == {} + + def test_options_are_not_data(self): + b = DefaultBox(a=1, box_dots=True) + assert b.to_dict() == {"a": 1} + assert b._box_config["box_dots"] is True diff --git a/test/test_box_keys_8.py b/test/test_box_keys_8.py new file mode 100644 index 00000000..690dc424 --- /dev/null +++ b/test/test_box_keys_8.py @@ -0,0 +1,119 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +"""Integer keys in box_dots paths (#123) and non-destructive camel killer (#279).""" + +import pytest + +from box import Box, BoxError, BoxKeyError, ConfigBox + + +class TestDotsIntegerKeys: + def test_lookup(self): + info = Box({"uno": {2: "tres", "cuatro": 5}}, default_box=True, box_dots=True) + assert info["uno.2"] == "tres" + assert info["uno.cuatro"] == 5 + assert "uno.2" in info + assert "uno.3" not in info + + def test_first_segment_and_negative(self): + b = Box({1: {"a": "x"}, "n": {-1: "neg"}}, box_dots=True) + assert b["1.a"] == "x" + assert b["n.-1"] == "neg" + assert "1.a" in b + + def test_plain_keys_are_not_mapped(self): + b = Box({2: "int"}, box_dots=True) + with pytest.raises(BoxKeyError): + b["2"] + assert "2" not in b + b["2"] = "str" + assert b.to_dict() == {2: "int", "2": "str"} + + def test_string_key_still_wins(self): + b = Box({"uno": {2: "int", "2": "str"}}, box_dots=True) + assert b["uno.2"] == "str" + assert b.uno[2] == "int" + + def test_set_and_delete_update_the_int_key(self): + b = Box({"uno": {2: "tres"}}, box_dots=True) + b["uno.2"] = "dos" + assert b.to_dict() == {"uno": {2: "dos"}} + del b["uno.2"] + assert b.to_dict() == {"uno": {}} + + def test_missing_still_missing(self): + b = Box({"uno": {2: "tres"}}, box_dots=True) + with pytest.raises(BoxKeyError): + b["uno.3"] + b2 = Box({"uno": {}}, box_dots=True, default_box=True) + assert b2["uno.3"] == Box() + + def test_not_digits_or_without_box_dots(self): + b = Box({"uno": {2: "tres", 1.5: "float"}}, box_dots=True) + with pytest.raises(BoxKeyError): + b["uno.²"] # a unicode digit, not an int + with pytest.raises(BoxKeyError): + Box({2: "tres"})["2"] + + def test_box_list_index_unchanged(self): + b = Box({"items": [{"a": 1}, {"a": 2}]}, box_dots=True) + assert b["items[1].a"] == 2 + + +class TestCamelKillerKeepKeys: + def test_round_trip_keeps_original_keys(self): + data = Box({"loadBalancer": "foo", "sneaky_snake": 1}, camel_killer_box=True, camel_killer_box_keep_keys=True) + assert data.load_balancer == "foo" + assert data.loadBalancer == "foo" + data.load_balancer = "bar" + assert data.to_dict() == {"loadBalancer": "bar", "sneaky_snake": 1} + + def test_nested_and_lists(self): + data = Box( + {"spec": {"clusterIP": "1", "ports": [{"targetPort": 80}]}}, + camel_killer_box=True, + camel_killer_box_keep_keys=True, + ) + assert data.spec.cluster_ip == "1" + assert data.spec.ports[0].target_port == 80 + data.spec.ports[0].target_port = 8080 + assert data.to_dict() == {"spec": {"clusterIP": "1", "ports": [{"targetPort": 8080}]}} + + def test_item_access_uses_original_keys(self): + data = Box({"loadBalancer": "foo"}, camel_killer_box=True, camel_killer_box_keep_keys=True) + assert data["loadBalancer"] == "foo" + with pytest.raises(BoxKeyError): + data["load_balancer"] + + def test_new_keys_and_delete(self): + data = Box({"loadBalancer": "foo"}, camel_killer_box=True, camel_killer_box_keep_keys=True) + data.newField = 1 + data.other_field = 2 + assert data.new_field == 1 + del data.load_balancer + assert data.to_dict() == {"newField": 1, "other_field": 2} + + def test_dir_lists_snake_aliases(self): + data = Box({"loadBalancer": "foo"}, camel_killer_box=True, camel_killer_box_keep_keys=True) + assert "load_balancer" in dir(data) + + def test_destructive_default_unchanged(self): + data = Box({"loadBalancer": "foo"}, camel_killer_box=True) + assert data.to_dict() == {"load_balancer": "foo"} + + def test_needs_conversion_box(self): + with pytest.raises(BoxError): + Box(camel_killer_box=True, camel_killer_box_keep_keys=True, conversion_box=False) + + def test_as_subclass_default(self): + class KubeBox(Box): + _box_defaults = {"camel_killer_box": True, "camel_killer_box_keep_keys": True} + + obj = KubeBox.from_json('{"metadata": {"resourceVersion": "1"}}') + assert obj.metadata.resource_version == "1" + assert obj.to_json() == '{"metadata": {"resourceVersion": "1"}}' + + def test_config_box(self): + cb = ConfigBox({"maxConnections": "5"}, camel_killer_box=True, camel_killer_box_keep_keys=True) + assert cb.int("max_connections") == 5 + assert cb.to_dict() == {"maxConnections": "5"} diff --git a/test/test_box_list.py b/test/test_box_list.py index 9cd90e04..469c3e98 100644 --- a/test/test_box_list.py +++ b/test/test_box_list.py @@ -3,19 +3,19 @@ # Test files gathered from json.org and yaml.org import json +import operator import os +import pickle import shutil -import sys -import platform -from pathlib import Path from io import StringIO -from test.common import test_root, tmp_dir +from pathlib import Path import pytest from ruamel.yaml import YAML from box import Box, BoxError, BoxList from box.converters import toml_read_library, toml_write_library +from test.common import test_root, tmp_dir class TestBoxList: @@ -50,6 +50,58 @@ def test_box_list(self): assert isinstance(new_list[1], BoxList) assert not isinstance(new_list.to_list(), BoxList) + @pytest.mark.parametrize("falsey", [False, True]) + def test_box_list_does_not_require_iterable_truth_value(self, falsey): + # 2026-10-10: Iterable inputs can be falsey or have no boolean value. + class Rows: + def __iter__(self): + return iter([{"value": 1}]) + + def __bool__(self): + if falsey: + return False + raise ValueError("ambiguous truth value") + + result = BoxList(Rows()) + assert len(result) == 1 + assert result[0].value == 1 + + @pytest.mark.parametrize("values", [[], [1], [1, 2], [{"SomeKey": 3}, [4]]]) + def test_extend_self(self, values, monkeypatch): + data = BoxList(values, camel_killer_box=True) + expected = data.to_list() * 2 + append = data.append + remaining = len(data) + + def bounded_append(item): + nonlocal remaining + assert remaining > 0, "extend revisited an appended element" + remaining -= 1 + append(item) + + # Bound the regression test even if extend iterates its growing destination. + monkeypatch.setattr(data, "append", bounded_append) + assert data.extend(data) is None + assert remaining == 0 + assert data.to_list() == expected + if values and isinstance(values[0], dict): + assert isinstance(data[2], Box) + assert data[2].some_key == 3 + assert isinstance(data[3], BoxList) + + def test_extend_generator_preserves_partial_progress(self): + data = BoxList([0]) + + def items(): + yield {"value": 1} + raise ValueError("unfinished input") + + with pytest.raises(ValueError, match="unfinished input"): + data.extend(items()) + assert data[0] == 0 + assert isinstance(data[1], Box) + assert data[1].value == 1 + def test_frozen_list(self): bl = BoxList([5, 4, 3], frozen_box=True) with pytest.raises(BoxError): @@ -74,6 +126,187 @@ def test_frozen_list(self): bl2[1] = 4 assert bl2[1] == 4 + def test_frozen_list_pickle(self): + for protocol in range(pickle.HIGHEST_PROTOCOL + 1): + bl = BoxList([5, 4, 3], frozen_box=True) + dumped = pickle.dumps(bl, protocol=protocol) + loaded = pickle.loads(dumped) + assert loaded == [5, 4, 3] + assert loaded.box_options.get("frozen_box") is True + with pytest.raises(BoxError): + loaded.append(2) + with pytest.raises(BoxError): + loaded.extend([1]) + with pytest.raises(BoxError): + loaded.pop(0) + with pytest.raises(BoxError): + loaded.remove(5) + with pytest.raises(BoxError): + loaded.insert(0, 9) + with pytest.raises(BoxError): + loaded.reverse() + with pytest.raises(BoxError): + loaded.sort() + with pytest.raises(BoxError): + del loaded[0] + with pytest.raises(BoxError): + loaded[0] = 99 + + empty_bl = BoxList([], frozen_box=True) + empty_dumped = pickle.dumps(empty_bl, protocol=protocol) + empty_loaded = pickle.loads(empty_dumped) + assert empty_loaded == [] + assert empty_loaded.box_options.get("frozen_box") is True + with pytest.raises(BoxError): + empty_loaded.append(1) + + def test_box_list_pickle(self): + for protocol in range(pickle.HIGHEST_PROTOCOL + 1): + bl = BoxList([1, 2, 3]) + dumped = pickle.dumps(bl, protocol=protocol) + loaded = pickle.loads(dumped) + assert loaded == [1, 2, 3] + assert not loaded.box_options.get("frozen_box") + loaded.append(4) + assert loaded == [1, 2, 3, 4] + loaded[0] = 9 + assert loaded[0] == 9 + del loaded[0] + assert loaded == [2, 3, 4] + + def test_deepcopy_preserves_box_options(self): + import copy + + # deepcopy must preserve box_options, matching __copy__ and Box.__deepcopy__ + for options in ( + {"frozen_box": True}, + {"box_dots": True}, + {"default_box": True}, + {"box_intact_types": (dict,)}, + ): + bl = BoxList([{"a": 1}], **options) + key = list(options)[0] + assert copy.copy(bl).box_options.get(key) == options[key] + assert copy.deepcopy(bl).box_options.get(key) == options[key] + + # a frozen BoxList must stay frozen (immutable + hashable) after deepcopy + frozen = BoxList([5, 4, 3], frozen_box=True) + clone = copy.deepcopy(frozen) + with pytest.raises(BoxError): + clone.append(1) + assert hash(clone) == hash(frozen) + + @pytest.mark.parametrize("index", [0, -1, "[0]", "[1]"]) + @pytest.mark.parametrize("container", ["mapping", "sequence"]) + def test_assigned_containers_are_converted(self, index, container): + class ChildBox(Box): + pass + + data = BoxList([None], box_dots=True, default_box=True, camel_killer_box=True, box_class=ChildBox) + value = {"SomeKey": 7} if container == "mapping" else [{"SomeKey": 7}] + data[index] = value + assigned = data[1 if index == "[1]" else 0] + if container == "sequence": + assert isinstance(assigned, BoxList) + assigned = assigned[0] + assert isinstance(assigned, ChildBox) + assert assigned.some_key == 7 + assert assigned._box_config["box_dots"] is True + + @pytest.mark.parametrize( + "selection, count", [(slice(1, 2), 2), (slice(None, None, 2), 2), (slice(None, None, -1), 3), (slice(2, 2), 2)] + ) + def test_slice_assignment_converts_containers(self, selection, count): + data = BoxList([0, 1, 2], camel_killer_box=True) + values = [{"SomeKey": number} if number % 2 == 0 else [{"SomeKey": number}] for number in range(count)] + expected = [0, 1, 2] + expected[selection] = [ + {"some_key": number} if number % 2 == 0 else [{"some_key": number}] for number in range(count) + ] + data[selection] = (value for value in values) + assert data.to_list() == expected + for value in data: + if isinstance(value, dict): + assert isinstance(value, Box) + assert value.some_key in range(count) + elif isinstance(value, list): + assert isinstance(value, BoxList) + assert isinstance(value[0], Box) + assert value[0].some_key in range(count) + + @pytest.mark.parametrize("index", [0, "[0]", slice(None)]) + def test_assignment_respects_intact_types(self, index): + value = {"SomeKey": 7} + data = BoxList([None], box_dots=True, box_intact_types=(dict,)) + data[index] = [value] if isinstance(index, slice) else value + assert data[0] is value + + @pytest.mark.parametrize("index", [0, "[0]", slice(None)]) + def test_frozen_assignment_keeps_contents(self, index): + data = BoxList([1], frozen_box=True, box_dots=True) + with pytest.raises(BoxError): + data[index] = [{"key": 2}] if isinstance(index, slice) else {"key": 2} + assert data == [1] + + def test_invalid_slice_assignment_keeps_contents(self): + data = BoxList([0, 1, 2]) + with pytest.raises(ValueError): + data[::2] = [{"key": 1}] + assert data == [0, 1, 2] + with pytest.raises(TypeError): + data[:] = 3 + assert data == [0, 1, 2] + + @pytest.mark.parametrize("replacement_kind", ["generator", "iterable", "noniterable"]) + def test_zero_step_does_not_consume_replacements(self, replacement_kind): + consumed = [] + + def replacements(): + consumed.append(True) + yield {"key": 1} + + class Unreadable: + def __iter__(self): + raise RuntimeError("replacement must not be read") + + value = {"generator": replacements(), "iterable": Unreadable(), "noniterable": 3}[replacement_kind] + data = BoxList([0, 1, 2]) + with pytest.raises(ValueError, match="slice step cannot be zero"): + data[::0] = value + assert consumed == [] + assert data == [0, 1, 2] + + @pytest.mark.parametrize("bounds", [(0, 4, 1), (3, -5, -2)]) + def test_slice_bounds_are_evaluated_once_before_replacements(self, bounds): + def assign(list_type): + events = [] + + class Index: + def __init__(self, name, value): + self.name = name + self.value = value + + def __index__(self): + events.append(self.name) + return self.value + + class Replacements: + def __iter__(self): + events.append("iter") + return iter([8, 9]) + + selection = slice(*(Index(name, value) for name, value in zip(("start", "stop", "step"), bounds))) + data = list_type([0, 1, 2, 3]) + data[selection] = Replacements() + return data, events + + expected, expected_events = assign(list) + actual, actual_events = assign(BoxList) + assert actual == expected + assert actual_events == expected_events + assert sorted(actual_events[:3]) == ["start", "step", "stop"] + assert actual_events[3:] == ["iter"] + def test_box_list_to_json(self): bl = BoxList([{"item": 1, "CamelBad": 2}]) assert json.loads(bl.to_json())[0]["item"] == 1 @@ -151,7 +384,7 @@ def test_from_csv(self): bl = BoxList.from_csv(filename=Path(test_root, "data", "csv_file.csv")) assert bl[1].Name == "Sam" b2 = BoxList.from_csv( - "Number,Name,Country\r\n1,Chris,US\r\n2,Sam" ",US\r\n3,Jess,US\r\n4,Frank,UK\r\n5,Demo,CA\r\n" + "Number,Name,Country\r\n1,Chris,US\r\n2,Sam,US\r\n3,Jess,US\r\n4,Frank,UK\r\n5,Demo,CA\r\n" ) assert b2[2].Name == "Jess" @@ -222,6 +455,61 @@ def test_box_list_dots(self): for key in keys: db[key] + @pytest.mark.parametrize("key", ["[x]", "[]", "[", "[1x]"]) + @pytest.mark.parametrize("default_box", [False, True]) + def test_box_list_dots_invalid_get(self, key, default_box): + data = BoxList([{"value": 1}], box_dots=True, default_box=default_box) + with pytest.raises(BoxError) as error: + data[key] + assert "Invalid list index" in str(error.value) + assert repr(key) in str(error.value) + assert data.to_list() == [{"value": 1}] + + @pytest.mark.parametrize("key", ["[x]", "[]", "[", "[1x]"]) + @pytest.mark.parametrize("default_box", [False, True]) + def test_box_list_dots_invalid_set(self, key, default_box): + data = BoxList([{"value": 1}], box_dots=True, default_box=default_box) + with pytest.raises(BoxError) as error: + data[key] = 2 + assert "Invalid list index" in str(error.value) + assert repr(key) in str(error.value) + assert data.to_list() == [{"value": 1}] + + @pytest.mark.parametrize("key", ["[x]", "[]", "[", "[1x]"]) + @pytest.mark.parametrize("default_box", [False, True]) + def test_box_list_dots_invalid_delete(self, key, default_box): + data = BoxList([{"value": 1}], box_dots=True, default_box=default_box) + with pytest.raises(BoxError) as error: + del data[key] + assert "Invalid list index" in str(error.value) + assert repr(key) in str(error.value) + assert data.to_list() == [{"value": 1}] + + @pytest.mark.parametrize("method, args", [("__getitem__", ()), ("__setitem__", (2,)), ("__delitem__", ())]) + def test_box_list_dots_invalid_nested_index(self, method, args): + data = BoxList([[1]], box_dots=True) + with pytest.raises(BoxError) as error: + getattr(data, method)("[0][x]", *args) + assert "Invalid list index: '[x]'" in str(error.value) + assert data.to_list() == [[1]] + + def test_box_list_dots_frozen_invalid_index(self): + data = BoxList([1], box_dots=True, frozen_box=True) + with pytest.raises(BoxError, match="Invalid list index"): + data["[x]"] + with pytest.raises(BoxError, match="BoxList is frozen"): + data["[x]"] = 2 + with pytest.raises(BoxError, match="BoxList is frozen"): + del data["[x]"] + assert data.to_list() == [1] + + @pytest.mark.parametrize("method, args", [("__getitem__", ()), ("__setitem__", (2,)), ("__delitem__", ())]) + def test_box_list_invalid_index_without_dots(self, method, args): + data = BoxList([1], box_dots=False) + with pytest.raises(TypeError, match="list indices must be integers or slices"): + getattr(data, method)("[x]", *args) + assert data.to_list() == [1] + def test_box_list_default_dots(self): box_1 = Box(default_box=True, box_dots=True) box_1["a[0]"] = 42 @@ -241,6 +529,24 @@ def test_box_list_default_dots(self): box_3["a.b[0]"] = 42 assert box_3.a.b[0] == 42 + # A second dotted write into an existing list element must not discard + # the keys already written there (regression). + box_4 = Box(default_box=True, box_dots=True) + box_4["a[0].x"] = 1 + box_4["a[0].y"] = 2 + assert box_4.a[0].to_dict() == {"x": 1, "y": 2} + + box_5 = Box(default_box=True, box_dots=True) + box_5["a[0][0].x"] = 1 + box_5["a[0][1].y"] = 2 + assert box_5.a[0].to_list() == [{"x": 1}, {"y": 2}] + + # A scalar already at the position is still overwritten. + box_6 = Box(default_box=True, box_dots=True) + box_6["a[0]"] = 5 + box_6["a[0].x"] = 1 + assert box_6.a[0].to_dict() == {"x": 1} + def test_box_config_propagate(self): structure = Box(a=[Box(default_box=False)], default_box=True, box_inherent_settings=True) assert structure._box_config["default_box"] is True @@ -274,3 +580,89 @@ def test_circular_references(self): circular_list.append(circular_list) circular_box = BoxList(circular_list) assert circular_box[0] == circular_box + + +@pytest.mark.parametrize( + "mutate, expected", + [ + (lambda value: value.clear(), []), + (lambda value: operator.iadd(value, [3]), [1, 2, 3]), + (lambda value: operator.imul(value, 2), [1, 2, 1, 2]), + (lambda value: operator.imul(value, 0), []), + ], +) +def test_frozen_list_inplace_mutations(mutate, expected): + frozen = BoxList([1, 2], frozen_box=True) + original_hash = hash(frozen) + with pytest.raises(BoxError, match="BoxList is frozen"): + mutate(frozen) + assert frozen == [1, 2] + assert hash(frozen) == original_hash + + mutable = BoxList([1, 2]) + alias = mutable + mutate(mutable) + assert mutable is alias + assert mutable == expected + + +@pytest.mark.parametrize("as_iterator", [False, True]) +def test_iadd_converts_containers_and_preserves_options(as_iterator): + class CustomBox(Box): + pass + + values = [{"someKey": 1}, [{"otherKey": 2}]] + source = iter(values) if as_iterator else values + data = BoxList([0], box_class=CustomBox, camel_killer_box=True) + original = data + + data += source + + assert data is original + assert data[0] == 0 + assert isinstance(data[1], CustomBox) + assert data[1].some_key == 1 + assert isinstance(data[2], BoxList) + assert isinstance(data[2][0], CustomBox) + assert data[2][0].other_key == 2 + assert data.box_options["box_class"] is CustomBox + assert data[2].box_options["camel_killer_box"] is True + assert values == [{"someKey": 1}, [{"otherKey": 2}]] + + +def test_iadd_respects_intact_types(): + item = {"value": 1} + data = BoxList(box_intact_types=(dict,)) + data += [item] + assert data[0] is item + + +@pytest.mark.parametrize("values", [[], [1, 2], [{"value": 1}]]) +def test_iadd_self(values): + data = BoxList(values) + original = data + data += data + assert data is original + assert data.to_list() == values + values + + +def test_iadd_partial_iterator_failure(): + def source(): + yield {"value": 1} + raise RuntimeError("source failed") + + data = BoxList() + with pytest.raises(RuntimeError, match="source failed"): + data += source() + assert len(data) == 1 + assert isinstance(data[0], Box) + assert data[0].value == 1 + + +def test_iadd_frozen_does_not_consume_source(): + source = iter([{"value": 1}]) + data = BoxList([0], frozen_box=True) + with pytest.raises(BoxError, match="BoxList is frozen"): + data += source + assert next(source) == {"value": 1} + assert data == [0] diff --git a/test/test_comments.py b/test/test_comments.py new file mode 100644 index 00000000..e685c436 --- /dev/null +++ b/test/test_comments.py @@ -0,0 +1,424 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +"""Comments on Box keys and BoxList items, read from and written to YAML (#184).""" + +import copy +import json +import pickle + +import pytest + +import box.converters as converters +from box import Box, BoxError, BoxKeyError, BoxList, ConfigBox +from box.exceptions import BoxValueError + +pytestmark = pytest.mark.skipif(not converters.ruamel_available, reason="comments need ruamel.yaml") + +DOCUMENT = """\ +# Service settings +# second line + +name: box # the name +# Where to listen +server: + host: localhost # bind address + + port: 8080 +# Things +items: +# first +- a # eol a +- b +last: 1 +# end of the document +""" + + +class TestReadAndWrite: + def test_round_trip_is_unchanged(self): + assert Box.from_yaml(DOCUMENT).to_yaml() == DOCUMENT + + def test_comments_are_read(self): + bx = Box.from_yaml(DOCUMENT) + assert bx.get_comment(None) == {"start": "Service settings\nsecond line\n", "end": "end of the document"} + assert bx.get_comment("name") == {"eol": "the name"} + assert bx.get_comment("server") == {"before": "Where to listen"} + assert bx.server.get_comment("host") == {"eol": "bind address"} + assert bx.server.get_comment("port") == {"before": ""} # the blank line + assert bx["items"].get_comment(0) == {"before": "first", "eol": "eol a"} + assert bx["items"].get_comment(1) is None + assert bx.get_comment("last") is None + + def test_data_is_unaffected(self): + bx = Box.from_yaml(DOCUMENT) + plain = {"name": "box", "server": {"host": "localhost", "port": 8080}, "items": ["a", "b"], "last": 1} + assert bx.to_dict() == plain + assert json.loads(bx.to_json()) == plain + assert bx == plain + assert Box.from_yaml(DOCUMENT) == Box(plain) + + def test_edits_keep_comments_on_their_keys(self): + bx = Box.from_yaml(DOCUMENT) + del bx.name + bx.server.port = 9090 + bx.server.timeout = 30 + bx.new = "x" + out = bx.to_yaml() + assert out.startswith("# Service settings\n# second line\n\n# Where to listen\nserver:\n") + assert " host: localhost # bind address\n\n port: 9090\n timeout: 30\n" in out + assert "the name" not in out + assert out.endswith("last: 1\nnew: x\n# end of the document\n") + + def test_comment_between_key_and_nested_value(self): + bx = Box.from_yaml("server:\n # inside\n host: x\n") + assert bx.server.get_comment("host") == {"before": "inside"} + assert bx.to_yaml() == "server:\n # inside\n host: x\n" + + def test_nested_list_of_maps(self): + src = "items:\n- a: 1 # one\n b: 2\n# second item\n- a: 3\n" + bx = Box.from_yaml(src) + assert bx["items"][0].get_comment("a") == {"eol": "one"} + assert bx["items"].get_comment(1) == {"before": "second item"} + assert bx.to_yaml() == src + + def test_document_without_comments_has_none(self): + bx = Box.from_yaml("a: 1\nb: [1, 2]\n") + assert bx.get_comment(None) is None + assert bx._box_config.get("__comments") is None + + def test_comment_only_document(self): + bx = Box.from_yaml("# nothing here\n") + assert bx == {} + + def test_numeric_keys(self): + bx = Box.from_yaml("1: one # first\n2.5: x\n") + assert bx.get_comment(1) == {"eol": "first"} + assert bx.to_yaml() == "1: one # first\n2.5: x\n" + + def test_files(self, tmp_path): + path = tmp_path / "config.yaml" + path.write_text(DOCUMENT) + bx = Box.from_yaml(filename=path) + bx.set_comment("last", "still last") + out = tmp_path / "out.yaml" + assert bx.to_yaml(filename=out) is None + assert out.read_text() == DOCUMENT.replace("last: 1\n", "last: 1 # still last\n") + + def test_box_list_documents(self): + src = "# people\n- name: a # first\n# then\n- name: b\n" + bl = BoxList.from_yaml(src) + assert bl.get_comment(None) == {"start": "people"} + assert bl[0].get_comment("name") == {"eol": "first"} + assert bl.get_comment(1) == {"before": "then"} + assert bl.to_yaml() == src + + +class TestApi: + def test_set_get_delete(self): + bx = Box(a=1, b={"c": 2}) + bx.set_comment("a", "eol text") + bx.set_comment("a", "line one\nline two", position="before") + bx.b.set_comment("c", "nested") + assert bx.get_comment("a") == {"eol": "eol text", "before": "line one\nline two"} + assert bx.to_yaml() == "# line one\n# line two\na: 1 # eol text\nb:\n c: 2 # nested\n" + bx.del_comment("a") + assert bx.get_comment("a") is None + bx.set_comment("b", "") # empty text removes that position + assert bx.get_comment("b") is None + + def test_remove_one_position(self): + bx = Box(a=1) + bx.set_comment("a", "x") + bx.set_comment("a", "y", position="before") + bx.set_comment("a", None) + assert bx.get_comment("a") == {"before": "y"} + + def test_hash_prefix_is_optional(self): + bx = Box(a=1) + bx.set_comment("a", "# already commented") + assert bx.get_comment("a") == {"eol": "already commented"} + + def test_document_comments(self): + bx = Box(a=1) + bx.set_comment(None, "header\n\nmore") + bx.set_comment(None, "footer", position="end") + assert bx.to_yaml() == "# header\n\n# more\na: 1\n# footer\n" + bx.del_comment() + assert bx.to_yaml() == "a: 1\n" + + @pytest.mark.parametrize( + "args, error", + [ + (("a", "two\nlines"), "single line"), + (("a", "x", "start"), "position must be one of 'before', 'eol'"), + ((None, "x", "eol"), "position must be one of 'start', 'end'"), + (("a", 5), "must be a string"), + ], + ) + def test_invalid(self, args, error): + with pytest.raises(BoxValueError, match=error): + Box(a=1).set_comment(*args) + + def test_missing_keys(self): + with pytest.raises(BoxKeyError, match="existing keys"): + Box().set_comment("missing", "x") + with pytest.raises(BoxKeyError): + Box().get_comment("missing") + with pytest.raises(BoxKeyError, match="existing items"): + BoxList([1]).set_comment(3, "x") + with pytest.raises(BoxKeyError): + Box(a={"b": 1}).set_comment("a.b", "x") # dotted paths need box_dots + + def test_box_dots_paths(self): + bx = Box({"a": {"b": 1}, "l": [{"x": 1}, 2]}, box_dots=True) + bx.set_comment("a.b", "deep") + bx.set_comment("l[0].x", "in a list") + bx.set_comment("l[1]", "item") + assert bx.a.get_comment("b") == {"eol": "deep"} + assert bx["l"][0].get_comment("x") == {"eol": "in a list"} + assert bx.get_comment("l[1]") == {"eol": "item"} + assert bx.get_comment("l[-1]") == {"eol": "item"} + + def test_box_dots_int_segments(self): + bx = Box({"a": {2: "two"}}, box_dots=True) + bx.set_comment("a.2", "int key") + assert bx.a.get_comment(2) == {"eol": "int key"} + + def test_negative_list_index(self): + bl = BoxList([1, 2, 3]) + bl.set_comment(-1, "last") + assert bl.get_comment(2) == {"eol": "last"} + + def test_methods_are_protected_names(self): + for name in ("get_comment", "set_comment", "del_comment"): + with pytest.raises(BoxKeyError, match="protected"): + setattr(Box(), name, 1) + + def test_frozen(self): + bx = Box.from_yaml("a: 1 # kept\n", frozen_box=True) + assert bx.get_comment("a") == {"eol": "kept"} + with pytest.raises(BoxError, match="frozen"): + bx.set_comment("a", "x") + with pytest.raises(BoxError, match="frozen"): + bx.del_comment("a") + bl = BoxList([1], frozen_box=True) + with pytest.raises(BoxError, match="frozen"): + bl.set_comment(0, "x") + + +class TestKeepingCommentsInSync: + def test_delete_pop_popitem_clear(self): + bx = Box(a=1, b=2, c=3, d=4) + for key in "abcd": + bx.set_comment(key, key) + del bx["a"] + bx.pop("b") + bx.popitem() + assert bx.get_comment("c") == {"eol": "c"} + bx["a"] = 1 + assert bx.get_comment("a") is None # a re-added key starts clean + bx.clear() + bx.c = 1 + assert bx.get_comment("c") is None + + def test_overwriting_a_value_keeps_the_comment(self): + bx = Box(a=1, b={"x": 1}) + bx.set_comment("a", "kept") + bx.set_comment("b", "kept too") + bx.a = 2 + bx.b = {"y": 2} + assert bx.get_comment("a") == {"eol": "kept"} + assert bx.get_comment("b") == {"eol": "kept too"} + + def test_merge_update_and_update_keep_existing(self): + bx = Box.from_yaml("a:\n b: 1 # keep\n") + bx.merge_update({"a": {"c": 2}}) + bx.update(z=1) + assert bx.a.get_comment("b") == {"eol": "keep"} + + def test_copy_deepcopy_pickle_and_rebuild(self): + bx = Box.from_yaml(DOCUMENT) + for other in (bx.copy(), copy.copy(bx), copy.deepcopy(bx), pickle.loads(pickle.dumps(bx)), Box(bx)): + assert other.to_yaml() == DOCUMENT + other = copy.deepcopy(bx) + other.server.set_comment("host", "changed") + assert bx.server.get_comment("host") == {"eol": "bind address"} + + def test_moving_a_subtree(self): + bx = Box.from_yaml(DOCUMENT) + target = Box() + target.settings = bx.server + assert target.settings.get_comment("host") == {"eol": "bind address"} + + def test_box_list_index_changes(self): + bl = BoxList(["a", "b", "c", "d"]) + for index in range(4): + bl.set_comment(index, "abcd"[index]) + + def comments(): + return [(bl.get_comment(i) or {}).get("eol") for i in range(len(bl))] + + bl.insert(1, "new") + assert comments() == ["a", None, "b", "c", "d"] + bl.pop(1) + assert comments() == ["a", "b", "c", "d"] + del bl[0] + assert comments() == ["b", "c", "d"] + bl.remove("c") + assert comments() == ["b", "d"] + bl.insert(-1, "x") + assert bl == ["b", "x", "d"] and comments() == ["b", None, "d"] + bl.reverse() + assert comments() == ["d", None, "b"] + bl.sort() + assert bl == ["b", "d", "x"] and comments() == ["b", "d", None] + bl.sort(key=lambda v: v == "b", reverse=True) + assert bl == ["b", "d", "x"] and comments() == ["b", "d", None] + bl.append("e") + bl += ["f"] + assert comments() == ["b", "d", None, None, None] + bl.pop() + bl[0:2] = ["y"] # slice writes drop the list's item comments + assert comments() == [None, None, None] + bl.set_comment(0, "again") + bl.clear() + bl.append(1) + assert bl.get_comment(0) is None + + def test_box_list_copies_and_pickles(self): + bl = BoxList.from_yaml("- 1 # one\n- 2\n") + for other in (copy.copy(bl), copy.deepcopy(bl), pickle.loads(pickle.dumps(bl)), BoxList(bl)): + assert other.get_comment(0) == {"eol": "one"} + + def test_config_box_any_case_and_latest_write(self): + cb = ConfigBox.from_yaml("Host: x # the host\n") + assert cb.get_comment("host") == {"eol": "the host"} + cb.set_comment("HOST", "renamed later") + cb["host"] = "y" # the latest spelling wins, the comment goes with it + assert cb.to_yaml() == "host: y # renamed later\n" + + def test_camel_killer_keys(self): + bx = Box.from_yaml("loadBalancer: x # lb\n", camel_killer_box=True) + assert bx.get_comment("load_balancer") == {"eol": "lb"} + assert bx.get_comment("loadBalancer") == {"eol": "lb"} + assert bx.to_yaml() == "load_balancer: x # lb\n" + + def test_box_dots_split_keys_lose_comments_safely(self): + bx = Box.from_yaml("a.b: 1 # dotted\n", box_dots=True, default_box=True) + assert bx.to_dict() == {"a": {"b": 1}} + assert bx.to_yaml() == "a:\n b: 1\n" + + +class TestOtherBackends: + def test_safe_dumper_ignores_comments(self): + bx = Box.from_yaml(DOCUMENT) + assert "#" not in bx.to_yaml(ruamel_typ="safe") + + def test_safe_loader_reads_none(self): + bx = Box.from_yaml(DOCUMENT, ruamel_typ="safe") + assert bx.get_comment(None) is None and bx.get_comment("name") is None + + def test_pyyaml(self, monkeypatch): + if not converters.pyyaml_available: + pytest.skip("PyYAML is not installed") + monkeypatch.setattr(converters, "ruamel_available", False) + bx = Box.from_yaml(DOCUMENT) + assert bx.get_comment("name") is None + bx.set_comment("name", "ignored by PyYAML") + assert "#" not in bx.to_yaml() + + def test_output_without_comments_is_unchanged(self): + data = {"z": 1, "a": {"b": [1, {"c": 2}]}} + assert Box(data).to_yaml() == converters._to_yaml(data) + assert BoxList([data]).to_yaml() == converters._to_yaml([data]) + + +class TestEdgeCases: + def test_missing_keys_and_paths(self): + with pytest.raises(BoxKeyError): + Box(camel_killer_box=True).set_comment("missingKey", "x") + dotted = Box({"a": 1, "l": [1]}, box_dots=True) + for key in ("nope.x", "a.x", "l[0].x", "l[5]", "l[x]", "l.x"): + with pytest.raises(BoxKeyError): + dotted.set_comment(key, "x") + with pytest.raises(BoxKeyError): + BoxList([1]).set_comment(1.5, "x") + + def test_delete_without_comments(self): + bx = Box(a=1) + bx.del_comment("a") + bl = BoxList([1]) + bl.del_comment(0) + bl.set_comment(0, "x") + bl.del_comment(0) + assert bl.get_comment(0) is None + + def test_box_list_document_and_positions(self): + bl = BoxList([1, 2]) + bl.set_comment(None, "top") + bl.set_comment(0, "above", position="before") + bl.set_comment(0, None, position="before") + assert bl.get_comment(0) is None + assert copy.copy(bl).get_comment(None) == {"start": "top"} + bl.del_comment() + assert bl.get_comment(None) is None + + def test_box_list_without_comments_keeps_working(self): + bl = BoxList([3, 1, 2]) + bl.sort() + bl.reverse() + del bl[0:1] + assert bl == [2, 1] + + def test_slice_delete_drops_item_comments(self): + bl = BoxList([1, 2, 3]) + bl.set_comment(2, "x") + del bl[0:1] + assert bl.get_comment(1) is None + + def test_empty_comment_and_missing_final_newline(self): + bx = Box.from_yaml("a: 1 #\nb: 2 # two\n# end") + assert bx.get_comment("a") is None + assert bx.get_comment("b") == {"eol": "two"} + assert bx.get_comment(None) == {"end": "end"} + + def test_frozen_lists_skip_item_comments(self): + bx = Box.from_yaml("l:\n- a: 1 # in a frozen list\n", frozen_box=True) + assert bx.to_dict() == {"l": ({"a": 1},)} # frozen boxes store lists as tuples + + def test_box_dots_split_parent_key(self): + bx = Box.from_yaml("a.b:\n c: 1 # c\n", box_dots=True, default_box=True) + assert bx.to_dict() == {"a": {"b": {"c": 1}}} + + def test_self_reference(self): + bx = Box(a=1) + dict.__setitem__(bx, "me", bx) # Box itself never builds cycles, guard against them anyway + assert bx.to_yaml() == "&id001\na: 1\nme: *id001\n" + bx.set_comment("a", "x") + assert "a: 1 # x" in bx.to_yaml() + + +class TestCommentTextIsNeverYaml: + @pytest.mark.parametrize("brk", ["\n", "\r", "\r\n", "\x85", "\u2028", "\u2029"]) + def test_end_of_line_comments_reject_every_line_break(self, brk): + with pytest.raises(BoxValueError, match="single line"): + Box(a=1).set_comment("a", f"x{brk}injected: 1") + + @pytest.mark.parametrize("brk", ["\n", "\r", "\r\n", "\x85", "\u2028", "\u2029"]) + @pytest.mark.parametrize("key, position", [("a", "before"), (None, "start"), (None, "end")]) + def test_multi_line_comments_stay_comments(self, brk, key, position): + bx = Box(a=1) + bx.set_comment(key, f"one{brk}injected: 1", position=position) + out = bx.to_yaml() + assert Box.from_yaml(out).to_dict() == {"a": 1}, out + assert "# injected: 1" in out + + @pytest.mark.parametrize("char", ["\x00", "\x08", "\x0b", "\x0c", "\x1b", "\x7f"]) + def test_control_characters_are_rejected(self, char): + with pytest.raises(BoxValueError, match="control characters"): + Box(a=1).set_comment("a", f"x{char}y", position="before") + + def test_tabs_are_fine(self): + bx = Box(a=1) + bx.set_comment("a", "x\ty") + assert Box.from_yaml(bx.to_yaml()).get_comment("a") == {"eol": "x\ty"} diff --git a/test/test_config_box.py b/test/test_config_box.py index 345ed55b..59089df2 100644 --- a/test/test_config_box.py +++ b/test/test_config_box.py @@ -1,9 +1,8 @@ #!/usr/bin/env python # -*- coding: utf-8 -*- -from test.common import test_dict - from box import Box, ConfigBox +from test.common import test_dict class TestConfigBox: diff --git a/test/test_config_box_case.py b/test/test_config_box_case.py new file mode 100644 index 00000000..95f5f9c5 --- /dev/null +++ b/test/test_config_box_case.py @@ -0,0 +1,222 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +"""ConfigBox string keys are case-insensitive and the latest write wins (#314).""" + +import copy +import pickle +import time + +import pytest + +from box import Box, BoxError, ConfigBox + + +class TestConfigBoxCaseInsensitive: + def test_lookup_any_case(self): + cb = ConfigBox({"HOST": "localhost", "ServerPort": 8080}) + assert cb["host"] == cb["Host"] == cb.host == cb.HOST == "localhost" + assert cb.serverport == cb["SERVERPORT"] == 8080 + assert "host" in cb and "serverPORT" in cb and "nope" not in cb + assert cb.get("host") == "localhost" + assert cb.get("nope", 5) == 5 + + def test_transforms_any_case(self): + cb = ConfigBox({"Flag": "yes", "Count": "5", "Ratio": "1.5", "Items": "a, b"}) + assert cb.bool("flag") is True + assert cb.int("COUNT") == 5 + assert cb.getfloat("ratio") == 1.5 + assert cb.list("items") == ["a", "b"] + + def test_latest_write_wins_on_construction(self): + assert ConfigBox({"Foo": 1, "foo": 2}).to_dict() == {"foo": 2} + assert ConfigBox({"Foo": 1, "foo": 2, "FOO": 3}).to_dict() == {"FOO": 3} + assert ConfigBox(A=1, a=2).to_dict() == {"a": 2} + assert ConfigBox.from_json('{"Foo": 1, "foo": 2}').to_dict() == {"foo": 2} + + def test_latest_write_wins_on_assignment(self): + cb = ConfigBox({"host": "a", "port": 1}) + cb["HOST"] = "b" + assert cb.to_dict() == {"port": 1, "HOST": "b"} + cb.Host = "c" + assert cb.to_dict() == {"port": 1, "Host": "c"} + cb.Host = "d" # same spelling replaces in place + assert list(cb.keys()) == ["port", "Host"] + assert cb.host == "d" + + def test_update_and_merge_update_agree(self): + for method in ("update", "merge_update"): + cb = ConfigBox({"Host": "h", "port": 1}) + getattr(cb, method)({"HOST": "u"}) + assert cb.to_dict() == {"port": 1, "HOST": "u"}, method + getattr(cb, method)(host="v") + assert cb.to_dict() == {"port": 1, "host": "v"}, method + getattr(cb, method)([("Host", "w")]) + assert cb.to_dict() == {"port": 1, "Host": "w"}, method + cb = ConfigBox() + cb.update({"a": 1, "A": 2}) + assert cb.to_dict() == {"A": 2} + + def test_merge_update_merges_nested_and_takes_spelling(self): + cb = ConfigBox({"Server": {"host": "h", "port": 1}}) + cb.merge_update({"SERVER": {"PORT": 2}}) + assert cb.to_dict() == {"SERVER": {"host": "h", "PORT": 2}} + assert cb.server.port == 2 + cb.merge_update(iter([("server", {"x": 1})])) # one-shot iterators are only consumed once + assert cb.to_dict() == {"server": {"host": "h", "PORT": 2, "x": 1}} + + def test_union_right_side_wins(self): + assert (ConfigBox({"Foo": 1, "bar": 2}) | {"FOO": 3}).to_dict() == {"bar": 2, "FOO": 3} + + def test_delete_and_pop_any_case(self): + cb = ConfigBox({"HOST": 1, "Port": 2, "user": 3}) + del cb["host"] + assert cb.pop("PORT") == 2 + del cb.USER + assert cb.to_dict() == {} + assert "host" not in cb + with pytest.raises(KeyError): + del cb["host"] + + def test_setdefault_keeps_existing(self): + cb = ConfigBox({"Host": "h"}) + assert cb.setdefault("host", "x") == "h" + assert cb.to_dict() == {"Host": "h"} + + def test_popitem_and_clear_keep_index_in_sync(self): + cb = ConfigBox({"A": 1, "B": 2}) + assert cb.popitem() == ("B", 2) + assert "b" not in cb and "a" in cb + cb.clear() + assert "a" not in cb + cb["A"] = 1 + assert cb.a == 1 + + @pytest.mark.parametrize("key", [1, None, (1, 2), 1.5, b"Bytes"]) + def test_non_string_keys_match_exactly(self, key): + cb = ConfigBox({key: "v"}) + assert cb[key] == "v" + assert key in cb + assert 999 not in cb + del cb[key] + assert key not in cb + assert b"bytes" not in ConfigBox({b"Bytes": 1}) + + def test_missing_keys_raise_keyerror(self): + with pytest.raises(KeyError): + ConfigBox({"a": 1})[5] + with pytest.raises(KeyError): + ConfigBox({"a": 1})["b"] + with pytest.raises(AttributeError): + ConfigBox({"a": 1}).b + + def test_unhashable_in_raises_typeerror_like_dict(self): + with pytest.raises(TypeError): + [] in ConfigBox({"a": 1}) + + def test_mixed_str_and_non_str_keys(self): + cb = ConfigBox({1: "one", "One": "word"}) + cb["ONE"] = "WORD" + assert cb.to_dict() == {1: "one", "ONE": "WORD"} + + def test_box_duplicates_error_still_raises(self): + with pytest.raises(BoxError): + ConfigBox({"a_b": 1, "a b": 2}, box_duplicates="error") + # A different case is replaced rather than reported as a duplicate + assert ConfigBox({"A_B": 1, "a_b": 2}, box_duplicates="error").to_dict() == {"a_b": 2} + + def test_conversion_alias_follows_new_spelling(self): + cb = ConfigBox({"My Key": 1}) + assert cb.My_Key == 1 + cb["my key"] = 2 + assert cb.my_key == 2 + assert cb.to_dict() == {"my key": 2} + + def test_nested_boxes_are_case_insensitive(self): + cb = ConfigBox({"Database": {"Host": "h"}}) + assert isinstance(cb.database, ConfigBox) + assert cb.DATABASE.host == "h" + cb.database.HOST = "x" + assert cb.to_dict() == {"Database": {"HOST": "x"}} + + def test_box_dots_any_case(self): + cb = ConfigBox({"Server": {"Host": "h", "Ports": [1, 2]}}, box_dots=True) + assert cb["server.host"] == "h" + assert cb["SERVER.ports[1]"] == 2 + assert "server.HOST" in cb + cb["server.host"] = "x" + assert cb.to_dict() == {"Server": {"host": "x", "Ports": [1, 2]}} + del cb["SERVER.HOST"] + assert cb.to_dict() == {"Server": {"Ports": [1, 2]}} + + def test_box_dots_literal_dotted_key(self): + cb = ConfigBox({"A.B": 1}, box_dots=True, box_dots_exclude=r"(?i)a\.b") + assert cb["a.b"] == 1 + cb["a.b"] = 2 + assert cb.to_dict() == {"a.b": 2} + + def test_default_box_any_case(self): + cb = ConfigBox({"Host": "h"}, default_box=True) + assert cb.host == "h" + cb.HOST = "x" + assert cb.to_dict() == {"HOST": "x"} + + def test_default_box_created_key_found_any_case(self): + cb = ConfigBox(default_box=True) + cb.Section.Key = 1 + assert cb.section.key == 1 + assert cb.to_dict() == {"Section": {"Key": 1}} + + def test_stale_ephemeral_child_is_not_attached(self): + cb = ConfigBox(default_box=True, default_box_create_on_get=False) + child = cb.Section + cb["SECTION"] = {"a": 1} + child.b = 2 + assert cb.to_dict() == {"SECTION": {"a": 1}} + + def test_frozen(self): + cb = ConfigBox({"Host": "h", "host": "x"}, frozen_box=True) + assert cb.to_dict() == {"host": "x"} + assert cb.HOST == "x" + for action in ( + lambda: cb.__setitem__("HOST", 1), + lambda: cb.update(HOST=1), + lambda: cb.merge_update(HOST=1), + lambda: cb.__delitem__("HOST"), + ): + with pytest.raises(BoxError): + action() + assert cb.to_dict() == {"host": "x"} + + def test_copy_pickle_round_trip(self): + cb = ConfigBox({"Host": "h", "Nested": {"Key": 1}}) + for other in (cb.copy(), copy.deepcopy(cb), pickle.loads(pickle.dumps(cb))): + assert type(other) is ConfigBox + assert other.host == "h" and other.nested.key == 1 + other["HOST"] = "x" + assert other.to_dict() == {"Nested": {"Key": 1}, "HOST": "x"} + assert cb.to_dict() == {"Host": "h", "Nested": {"Key": 1}} + + def test_plain_box_unchanged(self): + bx = Box({"Foo": 1, "foo": 2}) + assert bx.to_dict() == {"Foo": 1, "foo": 2} + with pytest.raises(KeyError): + bx["FOO"] + + def test_index_survives_direct_dict_writes(self): + cb = ConfigBox({"a": 1}) + assert "A" in cb + dict.__setitem__(cb, "New", 2) # bypasses ConfigBox, as some Box internals do + assert cb.new == 2 + + def test_large_box_misses_and_construction_are_fast(self): + start = time.perf_counter() + cb = ConfigBox({f"Key{i}": i for i in range(20000)}) + built = time.perf_counter() - start + start = time.perf_counter() + for _ in range(2000): + assert "nope" not in cb + assert cb.get("KEY19999") == 19999 + lookups = time.perf_counter() - start + # Generous limits: a scan of every key per miss takes seconds here, quadratic construction minutes + assert built < 5 + assert lookups < 1 diff --git a/test/test_converters.py b/test/test_converters.py index d66b75b0..011436cf 100644 --- a/test/test_converters.py +++ b/test/test_converters.py @@ -4,14 +4,14 @@ import os import shutil from pathlib import Path -from test.common import movie_data, tmp_dir import msgpack import pytest from ruamel.yaml import YAML -from box import BoxError +from box import Box, BoxError, BoxList from box.converters import _from_toml, _to_json, _to_msgpack, _to_toml, _to_yaml +from test.common import movie_data, tmp_dir toml_string = """[movies.Spaceballs] imdb_stars = 7.1 @@ -75,6 +75,53 @@ def test_to_json(self): assert "Rick Moranis" in open(m_file).read() assert json.load(open(m_file)) == json.loads(movie_string) + @pytest.mark.parametrize("box_type", [Box, BoxList]) + @pytest.mark.parametrize("to_file", [False, True]) + @pytest.mark.parametrize( + "ensure_ascii, expected", + [ + (None, '{"café": "你好😀"}'), + (False, '{"café": "你好😀"}'), + (True, r'{"caf\u00e9": "\u4f60\u597d\ud83d\ude00"}'), + ], + ) + def test_to_json_ensure_ascii(self, box_type, to_file, ensure_ascii, expected, tmp_path): + data = {"café": "你好😀"} + if box_type is BoxList: + data = [data] + expected = f"[{expected}]" + value = box_type(data) + kwargs = {} if ensure_ascii is None else {"ensure_ascii": ensure_ascii} + + if to_file: + filename = tmp_path / "unicode.json" + encoding = "ascii" if ensure_ascii else "utf-8" + assert value.to_json(filename=filename, encoding=encoding, **kwargs) is None + actual = filename.read_text(encoding=encoding) + else: + actual = value.to_json(**kwargs) + + assert actual == expected + assert json.loads(actual) == data + + @pytest.mark.parametrize("ensure_ascii", [None, False, True]) + def test_to_json_multiline_ensure_ascii(self, ensure_ascii, tmp_path): + value = BoxList([{"text": "你好"}, {"text": "😀"}]) + kwargs = {} if ensure_ascii is None else {"ensure_ascii": ensure_ascii} + filename = tmp_path / "unicode.jsonl" + + assert value.to_json(filename=filename, multiline=True, **kwargs) is None + + expected = '{"text": "你好"}\n{"text": "😀"}' + if ensure_ascii: + expected = r'{"text": "\u4f60\u597d"}' + "\n" + r'{"text": "\ud83d\ude00"}' + assert filename.read_text(encoding="utf-8") == expected + + def test_to_json_ensure_ascii_with_other_options(self): + value = Box(z="你好", a=1) + + assert value.to_json(ensure_ascii=True, sort_keys=True, separators=(",", ":")) == r'{"a":1,"z":"\u4f60\u597d"}' + def test_to_yaml(self): m_file = os.path.join(tmp_dir, "movie_data") movie_string = _to_yaml(movie_data) @@ -94,5 +141,5 @@ def test_to_msgpack(self): def test_to_yaml_ruamel(self): movie_string = _to_yaml(movie_data, ruamel_attrs={"width": 12}) - multiline_except = """ - name: \n Roger\n Rees\n imdb: \n nm0715953\n role: \n Sheriff\n of \n Rottingham\n - name: \n Amy \n Yasbeck""" + multiline_except = """ - name: \n Roger\n Rees\n imdb: \n nm0715953\n role: \n Sheriff\n of \n Rottingham\n - name: \n Amy \n Yasbeck""" # noqa: E501 assert multiline_except in movie_string diff --git a/test/test_coverage_paths.py b/test/test_coverage_paths.py new file mode 100644 index 00000000..a60b7a9a --- /dev/null +++ b/test/test_coverage_paths.py @@ -0,0 +1,373 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +"""Behaviour of less travelled code paths: error branches, optional backends and fallbacks.""" + +import sys +import types + +import pytest + +import box.converters as converters +import box.from_file as from_file +from box import Box, BoxError, BoxKeyError, BoxList, ConfigBox, box_from_file, box_from_string +from box.box import _parse_box_dots +from box.exceptions import BoxTypeError + + +@pytest.fixture +def fake_ipython(monkeypatch): + module = types.ModuleType("IPython") + module.get_ipython = lambda: object() + monkeypatch.setitem(sys.modules, "IPython", module) + return module + + +class TestBoxPaths: + def test_ipython_probes_are_not_defaulted(self, fake_ipython): + b = Box(default_box=True) + assert b.getdoc is None + assert b.shape is None + assert b.other == Box() + + def test_ipython_installed_but_not_running(self, fake_ipython, monkeypatch): + monkeypatch.setattr(fake_ipython, "get_ipython", lambda: None) + assert Box(default_box=True).shape == Box() + + def test_parse_box_dots_without_separator(self): + with pytest.raises(BoxError): + _parse_box_dots(Box(), "nodots") + + def test_tuple_holding_box_list_to_dict(self): + b = Box({"a": (BoxList([1, {"x": 1}]), Box(y=2))}) + assert b.to_dict() == {"a": ([1, {"x": 1}], {"y": 2})} + assert type(b.to_dict()["a"][0]) is list + assert type(b.to_dict()["a"][0][1]) is dict + + def test_default_box_attr_function_arguments(self): + def positional(key, box_instance): + return f"{key}-{type(box_instance).__name__}" + + def keyword(*, key, box_instance): + return f"{key}:{type(box_instance).__name__}" + + assert Box(default_box=True, default_box_attr=positional).hi == "hi-Box" + assert Box(default_box=True, default_box_attr=keyword).hi == "hi:Box" + + def bad(name): + return name + + with pytest.raises(BoxError, match="only have the required arguments .key. and .box_instance., not .name."): + Box(default_box=True, default_box_attr=bad).hi + + def test_create_on_get_dotted_through_non_container(self): + b = Box({"a": 5}, default_box=True, box_dots=True, default_box_create_on_get=True) + assert b["a.b"] == Box() + assert b.to_dict() == {"a": 5} + + def test_unhashable_key(self): + with pytest.raises(BoxTypeError): + Box()[["unhashable"]] + + def test_ephemeral_child_of_frozen_box(self): + b = Box(default_box=True, frozen_box=True) + child = b.missing + with pytest.raises(BoxError, match="frozen"): + child.x = 1 + assert b.to_dict() == {} + + def test_ephemeral_child_without_conversion_box(self): + b = Box(default_box=True, conversion_box=False) + b.new.key = 1 + assert b.to_dict() == {"new": {"key": 1}} + + def test_dotted_set_without_parent(self): + with pytest.raises(BoxKeyError, match="has no attribute a"): + Box(box_dots=True)["a.b"] = 1 + + def test_dotted_paths_through_non_containers(self): + b = Box({"a": 5}, box_dots=True) + with pytest.raises(BoxKeyError): + b["a.b"] + assert "a.b" not in b + b["a.b"] = 1 # the int can't hold "b", so the whole key is stored + assert b.to_dict() == {"a": 5, "a.b": 1} + del b["a.b"] + assert b.to_dict() == {"a": 5} + b2 = Box({"a": 5}, box_dots=True) + with pytest.raises(BoxKeyError): + del b2["a.b"] + + def test_dotted_contains_into_box_list(self): + b = Box({"a": [1, 2]}, box_dots=True) + assert "a.b" not in b + + def test_camel_killer_delete_non_string_key(self): + b = Box({1: "a"}, camel_killer_box=True) + with pytest.raises(BoxKeyError): + del b[2] + del b[1] + assert b == {} + + def test_merge_update_too_many_arguments(self): + with pytest.raises(BoxTypeError, match="at most 1 argument"): + Box().merge_update({"a": 1}, b=2) + + def test_setdefault_with_list_path(self): + b = Box({"a": [1, 2]}, box_dots=True) + assert b.setdefault("a[1]", 5) == 2 + assert b.to_dict() == {"a": [1, 2]} + + def test_keep_keys_non_string_key(self): + b = Box({1: "a", "camelCase": 2}, camel_killer_box=True, camel_killer_box_keep_keys=True) + assert b[1] == "a" + assert b.camel_case == 2 + + def test_operators_with_boxes(self): + assert (Box(a=1) + Box(b=2)).to_dict() == {"a": 1, "b": 2} + assert (Box(a=1) | Box(b=2)).to_dict() == {"a": 1, "b": 2} + + def test_subtract_nested_keeps_differences(self): + result = Box(a={"x": 1, "y": 2}, b=1) - Box(a={"x": 1}) + assert result.to_dict() == {"a": {"y": 2}, "b": 1} + + def test_reflected_operators_with_box(self): + assert Box(a=1).__radd__(Box(b=2)).to_dict() == {"b": 2, "a": 1} + assert Box(a=1).__ror__(Box(a=2, b=2)).to_dict() == {"a": 1, "b": 2} + + def test_ephemeral_unfrozen_child_of_frozen_box(self): + class Other(Box): + pass + + b = Box(default_box=True, frozen_box=True, default_box_attr=Other) + child = b.missing + assert type(child) is Other + with pytest.raises(BoxError, match="frozen"): + child.x = 1 + assert b.to_dict() == {} + + def test_dir_skips_keys_without_attribute_name(self): + names = dir(Box({"...": 1, "ok": 2}, box_safe_prefix="")) + assert "ok" in names and "" not in names + + def test_dir_without_conversion_box(self): + names = dir(Box({"good": 1, "not valid": 2}, conversion_box=False)) + assert "good" in names + assert "not valid" not in names and "not_valid" not in names + + +class TestBoxListPaths: + def test_tuple_indexing_into_non_list(self): + bl = BoxList([[1, 2], {"a": 1}]) + assert bl[0, 1] == 2 + with pytest.raises(BoxTypeError, match="numpy-style"): + bl[1, 0] + + def test_dotted_delete_into_non_container(self): + bl = BoxList([5], box_dots=True) + with pytest.raises(TypeError): + del bl["[0].x"] + assert bl == [5] + + +class TestBoxListPickleFormats: + def test_loads_box_7_pickles(self, monkeypatch): + import pickle + + # Box 7 had no __reduce_ex__: items were appended first, then the instance state restored + with monkeypatch.context() as patch: + patch.delattr(BoxList, "__reduce_ex__") + data = pickle.dumps(BoxList([1, {"a": 1}], box_dots=True), protocol=2) + out = pickle.loads(data) + assert type(out) is BoxList + assert out.to_list() == [1, {"a": 1}] + assert out.box_options["box_dots"] is True + + def test_self_referencing_items_survive_pickle(self): + import pickle + + bl = BoxList([{"a": 1}]) + bl[0].parent = bl + out = pickle.loads(pickle.dumps(bl)) + assert out[0].parent is out + + +class TestConfigBoxPaths: + def test_update_non_string_and_exact_keys(self): + cb = ConfigBox({"a": 1}) + cb.update({1: "one", "a": 2}) + assert cb.to_dict() == {"a": 2, 1: "one"} + + def test_missing_dotted_key(self): + cb = ConfigBox({"a": {"b": 1}}, box_dots=True) + assert "nope.x" not in cb + assert cb["A.B"] == 1 + + def test_index_rebuilds_after_direct_dict_write(self): + cb = ConfigBox({"a": 1}) + assert "A" in cb # builds the lower case index + dict.__setitem__(cb, "Raw", 2) + cb["b"] = 3 # the index is stale: dropped and rebuilt on the next lookup + assert cb.raw == 2 and cb.B == 3 + + def test_index_rebuilds_after_direct_write_then_exact_write(self): + cb = ConfigBox({"a": 1}) + assert "A" in cb + dict.__setitem__(cb, "Raw", 2) + cb["a"] = 5 # exact key, no lookup first, so the stale index is noticed on the write + assert cb.raw == 2 and cb.A == 5 + + def test_reflected_add_on_config_box(self): + assert ({"FOO": 2} + ConfigBox({"Foo": 1, "bar": 3})).to_dict() == {"bar": 3, "Foo": 1} + + def test_index_tracks_non_string_keys(self): + cb = ConfigBox({"a": 1}) + assert "A" in cb + cb[5] = "five" + assert cb[5] == "five" and cb.A == 1 + + def test_index_invalidated_by_nested_dotted_write(self): + cb = ConfigBox(default_box=True, box_dots=True) + assert "x" not in cb + cb["a.b"] = 1 + assert cb["A.B"] == 1 + + def test_case_variants_without_conversion_box(self): + cb = ConfigBox({"Foo": 1}, conversion_box=False) + cb["FOO"] = 2 + cb.merge_update({"foo": 3}) + assert cb.to_dict() == {"foo": 3} + + def test_take_over_keeps_other_alias(self): + cb = ConfigBox({"a_b": 1, "a b": 2}) + cb["A_B"] = 3 + assert cb.to_dict() == {"a b": 2, "A_B": 3} + + def test_box_config_key_is_stored_as_data(self): + cb = ConfigBox() + cb["_box_config"] = 5 + assert dict.__getitem__(cb, "_box_config") == 5 + + def test_update_too_many_arguments(self): + with pytest.raises(BoxTypeError, match="at most 1 argument"): + ConfigBox().update({"a": 1}, {"b": 2}) + + def test_union_on_frozen_config_box(self): + cb = ConfigBox({"Foo": 1}, frozen_box=True) + result = cb | {"FOO": 2} + assert result.to_dict() == {"FOO": 2} + assert cb.to_dict() == {"Foo": 1} + + def test_list_without_strip(self): + cb = ConfigBox(items="[a, b]") + assert cb.list("items", strip=False) == ["[a", " b]"] + + +class TestConverterPaths: + @pytest.fixture + def pyyaml_only(self, monkeypatch): + if not converters.pyyaml_available: + pytest.skip("PyYAML is not installed") + monkeypatch.setattr(converters, "ruamel_available", False) + + @pytest.fixture + def no_yaml(self, monkeypatch): + monkeypatch.setattr(converters, "ruamel_available", False) + monkeypatch.setattr(converters, "pyyaml_available", False) + + def test_no_yaml_library(self, no_yaml, tmp_path): + path = tmp_path / "a.yaml" + path.write_text("a: 1\n") + with pytest.raises(BoxError, match="No YAML Parser"): + converters._to_yaml({"a": 1}) + with pytest.raises(BoxError, match="No YAML Parser"): + converters._from_yaml("a: 1") + with pytest.raises(BoxError, match="No YAML Parser"): + converters._from_yaml(filename=path) + + def test_pyyaml_file_and_loader(self, pyyaml_only, tmp_path): + import yaml + + path = tmp_path / "a.yaml" + path.write_text("a: 1\nb: [1, 2]\n") + assert Box.from_yaml(filename=path).to_dict() == {"a": 1, "b": [1, 2]} + assert Box.from_yaml(filename=path, Loader=yaml.SafeLoader).a == 1 + assert Box.from_yaml("a: 1\n", Loader=yaml.SafeLoader).a == 1 + + def test_ruamel_attrs_from_file(self, tmp_path): + if not converters.ruamel_available: + pytest.skip("ruamel.yaml is not installed") + path = tmp_path / "a.yaml" + path.write_text("a: 'x'\n") + bx = Box.from_yaml(filename=path, ruamel_attrs={"preserve_quotes": True}) + assert bx.to_yaml() == "a: 'x'\n" + + def test_ruamel_dumper_without_sort_attribute(self): + if not converters.ruamel_available: + pytest.skip("ruamel.yaml is not installed") + assert "a" in converters._to_yaml({"a": 1}, ruamel_typ="base") + + def test_toml_package_writer(self, monkeypatch, tmp_path): + written = [] + fake_toml = types.ModuleType("toml") + fake_toml.dump = lambda obj, f: written.append(obj) or f.write("a = 1\n") + fake_toml.dumps = lambda obj: "a = 1\n" + monkeypatch.setattr(converters, "toml_write_library", fake_toml) + path = tmp_path / "out.toml" + converters._to_toml({"a": 1}, filename=path) + assert path.read_text() == "a = 1\n" + assert written == [{"a": 1}] + + +class TestFromFilePaths: + def test_toon_files(self, tmp_path): + if not from_file.toon_available: + pytest.skip("toon_format is not installed") + good = tmp_path / "data.toon" + Box(a=1, b="x").to_toon(filename=good) + assert box_from_file(good).to_dict() == {"a": 1, "b": "x"} + rows = tmp_path / "rows.toon" + BoxList([{"a": 1}, {"a": 2}]).to_toon(filename=rows) + assert box_from_file(rows).to_list() == [{"a": 1}, {"a": 2}] + bad = tmp_path / "bad.toon" + bad.write_text('a: "unterminated\n') + with pytest.raises(BoxError, match="not TOON"): + box_from_file(bad) + + def test_toon_unavailable(self, tmp_path, monkeypatch): + monkeypatch.setattr(from_file, "toon_available", False) + path = tmp_path / "data.toon" + path.write_text("a: 1\n") + with pytest.raises(BoxError, match="toon"): + box_from_file(path) + with pytest.raises(BoxError, match="toon"): + box_from_string("a: 1", string_type="toon") + + def test_box_from_string_json(self): + assert box_from_string('{"a": 1}').to_dict() == {"a": 1} + assert box_from_string("[1, 2]").to_list() == [1, 2] + with pytest.raises(BoxError, match="not JSON"): + box_from_string("{nope") + + def test_box_from_string_toml(self): + assert box_from_string("a = 1", string_type="toml").to_dict() == {"a": 1} + with pytest.raises(BoxError, match="not TOML"): + box_from_string("= nope", string_type="toml") + + def test_box_from_string_yaml(self): + assert box_from_string("a: 1", string_type="yaml").to_dict() == {"a": 1} + assert box_from_string("- 1\n- 2\n", string_type="yaml").to_list() == [1, 2] + with pytest.raises(BoxError, match="not YAML"): + box_from_string("a: [1", string_type="yaml") + + def test_box_from_string_toon(self): + if not from_file.toon_available: + pytest.skip("toon_format is not installed") + assert box_from_string(Box(a=1).to_toon(), string_type="toon").to_dict() == {"a": 1} + rows = BoxList([{"a": 1}, {"a": 2}]).to_toon() + assert box_from_string(rows, string_type="toon").to_list() == [{"a": 1}, {"a": 2}] + with pytest.raises(BoxError, match="not TOON"): + box_from_string('a: "unterminated', string_type="toon") + + def test_box_from_string_unknown_type(self): + with pytest.raises(BoxError, match="Unsupported"): + box_from_string("a", string_type="xml") diff --git a/test/test_edge_cases.py b/test/test_edge_cases.py new file mode 100644 index 00000000..c414b193 --- /dev/null +++ b/test/test_edge_cases.py @@ -0,0 +1,1028 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +""" +Edge case and regression tests: hidden state (pickle / copy), ephemeral default_box children, +box_dots parsing, frozen containers, merge_update, operators, converters and subclassing. +""" + +import copy +import json +import math +import pickle +import warnings + +import pytest + +from box import ( + Box, + BoxError, + BoxKeyError, + BoxList, + ConfigBox, + DDBox, + SBox, + box_from_file, +) +from box.exceptions import BoxTypeError, BoxValueError, BoxWarning + + +class ListBox(Box): + pass + + +class DotsDefaultBox(Box): + _box_defaults = {"default_box": True, "box_dots": True} + + +class ParentDefaults(Box): + _box_defaults = {"box_dots": True} + + +class ChildDefaults(ParentDefaults): + _box_defaults = {"default_box": True} + + +class TrackedBox(Box): + _box_internal_attrs = ("_meta",) + + +class PropBox(Box): + @property + def temp(self): + return self.__dict__.get("_temp") + + @temp.setter + def temp(self, value): + self.__dict__["_temp"] = value + + @temp.deleter + def temp(self): + self.__dict__.pop("_temp", None) + + def describe(self): + return "described" + + +class IntactDict(dict): + pass + + +class IntactList(list): + pass + + +class TestPickleAndCopy: + def test_pickle_nested_box_dots_keeps_working(self): + bx = Box({"a": {"b": {"c": 1}}, "l": [{"x": 1}]}, box_dots=True) + out = pickle.loads(pickle.dumps(bx)) + assert out["a.b.c"] == 1 + assert out["l[0].x"] == 1 + out["a.b.d"] = 2 + assert out.a.b.d == 2 + assert out.a._box_config["box_dots"] is True + assert out.l.box_options["box_dots"] is True + + def test_pickle_frozen_stays_frozen_and_hashable(self): + bx = Box({"a": [1, {"b": 2}], "c": 3}, frozen_box=True) + out = pickle.loads(pickle.dumps(bx)) + assert out == bx + assert hash(out) == hash(bx) + assert isinstance(out.a, tuple) + with pytest.raises(BoxError): + out.c = 4 + with pytest.raises(BoxError): + out.a[1].b = 5 + + def test_pickle_config_box_keeps_case_insensitivity(self): + cfg = ConfigBox({"Host": "h", "sub": {"Port": 1}}) + assert cfg.host == "h" # builds the case index before pickling + out = pickle.loads(pickle.dumps(cfg)) + assert type(out) is ConfigBox + assert type(out.sub) is ConfigBox + assert out["HOST"] == "h" + assert out.SUB.port == 1 + out["HOST"] = "other" + assert list(out) == ["sub", "HOST"] + + @pytest.mark.parametrize("module", [pickle, copy]) + def test_subclass_defaults_survive_roundtrip(self, module): + bx = DotsDefaultBox({"n": {"x": 1}}) + out = pickle.loads(pickle.dumps(bx)) if module is pickle else copy.deepcopy(bx) + assert type(out) is DotsDefaultBox + assert type(out.n) is DotsDefaultBox + assert out["n.x"] == 1 + assert out.missing.deeper is not None + assert "missing" not in out + + def test_pickle_ephemeral_child_drops_parent_reference(self): + parent = Box(default_box=True) + child = parent.ghost + assert "__pending_parent" in child._box_config + data = pickle.dumps(child) + assert b"__pending_parent" not in data + out = pickle.loads(data) + assert "__pending_parent" not in out._box_config + out.x = 1 + assert out == {"x": 1} + assert "ghost" not in parent + + def test_copy_deepcopy_and_pickle_internal_attrs(self): + bx = TrackedBox({"a": 1}) + bx._meta = {"seen": [1]} + assert "_meta" not in bx + assert bx.to_dict() == {"a": 1} + shallow = copy.copy(bx) + deep = copy.deepcopy(bx) + unpickled = pickle.loads(pickle.dumps(bx)) + assert shallow._meta is bx._meta + assert deep._meta == bx._meta and deep._meta is not bx._meta + assert unpickled._meta == {"seen": [1]} + for each in (shallow, deep, unpickled): + assert type(each) is TrackedBox + assert each == {"a": 1} + + @pytest.mark.parametrize("how", ["pickle", "deepcopy"]) + def test_self_referencing_boxlist_roundtrip(self, how): + bl = BoxList([1, {"a": 2}]) + bl.append(bl) + out = pickle.loads(pickle.dumps(bl)) if how == "pickle" else copy.deepcopy(bl) + assert out is not bl + assert out[2] is out + assert out[1].a == 2 + as_list = out.to_list() + assert as_list[2] is as_list + + def test_frozen_boxlist_pickle_copy_deepcopy_refuse_list_mutation(self): + bl = BoxList([1, {"a": [2, 3]}], frozen_box=True) + for out in (pickle.loads(pickle.dumps(bl)), copy.copy(bl), copy.deepcopy(bl)): + assert out == bl + with pytest.raises(BoxError): + out.append(1) + with pytest.raises(BoxError): + out[0] = 2 + assert hash(copy.copy(bl)) == hash(bl) + + def test_frozen_boxlist_pickle_and_deepcopy_keep_items_frozen(self): + bl = BoxList([{"a": [2, 3]}], frozen_box=True) + for out in (pickle.loads(pickle.dumps(bl)), copy.deepcopy(bl)): + assert hash(out) == hash(bl) + with pytest.raises(BoxError): + out[0].a = 1 + + def test_pickle_keeps_options_of_boxes_inside_lists(self): + bx = Box({"l": [{"a": {"b": 1}}]}, box_dots=True) + out = pickle.loads(pickle.dumps(bx)) + assert out.l[0]._box_config["box_dots"] is True + standalone = BoxList([{"a": 1}], box_class=ListBox, default_box=True) + again = pickle.loads(pickle.dumps(standalone)) + assert type(again[0]) is ListBox + assert again[0]._box_config["default_box"] is True + + +class TestEphemeralDefaultBox: + def test_chained_assignment_creates_every_parent(self): + bx = Box(default_box=True) + bx.a.b.c = 1 + bx.a.b.d.e = 2 + bx["x"].y["z"] = 3 + assert bx == {"a": {"b": {"c": 1, "d": {"e": 2}}}, "x": {"y": {"z": 3}}} + + def test_lookups_never_store_and_look_empty(self): + bx = Box({"real": 1}, default_box=True) + ghost = bx.a.b.c + assert not ghost + assert len(ghost) == 0 + assert "x" not in ghost + assert ghost == {} + assert ghost == Box() + assert bx["q"] == {} + assert bx.get("w") == {} + assert bx == {"real": 1} + assert "a" not in bx + + def test_stale_child_does_not_overwrite_real_value(self): + bx = Box(default_box=True) + stale = bx.a + bx.a = {"k": 1} + stale.z = 2 + assert bx.a == {"k": 1} + assert stale == {"z": 2} + + def test_child_stored_elsewhere_is_copied_not_aliased(self): + bx = Box(default_box=True) + child = bx.a + bx.other = child + child.x = 1 + assert bx.other == {} + assert bx.a == {"x": 1} + + def test_box_dots_missing_list_and_dict_paths_are_created_on_write(self): + bx = DDBox() + assert bx["rows[3].name"] == {} + assert bx == {} + bx["rows[1].name"] = "x" + bx["a.b.c"] = 1 + assert bx.rows == [None, {"name": "x"}] + assert bx["a.b.c"] == 1 + assert isinstance(bx.rows, BoxList) + + def test_frozen_default_box_refuses_child_writes(self): + bx = Box({"a": 1}, default_box=True, frozen_box=True) + with pytest.raises(BoxError): + bx.missing.x = 1 + with pytest.raises(BoxError): + bx["m"].n = 1 + assert bx == {"a": 1} + + def test_update_and_merge_update_on_ephemeral_child_attach_it(self): + bx = Box(default_box=True) + bx.a.merge_update({"x": {"y": 1}}) + bx.b.update(z=2) + bx.c.update({}) + assert bx == {"a": {"x": {"y": 1}}, "b": {"z": 2}} + + def test_pop_delattr_and_pop_default_are_noops_for_missing_keys(self): + bx = Box({"keep": 1}, default_box=True) + assert bx.pop("nope") == {} + assert bx.pop("nope", 5) == 5 + assert hasattr(bx, "ghost") + delattr(bx, "ghost") + with pytest.raises(BoxKeyError): + del bx["ghost"] + assert bx == {"keep": 1} + + +class TestBoxDots: + def test_negative_and_out_of_range_list_indexes(self): + bx = Box({"a": [1, 2, 3]}, box_dots=True) + assert bx["a[2]"] == 3 + with pytest.raises(IndexError): + bx["a[10]"] + with pytest.raises(BoxTypeError): + bx["a[-1]"] + with pytest.raises(BoxTypeError): + bx["a[x]"] + + def test_nested_lists_get_set_delete(self): + bx = Box({"a": [[1, 2], [3, {"y": 4}]]}, box_dots=True) + assert bx["a[0][1]"] == 2 + assert bx["a[1][1].y"] == 4 + bx["a[1][1].y"] = 5 + bx["a[0][0]"] = {"n": 1} + assert bx.a[1][1].y == 5 + assert isinstance(bx.a[0][0], Box) + del bx["a[1][1].y"] + assert bx.a[1][1] == {} + del bx["a[0]"] + assert len(bx.a) == 1 + + def test_keys_dotted_are_all_resolvable(self): + bx = Box({"a": {"b": 1, "c": [1, {"d": 2}, [3]]}, "e": 2}, box_dots=True) + keys = bx.keys(dotted=True) + assert keys == ["a.b", "a.c[0]", "a.c[1].d", "a.c[2][0]", "e"] + for key in keys: + assert bx[key] is not None + assert dict(bx.items(dotted=True)) == {"a.b": 1, "a.c[0]": 1, "a.c[1].d": 2, "a.c[2][0]": 3, "e": 2} + with pytest.raises(BoxError): + Box({"a": 1}).keys(dotted=True) + + def test_contains_agrees_with_dotted_lookup_through_lists(self): + bx = Box({"a": [{"x": 1}], "b": {"c": 1}}, box_dots=True) + for key in bx.keys(dotted=True): + assert bx[key] is not None + assert key in bx, key + + def test_get_agrees_with_getitem_for_list_paths(self): + bx = Box({"a": [{"x": 1}]}, box_dots=True) + assert bx["a[0].x"] == 1 + assert bx.get("a[0].x") == 1 + + def test_box_dots_exclude_keeps_literal_dotted_keys(self): + bx = Box({"v1.0": 1, "a": {"b": 2}}, box_dots=True, box_dots_exclude=r"v\d") + assert bx["v1.0"] == 1 + assert bx["a.b"] == 2 + assert "v1.0" in bx + bx["v2.0"] = 5 + assert dict.__contains__(bx, "v2.0") + assert list(bx) == ["v1.0", "a", "v2.0"] + + def test_dotted_write_without_parent_needs_default_box(self): + with pytest.raises(BoxKeyError): + Box(box_dots=True)["a.b"] = 1 + with pytest.raises(BoxKeyError): + Box({"a.b": 1}, box_dots=True) + bx = Box(box_dots=True, default_box=True) + bx["a.b"] = 1 + bx["x..y"] = 2 + assert bx == {"a": {"b": 1}, "x": {"": {"y": 2}}} + + def test_trailing_dot_key_with_default_box_does_not_crash(self): + bx = Box(box_dots=True, default_box=True) + bx["a."] = 1 + assert bx.to_dict() == {"a": {"": 1}} + + def test_setdefault_get_and_pop_with_dotted_keys(self): + bx = Box({"a": {"b": 1}, "l": [{"k": 1}]}, box_dots=True) + assert bx.setdefault("a.c", 5) == 5 + assert bx.setdefault("a.b", 99) == 1 + assert bx.setdefault("l[0].k", 99) == 1 + assert bx.get("a.zz", 9) == 9 + assert type(bx.get("a.zz", {"q": 1})) is Box + assert bx.pop("a.b") == 1 + assert bx.pop("a.b", "gone") == "gone" + with pytest.raises(BoxKeyError): + bx.pop("a.b") + assert bx.a == {"c": 5} + + def test_integer_path_segments_only_match_within_dotted_paths(self): + bx = Box({"a": {2: "two", "3": "str3", 3: "int3"}, 7: "seven"}, box_dots=True) + assert bx["a.2"] == "two" + assert bx["a.3"] == "str3" + assert "a.2" in bx + assert "a.9" not in bx + with pytest.raises(BoxKeyError): + bx["a"]["2"] + bx["a.2"] = "TWO" + assert bx.a[2] == "TWO" + del bx["a.2"] + assert 2 not in bx.a + assert bx[7] == "seven" + assert "7" not in bx + + +class TestConversionBox: + def test_duplicate_detection_warn_error_and_ignore(self): + with pytest.raises(BoxError): + Box({"a b": 1, "a_b": 2}, box_duplicates="error") + with pytest.warns(BoxWarning): + Box({"a b": 1, "a_b": 2}, box_duplicates="warn") + with warnings.catch_warnings(): + warnings.simplefilter("error") + quiet = Box({"a b": 1, "a_b": 2}) + assert len(quiet) == 2 + with pytest.raises(BoxError): + Box(box_duplicates="error", conversion_box=False) + + def test_keywords_digits_and_unicode_keys_get_safe_aliases(self): + bx = Box({"class": 1, "def": 2, "1abc": 3, "ключ": 4, "naïve key": 5, "x-y": 6}) + assert bx.xclass == 1 + assert bx.xdef == 2 + assert bx.x1abc == 3 + assert bx.ключ == 4 + assert bx.naïve_key == 5 + assert bx.x_y == 6 + assert bx["class"] == 1 + dirs = dir(bx) + assert "xclass" in dirs and "ключ" in dirs and "class" not in dirs + + def test_deleting_a_key_releases_its_alias(self): + bx = Box({"a b": 1}, box_duplicates="error") + assert bx.a_b == 1 + del bx["a b"] + with pytest.raises(BoxKeyError): + bx.a_b + bx["a_b"] = 2 + assert bx.a_b == 2 + bx.clear() + bx["a b"] = 3 + assert bx.a_b == 3 + + def test_protected_names_stay_methods_but_work_as_keys(self): + bx = Box() + with pytest.raises(BoxKeyError): + bx.keys = 1 + with pytest.raises(BoxKeyError): + bx.to_dict = 1 + bx["keys"] = 1 + bx["update"] = 2 + assert bx["keys"] == 1 + assert callable(bx.keys) + assert callable(bx.update) + assert sorted(bx.keys()) == ["keys", "update"] + with pytest.raises(BoxKeyError): + del bx.keys + with pytest.raises(BoxError): + del bx._box_config + + def test_setting_method_names(self): + # Box's own converters are protected keys + for name in ("to_msgpack", "from_msgpack", "to_toon", "from_toon", "to_json"): + with pytest.raises(BoxKeyError, match="protected"): + setattr(Box(), name, 1) + + # Other class attributes are stored as keys, the method still wins for attribute access + class Described(Box): + label = "class attribute" + + def describe(self): + return "method" + + bx = Described() + bx.describe = 1 + bx.label = 2 + assert bx.to_dict() == {"describe": 1, "label": 2} + assert bx.describe() == "method" + + +class TestFrozen: + def test_hash_equality_and_unhashable_mutable(self): + one = Box({"a": [1, {"b": 2}], "c": "x"}, frozen_box=True) + two = Box({"a": [1, {"b": 2}], "c": "x"}, frozen_box=True) + assert one == two and hash(one) == hash(two) + assert {one: 1}[two] == 1 + assert len({one, two}) == 1 + with pytest.raises(BoxTypeError): + hash(Box(a=1)) + with pytest.raises(TypeError): + hash(BoxList([1])) + assert hash(BoxList([1, 2], frozen_box=True)) == hash(BoxList([1, 2], frozen_box=True)) + + def test_every_mutator_is_refused_and_leaves_data_intact(self): + bx = Box({"a": 1, "n": {"m": 1}}, frozen_box=True) + attempts = [ + lambda: bx.__setitem__("b", 1), + lambda: setattr(bx, "b", 1), + lambda: delattr(bx, "a"), + lambda: bx.__delitem__("a"), + lambda: bx.pop("a"), + lambda: bx.popitem(), + lambda: bx.clear(), + lambda: bx.update(b=1), + lambda: bx.merge_update({"b": 1}), + lambda: bx.merge_update({"n": {"m": 2}}), + lambda: bx.setdefault("zz", 1), + lambda: bx.n.__setitem__("m", 2), + lambda: bx.n.update({"m": 2}), + ] + for attempt in attempts: + with pytest.raises(BoxError): + attempt() + with pytest.raises(BoxError): + bx |= {"b": 1} + with pytest.raises(BoxError): + bx += {"b": 1} + assert bx == {"a": 1, "n": {"m": 1}} + + def test_frozen_boxlist_refuses_every_mutator(self): + bl = BoxList([3, 1, {"a": 1}], frozen_box=True) + attempts = [ + lambda: bl.append(1), + lambda: bl.extend([1]), + lambda: bl.insert(0, 1), + lambda: bl.pop(), + lambda: bl.remove(3), + lambda: bl.reverse(), + lambda: bl.sort(key=str), + lambda: bl.clear(), + lambda: bl.__setitem__(0, 1), + lambda: bl.__setitem__(slice(0, 1), [1]), + lambda: bl.__delitem__(0), + lambda: bl.__iadd__([1]), + lambda: bl.__imul__(2), + ] + for attempt in attempts: + with pytest.raises(BoxError): + attempt() + assert bl == [3, 1, {"a": 1}] + + @pytest.mark.parametrize( + "loader", + [ + lambda text, **kw: Box.from_json(text, **kw), + lambda text, **kw: Box.from_yaml(text, **kw), + ], + ids=["json", "yaml"], + ) + def test_frozen_loaded_from_text_serializes_back(self, loader): + text = json.dumps({"a": [1, {"b": [2, 3]}], "c": {"d": [{"e": 1}]}}) + bx = loader(text, frozen_box=True) + assert isinstance(bx.a, tuple) + assert hash(bx) == hash(loader(text, frozen_box=True)) + assert json.loads(bx.to_json()) == json.loads(text) + assert Box.from_yaml(bx.to_yaml()).to_dict() == json.loads(text) + with pytest.raises(BoxError): + bx.c.d[0].e = 2 + + def test_operators_on_frozen_boxes_return_new_frozen_boxes(self): + frozen = Box({"a": 1, "n": {"x": 1}}, frozen_box=True) + for result in (frozen + {"b": 2}, frozen | {"b": 2}, {"b": 2} + frozen, {"b": 2} | frozen): + assert result._box_config["frozen_box"] is True + assert result["b"] == 2 and result["a"] == 1 + with pytest.raises(BoxError): + result.c = 1 + assert (frozen - {"a": 1})._box_config["frozen_box"] is True + assert frozen == {"a": 1, "n": {"x": 1}} + mutable = Box(m=1) + frozen + mutable.k = 1 + assert mutable._box_config["frozen_box"] is False + + +class TestMergeUpdate: + def test_list_strategies(self): + def merged(strategy): + bx = Box({"l": [1, 2], "d": [{"a": 1}]}) + bx.merge_update({"l": [2, 3], "d": [{"b": 2}, {"c": 3}]}, box_merge_lists=strategy) + return bx.to_dict() + + assert merged(None) == {"l": [2, 3], "d": [{"b": 2}, {"c": 3}]} + assert merged(False) == {"l": [2, 3], "d": [{"b": 2}, {"c": 3}]} + assert merged("extend") == {"l": [1, 2, 2, 3], "d": [{"a": 1}, {"b": 2}, {"c": 3}]} + assert merged("unique") == {"l": [1, 2, 3], "d": [{"a": 1}, {"b": 2}, {"c": 3}]} + assert merged("merge") == {"l": [2, 3], "d": [{"a": 1, "b": 2}, {"c": 3}]} + + def test_merge_strategy_applies_to_nested_boxes_and_nested_lists(self): + bx = Box({"a": {"b": {"l": [[1, {"x": 1}], 5]}}}) + bx.merge_update({"a": {"b": {"l": [[9, {"y": 2}, 7], {"z": 1}]}}}, box_merge_lists="merge") + assert bx.to_dict() == {"a": {"b": {"l": [[9, {"x": 1, "y": 2}, 7], {"z": 1}]}}} + assert isinstance(bx.a.b.l[0][1], Box) + + def test_unknown_strategy_is_rejected_before_any_change(self): + bx = Box({"a": 1, "l": [1]}) + for bad in ("replace", "Extend", True, 1): + with pytest.raises(BoxValueError): + bx.merge_update({"a": 2, "l": [2]}, box_merge_lists=bad) + assert bx == {"a": 1, "l": [1]} + + def test_merging_dicts_and_lists_into_incompatible_values(self): + bx = Box({"num": 1, "txt": "s", "lst": [1], "dct": {"a": 1}}) + bx.merge_update({"num": {"n": 1}, "txt": [1], "lst": {"k": 1}, "dct": [1]}, box_merge_lists="extend") + assert bx == {"num": {"n": 1}, "txt": [1], "lst": {"k": 1}, "dct": [1]} + assert isinstance(bx.num, Box) and isinstance(bx.txt, BoxList) + + def test_merge_with_itself_and_with_its_dict_is_idempotent(self): + bx = Box({"a": {"b": [1, {"c": 1}]}, "d": 1}) + before = bx.to_dict() + bx.merge_update(bx) + assert bx.to_dict() == before + bx.merge_update(bx.to_dict(), box_merge_lists="merge") + assert bx.to_dict() == before + bx += bx + assert bx.to_dict() == before + + def test_merge_update_argument_forms(self): + bx = Box({"a": {"x": 1}}) + bx.merge_update([("b", 1), ("a", {"y": 2})]) + bx.merge_update(iter([("c", {"d": 1})])) + bx.merge_update(e={"f": 1}) + bx.merge_update({}) + bx.merge_update() + assert bx == {"a": {"x": 1, "y": 2}, "b": 1, "c": {"d": 1}, "e": {"f": 1}} + with pytest.raises(BoxTypeError): + bx.merge_update({"z": 1}, y=2) + with pytest.raises(BoxTypeError): + bx.merge_update({"z": 1}, {"y": 2}) + assert "z" not in bx + + def test_box_intact_types_are_not_converted_or_merged(self): + bx = Box({"d": {"a": 1}}, box_intact_types=(IntactDict, IntactList)) + bx.merge_update({"d": IntactDict(b=2), "l": IntactList([{"x": 1}])}) + assert type(bx.d) is IntactDict and bx.d == {"b": 2} + assert type(bx.l) is IntactList and type(bx.l[0]) is dict + bx.merge_update({"l": IntactList([{"y": 1}])}, box_merge_lists="extend") + assert type(bx.l) is IntactList and bx.l == [{"y": 1}] + + +class TestOperators: + def test_add_merges_deeply_and_right_side_wins(self): + left = Box({"a": {"x": 1, "y": 1}, "k": 1}) + right = {"a": {"y": 2}, "z": 3} + assert left + right == {"a": {"x": 1, "y": 2}, "k": 1, "z": 3} + assert right + left == {"a": {"x": 1, "y": 1}, "k": 1, "z": 3} + assert list(left + right) == ["a", "k", "z"] + assert left == {"a": {"x": 1, "y": 1}, "k": 1} + assert right == {"a": {"y": 2}, "z": 3} + + def test_sub_is_recursive_and_requires_a_mapping(self): + bx = Box({"a": {"x": 1, "y": 2}, "b": 1, "c": {"z": 1}}) + assert bx - {"a": {"x": 1}, "b": 1, "c": {"z": 1}} == {"a": {"y": 2}} + assert bx - Box() == bx + assert bx - bx == {} + with pytest.raises(BoxError): + bx - [("a", 1)] + assert bx == {"a": {"x": 1, "y": 2}, "b": 1, "c": {"z": 1}} + + def test_non_mappings_are_rejected_with_type_error(self): + bx = Box(a=1) + for other in ([("b", 1)], "text", 5, None, (("b", 1),)): + with pytest.raises(BoxTypeError): + bx + other + with pytest.raises(BoxTypeError): + other + bx + with pytest.raises(BoxTypeError): + bx | other + with pytest.raises(BoxTypeError): + other | bx + with pytest.raises(BoxTypeError): + bx.__iadd__(other) + with pytest.raises(BoxTypeError): + bx.__ior__(other) + assert bx == {"a": 1} + + def test_inplace_operators_keep_identity_and_class(self): + bx = Box({"a": {"x": 1}}) + ident = id(bx) + nested = bx.a + bx += {"a": {"y": 2}} + assert id(bx) == ident and bx.a is nested and nested == {"x": 1, "y": 2} + bx |= {"a": {"z": 3}} + assert id(bx) == ident and bx.a == {"z": 3} + assert type(bx.a) is Box + + def test_results_keep_the_class_and_options_of_the_box_operand(self): + cfg = ConfigBox({"Key": {"Inner": 1}}) + for result in (cfg + {"other": {"x": 1}}, cfg | {"other": {"x": 1}}, {"o": {"x": 1}} + cfg, {"o": 1} | cfg): + assert type(result) is ConfigBox + assert result.key.inner == 1 + sbx = SBox({"a": 1}, default_box=True) + for result in (sbx + {"b": {"c": 1}}, sbx | {"b": {"c": 1}}): + assert type(result) is SBox and type(result.b) is SBox + assert result.missing == {} + assert "missing" not in result + + +class TestConverters: + def test_json_roundtrip_unicode_none_empty_and_encoding(self, tmp_path): + data = {"ключ": "значение", "emoji": "😀", "none": None, "e1": {}, "e2": [], "l": [{"a": [{"b": None}]}]} + bx = Box(data) + assert Box.from_json(bx.to_json()).to_dict() == data + assert "😀" in bx.to_json() + assert "\\u" in bx.to_json(ensure_ascii=True) + for target in (tmp_path / "a.json", str(tmp_path / "b.json")): + assert bx.to_json(filename=target) is None + assert Box.from_json(filename=target).to_dict() == data + path = tmp_path / "utf16.json" + bx.to_json(filename=path, encoding="utf-16") + assert Box.from_json(filename=path, encoding="utf-16") == data + with pytest.raises(UnicodeError): + Box.from_json(filename=path, encoding="utf-8") + + def test_yaml_roundtrip_keeps_strings_that_look_like_other_types(self, tmp_path): + data = {"s1": "1.0", "s2": "true", "s3": "null", "s4": "0x10", "s5": "", "n": None, "u": "naïve ключ"} + data["l"] = [{"a": [], "b": {}}, [1, [2, {"c": "yes"}]]] + bx = Box(data) + assert Box.from_yaml(bx.to_yaml()).to_dict() == data + path = tmp_path / "out.yaml" + bx.to_yaml(filename=path) + assert Box.from_yaml(filename=str(path)).to_dict() == data + assert list(Box.from_yaml("z: 1\na: 2\nm: 3")) == ["z", "a", "m"] + + def test_yaml_scalars_load_as_builtin_types(self): + bx = Box.from_yaml("f: 1.5\ni: 0x10\nb: true\ns: '1.5'\nd: {x: [1.25, 2]}\nn: ~") + assert type(bx.f) is float + assert type(bx.i) is int and bx.i == 16 + assert type(bx.b) is bool + assert type(bx.s) is str and bx.s == "1.5" + assert type(bx.d.x[0]) is float and type(bx.d.x[1]) is int + assert bx.n is None + assert type(bx) is Box and type(bx.d) is Box and type(bx.d.x) is BoxList + + def test_toml_roundtrip_and_unsupported_none(self, tmp_path): + data = {"title": "naïve ключ", "tbl": {"a": 1, "arr": [1, 2]}, "items": [{"n": "x"}, {"n": "y"}], "e": {}} + bx = Box(data) + assert Box.from_toml(bx.to_toml()).to_dict() == data + path = tmp_path / "out.toml" + bx.to_toml(filename=path) + assert Box.from_toml(filename=path).to_dict() == data + with pytest.raises(TypeError): + Box(a=None).to_toml() + + def test_msgpack_roundtrip_including_bytes_and_boxlist(self, tmp_path): + data = {"b": b"\x00\x01", "u": "ключ", "n": None, "f": 1.5, "l": [{"a": [1, {"b": True}]}], "e": {}} + bx = Box(data) + assert Box.from_msgpack(bx.to_msgpack()).to_dict() == data + path = tmp_path / "out.msgpack" + bx.to_msgpack(filename=path) + assert Box.from_msgpack(filename=path).to_dict() == data + bl = BoxList([{"a": 1}, [2, {"b": 3}], None]) + assert BoxList.from_msgpack(bl.to_msgpack()) == bl + with pytest.raises(BoxError): + Box.from_msgpack(BoxList([1]).to_msgpack()) + with pytest.raises(BoxError): + BoxList.from_msgpack(Box(a=1).to_msgpack()) + + def test_toon_roundtrip_and_type_mismatch(self, tmp_path): + data = {"name": "naïve", "tags": ["a", "b"], "rows": [{"id": 1, "v": "x"}, {"id": 2, "v": "y"}], "n": None} + bx = Box(data) + assert Box.from_toon(bx.to_toon()).to_dict() == data + path = tmp_path / "out.toon" + bx.to_toon(filename=path) + assert Box.from_toon(filename=path).to_dict() == data + bl = BoxList([{"a": 1}, {"a": 2}]) + assert BoxList.from_toon(bl.to_toon()) == bl + with pytest.raises(BoxError): + BoxList.from_toon(bx.to_toon()) + + def test_csv_roundtrip_quoting_unicode_and_errors(self, tmp_path): + rows = BoxList([{"a": "x,y", "b": 'say "hi"', "c": "line\nbreak"}, {"a": "ключ", "b": "", "c": "1"}]) + text = rows.to_csv() + back = BoxList.from_csv(text) + assert back == rows + assert all(type(row) is Box for row in back) + path = tmp_path / "out.csv" + rows.to_csv(filename=path) + assert BoxList.from_csv(filename=path) == rows + assert BoxList([{"n": 1}]).to_csv().splitlines() == ["n", "1"] + assert BoxList.from_csv(BoxList([{"n": 1}]).to_csv())[0].n == "1" + with pytest.raises(BoxError): + BoxList([{"a": 1}, {"b": 2}]).to_csv() + with pytest.raises(BoxError): + BoxList.from_csv(filename=tmp_path / "missing.csv") + + def test_special_floats_roundtrip(self): + bx = Box(pos=math.inf, neg=-math.inf, nan=math.nan, small=5e-324, big=1.7976931348623157e308) + for back in ( + Box.from_json(bx.to_json()), + Box.from_yaml(bx.to_yaml()), + Box.from_toml(bx.to_toml()), + Box.from_msgpack(bx.to_msgpack()), + ): + assert back.pos == math.inf and back.neg == -math.inf + assert math.isnan(back.nan) + assert back.small == 5e-324 and back.big == 1.7976931348623157e308 + assert type(back.pos) is float + + def test_box_from_file_errors_and_overrides(self, tmp_path): + with pytest.raises(BoxError, match="does not exist"): + box_from_file(tmp_path / "nope.json") + with pytest.raises(BoxError, match="unknown type"): + box_from_file(self._write(tmp_path / "a.xyz", "{}")) + with pytest.raises(BoxError, match="not JSON"): + box_from_file(self._write(tmp_path / "bad.json", "not json at all")) + yaml_in_json = self._write(tmp_path / "data.json", "a: 1\nb: [1, 2]\n") + assert box_from_file(yaml_in_json, file_type="YAML") == {"a": 1, "b": [1, 2]} + upper = self._write(tmp_path / "UP.JSON", '{"a": {"b": 1}}') + loaded = box_from_file(upper, box_dots=True, frozen_box=True) + assert loaded["a.b"] == 1 + with pytest.raises(BoxError): + loaded.c = 1 + assert isinstance(box_from_file(self._write(tmp_path / "l.json", '[1, {"a": 2}]')), BoxList) + assert box_from_file(str(upper)) == {"a": {"b": 1}} + + @staticmethod + def _write(path, text): + path.write_text(text, encoding="utf-8") + return path + + +class TestConfigBox: + def test_bool_transform_values_defaults_and_missing(self): + cfg = ConfigBox(yes="yes", no="No", f="F", zero="0", one="1", false="FALSE", empty="", real=False, num=0, two=2) + for name in ("yes", "one", "two"): + assert cfg.bool(name) is True + for name in ("no", "f", "zero", "false", "empty", "real", "num"): + assert cfg.bool(name) is False + assert cfg.bool("missing", True) is True + assert cfg.bool("missing", False) is False + assert cfg.getboolean("YES") is True + with pytest.raises(BoxKeyError): + cfg.bool("missing") + + def test_list_transform_options(self): + cfg = ConfigBox(a=" 1, 2 ,3 ", b="[x;y]", c="5") + assert cfg.list("a") == ["1", "2", "3"] + assert cfg.list("a", mod=int) == [1, 2, 3] + assert cfg.list("a", strip=False) == [" 1", " 2 ", "3 "] + assert cfg.list("b", spliter=";") == ["x", "y"] + assert cfg.list("c") == ["5"] + assert cfg.list("missing", default=["d"]) == ["d"] + with pytest.raises(BoxKeyError): + cfg.list("missing") + + def test_case_insensitive_with_nested_boxes_and_box_dots(self): + cfg = ConfigBox({"Server": {"Port": "80", "Hosts": {"Main": "a"}}}, box_dots=True) + assert cfg.server.port == "80" + assert cfg["SERVER"]["port"] == "80" + assert cfg["server.port"] == "80" + assert cfg["SERVER.hosts.MAIN"] == "a" + assert "server.hosts.main" in cfg + assert cfg.int("server.port", 0) in (80, 0) + cfg["SERVER.Port"] = "81" + assert cfg == {"Server": {"Port": "81", "Hosts": {"Main": "a"}}} + assert type(cfg.server.hosts) is ConfigBox + del cfg["server.HOSTS.main"] + assert cfg.Server.Hosts == {} + + def test_latest_write_wins_for_every_write_path(self): + cfg = ConfigBox({"Foo": 1}) + cfg["FOO"] = 2 + assert list(cfg.items()) == [("FOO", 2)] + cfg.update(foo=3) + assert list(cfg.items()) == [("foo", 3)] + cfg.merge_update({"Foo": 4}) + assert list(cfg.items()) == [("Foo", 4)] + cfg.other = 1 + cfg.FOO = 5 + assert list(cfg.items()) == [("other", 1), ("FOO", 5)] + assert ConfigBox([("a", 1), ("A", 2)]) == {"A": 2} + + def test_default_box_and_ephemeral_children_ignore_case(self): + cfg = ConfigBox(default_box=True) + cfg.Sec.a = 1 + cfg.SEC.b = 2 + cfg.sec["c"] = 3 + assert cfg == {"Sec": {"a": 1, "b": 2, "c": 3}} + stale = cfg.Other + cfg.OTHER = {"k": 1} + stale.z = 1 + assert cfg == {"Sec": {"a": 1, "b": 2, "c": 3}, "OTHER": {"k": 1}} + assert "other" in cfg and "nothing" not in cfg + + def test_frozen_config_box_reads_but_never_writes(self): + cfg = ConfigBox({"Foo": {"Bar": 1}}, frozen_box=True) + assert cfg.FOO.bar == 1 + for attempt in ( + lambda: cfg.__setitem__("foo", 2), + lambda: cfg.__setitem__("FOO", 2), + lambda: cfg.update(foo=2), + lambda: cfg.merge_update({"FOO": {"x": 1}}), + lambda: cfg.__delitem__("foo"), + lambda: cfg.foo.__setitem__("BAR", 2), + ): + with pytest.raises(BoxError): + attempt() + assert cfg == {"Foo": {"Bar": 1}} + assert hash(cfg) == hash(ConfigBox({"Foo": {"Bar": 1}}, frozen_box=True)) + + +class TestBoxListBehavior: + def test_every_insertion_path_converts_items(self): + bl = BoxList() + bl.append({"a": 1}) + bl.insert(0, [{"b": 1}]) + bl.extend([{"c": 1}, [{"d": 1}]]) + bl[1:1] = [{"e": 1}] + bl[-1] = {"f": [{"g": 1}]} + assert type(bl[0]) is BoxList and type(bl[0][0]) is Box + assert type(bl[1]) is Box and bl[1].e == 1 + assert type(bl[2]) is Box and type(bl[3]) is Box + assert type(bl[-1].f) is BoxList and type(bl[-1].f[0]) is Box + + def test_iadd_converts_items_like_extend(self): + bl = BoxList() + bl += [{"a": 1}, [{"b": 2}]] + assert type(bl[0]) is Box + assert type(bl[1]) is BoxList and type(bl[1][0]) is Box + + def test_box_class_propagates_to_nested_items(self): + class MyBox(Box): + pass + + bl = BoxList([{"a": {"b": [{"c": 1}]}}], box_class=MyBox) + assert type(bl[0]) is MyBox + assert type(bl[0].a) is MyBox + assert type(bl[0].a.b) is BoxList and type(bl[0].a.b[0]) is MyBox + bl.append({"z": {}}) + assert type(bl[1]) is MyBox and type(bl[1].z) is MyBox + + def test_box_options_flow_from_parent_box_to_list_items(self): + bx = Box({"l": [{"a": 1}]}, box_dots=True, default_box=True, camel_killer_box=True) + bx.l.append({"CamelKey": {"X": 1}}) + assert bx.l.box_options["box_dots"] is True + assert bx["l[1].camel_key.x"] == 1 + assert bx.l[0].missing == {} + assert "missing" not in bx.l[0] + bx["l[2].fresh"] = 1 + assert bx.l[2] == {"fresh": 1} + + def test_boxlist_copy_is_shallow_deepcopy_is_independent(self): + bl = BoxList([{"a": [1]}], box_dots=True) + shallow = copy.copy(bl) + deep = copy.deepcopy(bl) + assert shallow == bl and deep == bl + assert shallow is not bl and deep is not bl + assert shallow.box_options["box_dots"] and deep.box_options["box_dots"] + assert shallow.box_options["box_class"] is deep.box_options["box_class"] is Box + deep[0].a.append(2) + deep.append({"n": 1}) + assert bl == [{"a": [1]}] + assert deep["[0].a[1]"] == 2 + assert deep[1]._box_config["box_dots"] is True + + +class TestSubclassing: + def test_box_defaults_inherit_and_explicit_options_win(self): + child = ChildDefaults({"a": {"b": 1}}) + assert child._box_config["box_dots"] is True + assert child._box_config["default_box"] is True + assert child["a.b"] == 1 + assert ParentDefaults()._box_config["default_box"] is False + assert ChildDefaults(box_dots=False)._box_config["box_dots"] is False + assert ChildDefaults(default_box=False)._box_config["default_box"] is False + assert Box()._box_config["box_dots"] is False + assert DDBox(default_box=False)._box_config["default_box"] is False + + def test_unknown_box_default_is_rejected_at_class_creation(self): + with pytest.raises(BoxError, match="not_an_option"): + + class Bad(Box): + _box_defaults = {"not_an_option": 1} + + def test_subclass_defaults_apply_to_nested_conversion_from_json_and_yaml(self): + text = '{"a": {"b": [{"c": 1}]}}' + for bx in (ChildDefaults.from_json(text), ChildDefaults.from_yaml(text)): + assert type(bx) is ChildDefaults + assert type(bx.a) is ChildDefaults + assert type(bx.a.b[0]) is ChildDefaults + assert bx["a.b[0].c"] == 1 + assert bx.a.nothing == {} and "nothing" not in bx.a + explicit = ChildDefaults.from_json(text, box_dots=False) + assert explicit.a._box_config["box_dots"] is False + + def test_property_setter_and_deleter_are_used_not_the_data(self): + bx = PropBox({"k": 1}) + bx.temp = 5 + assert bx.temp == 5 + assert "temp" not in bx + assert bx.to_dict() == {"k": 1} + del bx.temp + assert bx.temp is None + bx["temp"] = "as key" + assert bx["temp"] == "as key" + assert bx.temp is None + assert bx.describe() == "described" + bx["describe"] = 1 + assert bx.describe() == "described" + assert bx["describe"] == 1 + + +class TestDictCompat: + def test_dict_conversion_and_equality(self): + bx = Box({"a": {"b": 1}, "l": [1]}) + flat = dict(bx) + assert type(flat) is dict and type(flat["a"]) is Box + assert bx == {"a": {"b": 1}, "l": [1]} + assert {"a": {"b": 1}, "l": [1]} == bx + assert bx == Box({"l": [1], "a": {"b": 1}}, default_box=True) + assert bx != {"a": {"b": 2}, "l": [1]} + assert bx.a == {"b": 1} and bx.l == [1] + assert bx.l == BoxList([1]) + assert bx.a != BoxList([1]) + + def test_constructor_options_are_not_data_when_passed_in_a_dict(self): + bx = Box({"frozen_box": True, "default_box": 1}) + assert not bx._box_config["frozen_box"] + assert not bx._box_config["default_box"] + assert bx == {"frozen_box": True, "default_box": 1} + bx.new = 1 + opts = Box(a=1, frozen_box=True) + assert opts == {"a": 1} + assert Box({"a": 1}, b=2) == {"a": 1, "b": 2} + assert Box([("a", 1)], b=2) == {"a": 1, "b": 2} + with pytest.raises(BoxValueError): + Box("text") + with pytest.raises(BoxValueError): + Box(5) + with pytest.raises(BoxTypeError): + Box({"a": 1}, {"b": 2}) + + def test_fromkeys_and_get_default_conversion(self): + bx = Box.fromkeys(["a", "b"], {"x": 1}) + assert type(bx) is Box and type(bx.a) is Box and bx.a is not bx.b + got = bx.get("none", {"q": [{"r": 1}]}) + assert type(got) is Box and type(got.q) is BoxList + assert type(bx.get("none", [{"r": 1}])[0]) is Box + assert bx.get("none") is None + assert bx.get("none", None) is None + assert "none" not in bx + dflt = Box(default_box=True).get("zz") + assert dflt == {} + + def test_live_views_and_reversed(self): + bx = Box(a=1, b=2) + keys, values, items = bx.keys(), bx.values(), bx.items() + bx.c = {"d": 1} + assert "c" in keys and len(keys) == 3 + assert type(list(values)[-1]) is Box + assert ("a", 1) in items + assert list(reversed(bx)) == ["c", "b", "a"] + del bx.a + assert list(keys) == ["b", "c"] + assert bx.popitem() == ("c", {"d": 1}) and bx.popitem() == ("b", 2) + with pytest.raises(BoxKeyError): + bx.popitem() + + def test_repr_and_str_of_nested_frozen_and_subclass_boxes(self): + bx = Box({"a": {"b": [1, {"c": 2}]}}) + assert repr(bx) == "Box({'a': {'b': [1, {'c': 2}]}})" + assert str(bx) == "{'a': {'b': [1, {'c': 2}]}}" + assert repr(bx.a.b) == "BoxList([1, {'c': 2}])" + assert repr(ConfigBox(a=1)) == "ConfigBox({'a': 1})" + assert repr(SBox(a=1)) == "SBox({'a': 1})" + assert repr(ChildDefaults(a=1)) == "ChildDefaults({'a': 1})" + frozen = Box({"a": [1, {"b": 2}]}, frozen_box=True) + assert repr(frozen) == "Box({'a': (1, {'b': 2})})" + assert str(Box()) == "{}" and repr(BoxList()) == "BoxList([])" + + def test_contains_with_unhashable_and_odd_keys(self): + bx = Box({"a": 1, (1, 2): "t", None: "n", 1.5: "f"}) + with pytest.raises(TypeError): + [] in bx + with pytest.raises(TypeError): + {} in bx + with pytest.raises(TypeError): + [] in Box(box_dots=True) + with pytest.raises(TypeError): + [] in ConfigBox() + assert (1, 2) in bx and None in bx and 1.5 in bx + assert bx[(1, 2)] == "t" and bx[None] == "n" + assert "a.b" not in Box({"a": 1}, box_dots=True) diff --git a/test/test_from_file.py b/test/test_from_file.py index 7361e84b..6569028e 100644 --- a/test/test_from_file.py +++ b/test/test_from_file.py @@ -1,11 +1,11 @@ #!/usr/bin/env python # -*- coding: utf-8 -*- from pathlib import Path -from test.common import test_root import pytest from box import Box, BoxError, BoxList, box_from_file, box_from_string +from test.common import test_root class TestFromFile: diff --git a/test/test_json_lines_strings.py b/test/test_json_lines_strings.py new file mode 100644 index 00000000..40ef6f64 --- /dev/null +++ b/test/test_json_lines_strings.py @@ -0,0 +1,63 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +import json + +import pytest + +from box import BoxList + + +@pytest.mark.parametrize("data", [[], [{"a": 1}], [{"a": 1}, {"b": 2}], [None, False, 3, "café\u2028text"]]) +def test_multiline_string_output_matches_file(tmp_path, data): + values = BoxList(data) + path = tmp_path / "values.jsonl" + values.to_json(filename=path, multiline=True) + + result = values.to_json(multiline=True) + + assert result == path.read_text(encoding="utf-8") + assert result == "\n".join(json.dumps(value, ensure_ascii=False) for value in data) + + +@pytest.mark.parametrize("newline", ["\n", "\r\n", "\r"]) +def test_multiline_string_input_matches_file(tmp_path, newline): + text = newline.join(["# comment", "", '{"FirstKey": 1}', " ", ' {"SecondKey": "café\u2028text"} ', "# end"]) + path = tmp_path / "values.jsonl" + path.write_bytes(text.encode("utf-8")) + + result = BoxList.from_json(text, multiline=True, camel_killer_box=True) + from_file = BoxList.from_json(filename=path, multiline=True, camel_killer_box=True) + + assert result == from_file + assert result[0].first_key == 1 + assert result[1].second_key == "café\u2028text" + + +@pytest.mark.parametrize("text", ["", "\n \r\n", "# comment\n # another\n"]) +def test_empty_multiline_string_input(text): + assert BoxList.from_json(text, multiline=True) == [] + + +def test_multiline_string_json_options(): + values = BoxList([{"b": 2, "a": 1}, {"c": 3}]) + text = values.to_json(multiline=True, sort_keys=True, separators=(",", ":")) + + assert text == '{"a":1,"b":2}\n{"c":3}' + assert BoxList.from_json(text, multiline=True, parse_int=str) == [{"a": "1", "b": "2"}, {"c": "3"}] + + +@pytest.mark.parametrize("text", ['{"a": 1}\nnot json', '{"a": 1}\n{"b":']) +def test_multiline_string_rejects_invalid_json(text): + with pytest.raises(json.JSONDecodeError): + BoxList.from_json(text, multiline=True) + + +def test_multiple_objects_require_multiline(): + with pytest.raises(json.JSONDecodeError): + BoxList.from_json('{"a": 1}\n{"b": 2}') + + +def test_default_json_array_behavior(): + values = BoxList([{"a": 1}, {"b": 2}]) + assert json.loads(values.to_json()) == values.to_list() + assert BoxList.from_json(values.to_json()) == values diff --git a/test/test_review_fixes.py b/test/test_review_fixes.py new file mode 100644 index 00000000..2f772264 --- /dev/null +++ b/test/test_review_fixes.py @@ -0,0 +1,102 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +"""Reflected operators keep options, class factories for default_box_attr, ConfigBox "off".""" + +import pytest + +from box import Box, BoxError, BoxList, ConfigBox + + +class Sub(Box): + pass + + +class TestReflectedOperatorsKeepOptions: + @pytest.mark.parametrize("op", ["|", "+"]) + def test_plain_dict_on_the_left(self, op): + right = Sub({"b": {"c": 1}}, box_dots=True, default_box=True, camel_killer_box=True) + result = {"CamelKey": 1} | right if op == "|" else {"CamelKey": 1} + right + assert type(result) is Sub + for option in ("box_dots", "default_box", "camel_killer_box"): + assert result._box_config[option] is True, option + assert result["b.c"] == 1 + assert result.camel_key == 1 + assert result.missing == Sub() + + def test_frozen_right_side(self): + right = Box({"b": 2}, frozen_box=True) + for result in ({"a": 1} | right, {"a": 1} + right): + assert result.to_dict() == {"a": 1, "b": 2} + with pytest.raises(BoxError): + result.c = 3 + assert right.to_dict() == {"b": 2} + + def test_order_rules_unchanged(self): + right = Box({"a": 2, "b": 2}, box_dots=True) + assert ({"a": 1} | right).to_dict() == {"a": 2, "b": 2} + assert ({"a": 1} + right).to_dict() == {"a": 2, "b": 2} + assert (right | {"a": 1}).to_dict() == {"a": 1, "b": 2} + + def test_left_operand_is_not_changed(self): + left = {"a": {"x": 1}} + result = left | Box(box_dots=True) + result["a.x"] = 2 + assert left == {"a": {"x": 1}} + + +class TestDefaultBoxAttrFactories: + def test_list_class_like_defaultdict(self): + b = Box(default_box=True, default_box_attr=list) + assert isinstance(b.tags, BoxList) and b.tags == [] + b.tags = b.tags + [1] + assert b.to_dict() == {"tags": [1]} + + def test_list_class_with_create_on_get(self): + b = Box(default_box=True, default_box_attr=list, default_box_create_on_get=True) + b.tags.append({"a": 1}) + assert b.to_dict() == {"tags": [{"a": 1}]} + assert type(b.tags[0]) is Box + + @pytest.mark.parametrize("factory, expected", [(int, 0), (str, ""), (set, set()), (lambda: "x", "x")]) + def test_other_factories(self, factory, expected): + assert Box(default_box=True, default_box_attr=factory).missing == expected + + def test_optional_parameters_are_left_alone(self): + def factory(key, prefix="item-"): + return prefix + key + + assert Box(default_box=True, default_box_attr=factory).thing == "item-thing" + + def test_positional_only_and_keyword_only(self): + def positional(key, box_instance, /): + return (key, type(box_instance).__name__) + + def keyword_only(*, box_instance, key): + return (key, type(box_instance).__name__) + + assert Box(default_box=True, default_box_attr=positional).a == ("a", "Box") + assert Box(default_box=True, default_box_attr=keyword_only).a == ("a", "Box") + + def test_required_unknown_parameter(self): + def factory(key, other): + return key + + with pytest.raises(BoxError, match="not 'other'"): + Box(default_box=True, default_box_attr=factory).a + + def test_class_with_key_parameter(self): + class Named: + def __init__(self, key): + self.key = key + + assert Box(default_box=True, default_box_attr=Named).thing.key == "thing" + + +class TestConfigBoxBool: + @pytest.mark.parametrize("value", ["off", "OFF", " Off ", "no", "false", "0", "n", "f", ""]) + def test_false_values(self, value): + assert ConfigBox(flag=value).bool("flag") is False + + @pytest.mark.parametrize("value", ["on", "yes", "true", "1", "y", "t", "anything"]) + def test_true_values(self, value): + assert ConfigBox(flag=value).bool("flag") is True diff --git a/test/test_sbox.py b/test/test_sbox.py index ea0d06a7..2725ba5f 100644 --- a/test/test_sbox.py +++ b/test/test_sbox.py @@ -1,13 +1,11 @@ #!/usr/bin/env python # -*- coding: utf-8 -*- import json -from test.common import test_dict - -import pytest from ruamel.yaml import YAML from box import Box, SBox +from test.common import test_dict class TestSBox: diff --git a/test/test_yaml_order.py b/test/test_yaml_order.py new file mode 100644 index 00000000..fd9148f9 --- /dev/null +++ b/test/test_yaml_order.py @@ -0,0 +1,43 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +"""to_yaml writes keys in insertion order with every YAML backend (#104).""" + +import pytest + +import box.converters as converters +from box import Box, BoxList + +DATA = {"zlast": 1, "afirst": {"z": 1, "a": 2}} +IN_ORDER = "zlast: 1\nafirst:\n z: 1\n a: 2\n" +SORTED = "afirst:\n a: 2\n z: 1\nzlast: 1\n" + + +@pytest.fixture(params=["ruamel-rt", "ruamel-safe", "pyyaml"]) +def backend(request, monkeypatch): + if request.param == "pyyaml": + if not converters.pyyaml_available: + pytest.skip("PyYAML is not installed") + monkeypatch.setattr(converters, "ruamel_available", False) + return {} + if not converters.ruamel_available: + pytest.skip("ruamel.yaml is not installed") + return {"ruamel_typ": request.param.split("-")[1]} + + +class TestYamlOrder: + def test_insertion_order_by_default(self, backend): + assert Box(DATA).to_yaml(**backend) == IN_ORDER + + def test_sort_keys_opt_in(self, backend): + if backend.get("ruamel_typ", "safe") == "rt": + pytest.skip("the ruamel round trip dumper never sorts") + assert Box(DATA).to_yaml(sort_keys=True, **backend) == SORTED + + def test_file_output_and_box_list(self, backend, tmp_path): + path = tmp_path / "order.yaml" + Box(DATA).to_yaml(filename=path, **backend) + assert path.read_text() == IN_ORDER + assert BoxList([DATA]).to_yaml(**backend) == "- zlast: 1\n afirst:\n z: 1\n a: 2\n" + + def test_round_trip_keeps_order(self, backend): + assert list(Box.from_yaml(Box(DATA).to_yaml(**backend)).keys()) == ["zlast", "afirst"] diff --git a/uv.lock b/uv.lock new file mode 100644 index 00000000..bae615f2 --- /dev/null +++ b/uv.lock @@ -0,0 +1,1537 @@ +version = 1 +revision = 5 +requires-python = ">=3.11" +resolution-markers = [ + "python_full_version >= '3.15'", + "python_full_version < '3.15'", +] + +[[package]] +name = "ast-serialize" +version = "0.13.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/21/d5/5dc1ee8a80c3b20a0b63c61b43ba6bc53517faecd1def47bcd752d22268e/ast_serialize-0.13.1.tar.gz", hash = "sha256:401cc84e8888d4d76f2c8d296fa006ed1a5ff993b6aff90dd777c03973efd025", size = 955137, upload-time = "2026-10-17T00:04:17.183Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f3/a8/fbd136b9f70c59e75f59a8e974c84102976f1201828b4f886480ba956936/ast_serialize-0.13.1-cp314-cp314-pyemscripten_2026_0_wasm32.whl", hash = "sha256:3e129d44b0cffbea24a7f40117ce49e30993c3d119e584d4817ebd6f87246456", size = 897306, upload-time = "2026-10-17T00:02:52.479Z" }, + { url = "https://files.pythonhosted.org/packages/50/3f/2ad51e9823a790e7a70fd781e9595ab3abeace27f3aefcaa1939457efd72/ast_serialize-0.13.1-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:523d45bab16ddaf1399c04c4fe81bbf180f81e33c2f7bcbe76be56b0f7311ab4", size = 1236082, upload-time = "2026-10-17T00:02:54.82Z" }, + { url = "https://files.pythonhosted.org/packages/c0/5c/8e959db5cc2237f9d4c560a8e2253c98f9746883fb4774651e4cda458901/ast_serialize-0.13.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:638333fb8ae72c62753f9e794fda20290883ddc65b0d85e26e08f8bb227567ad", size = 1221242, upload-time = "2026-10-17T00:02:56.395Z" }, + { url = "https://files.pythonhosted.org/packages/d6/05/ab1c56c3b7adcac88764bba609502d6b4989e449b2dd60eb478e1d20e369/ast_serialize-0.13.1-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:cc34c670747d85d4232834665e247009413eaebe47c69eaf60a5c439aaecaed9", size = 1282105, upload-time = "2026-10-17T00:02:58.275Z" }, + { url = "https://files.pythonhosted.org/packages/0d/f4/41981fcd2ddffe0760e5326be9dcbd2eda9478a8430a637e5123bd8fcb26/ast_serialize-0.13.1-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:8c8ebd419811c435812d242fb2a173e57dfede198c9ac9a0a584666ebc9b9331", size = 1287905, upload-time = "2026-10-17T00:03:00.068Z" }, + { url = "https://files.pythonhosted.org/packages/6a/43/b783addc5681153707121991b7b47892f7e9c8ba58a0d03b71a3b023ba47/ast_serialize-0.13.1-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:8899c038b1c15ae8b98e379057fb3ef398ceb0b21d1737a8156dd5a0923b7e51", size = 1541806, upload-time = "2026-10-17T00:03:01.503Z" }, + { url = "https://files.pythonhosted.org/packages/47/10/969db095038ee15270f65ad20d1129c5e4da605bf7e93b70ae640f1c8a9f/ast_serialize-0.13.1-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e14c4de98f965647a74e6eaf37e20207124e45451ccd36e84a6f6ebab45e0372", size = 1309946, upload-time = "2026-10-17T00:03:02.971Z" }, + { url = "https://files.pythonhosted.org/packages/06/dd/7c623d2fb0b868948952d1787e629a43b866f7d4caefd5445e20aefacec4/ast_serialize-0.13.1-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7f3e8a3eff69af640db985360fef35073fb46956dfc3e5c614cf00920d2746dd", size = 1302773, upload-time = "2026-10-17T00:03:04.378Z" }, + { url = "https://files.pythonhosted.org/packages/d4/c2/4d49469110a19a44fc6269f4fd59679bcf84df068f185f89b73bee4da19b/ast_serialize-0.13.1-cp314-cp314t-manylinux_2_31_riscv64.whl", hash = "sha256:75d7750fe98f6f35a96c43aba8d98a2e623e22c778a0c17ab9ede92eb10f5d82", size = 1299579, upload-time = "2026-10-17T00:03:05.88Z" }, + { url = "https://files.pythonhosted.org/packages/9d/9a/2d381f1f262dda15affc8ad643fba1619eb07e7d9f8bd904deffef183006/ast_serialize-0.13.1-cp314-cp314t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:43e8ddd63e80fc280c2f790157386f27f9b9f6ccb9c4f8e803b863cbfb085769", size = 1355969, upload-time = "2026-10-17T00:03:07.321Z" }, + { url = "https://files.pythonhosted.org/packages/9d/9c/2266794e6c25fa9ce51ce04a9bf4b7e330e3ac9351ba3fa14e487678acdb/ast_serialize-0.13.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:9221e09496fb942901993c1812ee87950cc0ecbb514c7c0f1f5fa6d78f701ed8", size = 1460227, upload-time = "2026-10-17T00:03:08.733Z" }, + { url = "https://files.pythonhosted.org/packages/2b/d6/14deb28e5d8f328f626a0778ea2cf98fe908f2bbcccd804cb6f449ee1782/ast_serialize-0.13.1-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:7a5c38bdb93669c596f94fb7204dd6ebe4fadb19058ac9a2faf2948c2a175f96", size = 1562691, upload-time = "2026-10-17T00:03:10.25Z" }, + { url = "https://files.pythonhosted.org/packages/f5/19/7a28c0e5ba54f0d3e054f847a2a549b748cb179ab433321a8dc1b39e398d/ast_serialize-0.13.1-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:acf4e9f055d75058ab01536da330648746f2f82b7697a85230547f2d5ebe895c", size = 1558669, upload-time = "2026-10-17T00:03:11.799Z" }, + { url = "https://files.pythonhosted.org/packages/18/9a/f9e2690eab58217f1d395a964a78efa7eaf813a1e38be8dfd9a8d45d0840/ast_serialize-0.13.1-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:87427913c325adc811e81e7c9a757b061f47ef1e29114ac479aa0953a2687a98", size = 1665071, upload-time = "2026-10-17T00:03:13.284Z" }, + { url = "https://files.pythonhosted.org/packages/8e/f3/ef5b159a0d7161b404f05e7ec21cf7735ee7edc10c000cd2cbbc7bb6b69a/ast_serialize-0.13.1-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:ad88921f95b92bc144d9ad059a0e16f8c1ae69f5239f2d3c6536fd2774f73dfe", size = 1473364, upload-time = "2026-10-17T00:03:14.563Z" }, + { url = "https://files.pythonhosted.org/packages/1d/87/6e8ac4a865124a12cc4f915bf1bcfac3bba426cd5f58d3712a873ee61012/ast_serialize-0.13.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:f8b17e2921e56621bcb46792bd3e0b82ca3b85de78d5936e7b8174ba1758b0aa", size = 1500566, upload-time = "2026-10-17T00:03:15.917Z" }, + { url = "https://files.pythonhosted.org/packages/f5/1e/29155f1621433008013ad5c940a03d41a676be0680c41527040472d37583/ast_serialize-0.13.1-cp314-cp314t-win32.whl", hash = "sha256:2f9a9ce8b0994f757b941f7f7fe384a6666b4162b941ebc5c248081baea18e47", size = 1128674, upload-time = "2026-10-17T00:03:17.481Z" }, + { url = "https://files.pythonhosted.org/packages/bb/64/2506da65143ea138de5822e9173e0b72320a2f70e23bd723f044033175f1/ast_serialize-0.13.1-cp314-cp314t-win_amd64.whl", hash = "sha256:5d99910e6b9a9b9360bcca2ae99aee36cc912ce058df2a57d1c33099b6cb2593", size = 1163306, upload-time = "2026-10-17T00:03:19.046Z" }, + { url = "https://files.pythonhosted.org/packages/6d/8f/c7cb22638899b0cf15908809c270560e46395e65604bc59e4b623ab9f405/ast_serialize-0.13.1-cp314-cp314t-win_arm64.whl", hash = "sha256:a789cbe14d0a0e9ec9b32a456e5abc81ad8799479c3cfd88a29e3442262aebe6", size = 1133775, upload-time = "2026-10-17T00:03:20.377Z" }, + { url = "https://files.pythonhosted.org/packages/2b/e2/b0c140fe50fa39dd249e382f7733af6f816c90021fe7959a0b026f86237f/ast_serialize-0.13.1-cp315-abi3.abi3t-macosx_10_12_x86_64.whl", hash = "sha256:23d768369b89d551077dc173da6892fad00443338417523b6732f4e8ba4a7ed5", size = 1236160, upload-time = "2026-10-17T00:03:21.945Z" }, + { url = "https://files.pythonhosted.org/packages/23/c4/a8a2ca21e3943555b48221f8fba546877a7ad39efaf6505506524967d7c4/ast_serialize-0.13.1-cp315-abi3.abi3t-macosx_11_0_arm64.whl", hash = "sha256:68f8829d114dab6c9db4a8bbb8d0e342958faee1b5e15a29022678df639960f8", size = 1222214, upload-time = "2026-10-17T00:03:23.462Z" }, + { url = "https://files.pythonhosted.org/packages/15/19/2f58f2ba64e4799b39de85c140aef09a03aa6ea53be75dd292a9d9b9d8ae/ast_serialize-0.13.1-cp315-abi3.abi3t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4e385b17d5bde892a6184003a9aff3518387908b73f8f5ea539313c07c8c0ede", size = 1282979, upload-time = "2026-10-17T00:03:24.695Z" }, + { url = "https://files.pythonhosted.org/packages/b1/af/ca6087fe84210c1ccd43e3182917bb70649fa1e69745a90c1d59ba08fea8/ast_serialize-0.13.1-cp315-abi3.abi3t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:02686b281ec9b8e9614f6f0db27e12e4cac515f336c5d05b678bc9eb73ff2af5", size = 1288596, upload-time = "2026-10-17T00:03:26.04Z" }, + { url = "https://files.pythonhosted.org/packages/b0/2c/4ef964c763329a0347125e745ec0451ba4fbaceec9efe2ac729b7cd55f17/ast_serialize-0.13.1-cp315-abi3.abi3t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:a8ab2c2585b2e22e48cd4aff2136fce4eab4ced569b85f150ef9a5a5d6f34d49", size = 1545540, upload-time = "2026-10-17T00:03:27.52Z" }, + { url = "https://files.pythonhosted.org/packages/bb/85/aa961dbb75813cfa94de0ce9a16a9510c226b95f604c405421e727f44bb0/ast_serialize-0.13.1-cp315-abi3.abi3t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:c652d9f5d52d8b81eff3ff2c95c9dd0f281de45f6ad5d3fa95527550c396454a", size = 1309374, upload-time = "2026-10-17T00:03:29.091Z" }, + { url = "https://files.pythonhosted.org/packages/b4/e6/f2b67c327d9f9533e41791804403ccc2dc457821195a2e51f0b587a90b90/ast_serialize-0.13.1-cp315-abi3.abi3t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:121e1d08d58b75c15491cc3003609cbad71ac2b0016043c36d30a6b2032b6605", size = 1303466, upload-time = "2026-10-17T00:03:30.451Z" }, + { url = "https://files.pythonhosted.org/packages/73/1d/33f18b81d1bb1f5d682943ea92fda8130a6593627f12f6201668d40824fd/ast_serialize-0.13.1-cp315-abi3.abi3t-manylinux_2_31_riscv64.whl", hash = "sha256:30cf89b6a6844542d116c758725d13de5b97b9410a51ee577715f761270d0c1c", size = 1300576, upload-time = "2026-10-17T00:03:32.102Z" }, + { url = "https://files.pythonhosted.org/packages/25/cb/64914144925f1a4abdd9217e717b122255c38fc5ebe4342f92052f3bacbc/ast_serialize-0.13.1-cp315-abi3.abi3t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:732aaae9e498c973fc63fd7f308009b57c4afa6ff59d0b674d894e57d0bca01a", size = 1355960, upload-time = "2026-10-17T00:03:33.676Z" }, + { url = "https://files.pythonhosted.org/packages/ee/80/bd29379fab2bce19adc0bf9177002b11b23dfe8d8fecf409998b458b4624/ast_serialize-0.13.1-cp315-abi3.abi3t-musllinux_1_2_aarch64.whl", hash = "sha256:d9c1a920b2aa0c1e016bed7721689717034ca0dba64ac3a3ff243b003d4e8dd8", size = 1459779, upload-time = "2026-10-17T00:03:35.09Z" }, + { url = "https://files.pythonhosted.org/packages/83/89/012dbe733de05ffdf8e40ca0f9fa5d417cb16ec93a74463c57c001914198/ast_serialize-0.13.1-cp315-abi3.abi3t-musllinux_1_2_armv7l.whl", hash = "sha256:847cad4c22953823f5e76d0b126c6f9da670cfa45b1df41b9324e22189d77611", size = 1563399, upload-time = "2026-10-17T00:03:37.285Z" }, + { url = "https://files.pythonhosted.org/packages/69/37/ee4bcb0358bee38744eb0f18560446572d095fe3bf6b63d6f739d08a839c/ast_serialize-0.13.1-cp315-abi3.abi3t-musllinux_1_2_i686.whl", hash = "sha256:aca07de3ca8e3d9f2b716c3c31f4f384fe4bd2d03e09912417cff7a3e08036f7", size = 1558808, upload-time = "2026-10-17T00:03:38.711Z" }, + { url = "https://files.pythonhosted.org/packages/54/1c/ff44c5355251d61ef22934c4430bb31a61de4781d25a992154aac9b8c82a/ast_serialize-0.13.1-cp315-abi3.abi3t-musllinux_1_2_ppc64le.whl", hash = "sha256:5db12d843d931b9d1f1519ce66b9cbfe72d8563b75c1204d255322254d1964dd", size = 1666324, upload-time = "2026-10-17T00:03:40.376Z" }, + { url = "https://files.pythonhosted.org/packages/c8/bb/6da4bfc8aa3403e6447607131bf3463acaf954d990c6c8b6787c1902ddfe/ast_serialize-0.13.1-cp315-abi3.abi3t-musllinux_1_2_riscv64.whl", hash = "sha256:fb8021f4dc3296de18737e3b8b34994411da725374d74a0b9eb32a738f2a23d0", size = 1474089, upload-time = "2026-10-17T00:03:41.715Z" }, + { url = "https://files.pythonhosted.org/packages/21/97/897e33bef2eefd880e6350e375cc66bc5bcd00a139be480fd655f5b3f095/ast_serialize-0.13.1-cp315-abi3.abi3t-musllinux_1_2_x86_64.whl", hash = "sha256:0d764913374ba21df8cd618045b371ed104ce55c6276de7c59e554a4f5ba26fd", size = 1501542, upload-time = "2026-10-17T00:03:43.08Z" }, + { url = "https://files.pythonhosted.org/packages/8d/4c/821211ac83870c27e4412381b7c7838336456b40575bf840e4680b2018d9/ast_serialize-0.13.1-cp315-abi3.abi3t-win32.whl", hash = "sha256:2bad302ae2427454ef9dab71bd5c3ad67188860c39d36daee38f72031edb39c4", size = 1126118, upload-time = "2026-10-17T00:03:44.616Z" }, + { url = "https://files.pythonhosted.org/packages/1f/86/2b2d5e6c4fa352874a80618e742ffd32d249dee6c119f4233b51afc6b8f4/ast_serialize-0.13.1-cp315-abi3.abi3t-win_amd64.whl", hash = "sha256:032b09d86c785c3984e975378b7861f2a68ac44e22ba7b07b93a536b2524eeb8", size = 1163766, upload-time = "2026-10-17T00:03:45.986Z" }, + { url = "https://files.pythonhosted.org/packages/77/a3/d610cfcdabaa44fd62a54ca1fc57a7dba120643798b089a14914973562de/ast_serialize-0.13.1-cp315-abi3.abi3t-win_arm64.whl", hash = "sha256:929eda0c419e622ab49df3a4c45f81c57dcc10874bbad55d0470a4a03324dac3", size = 1134043, upload-time = "2026-10-17T00:03:48.453Z" }, + { url = "https://files.pythonhosted.org/packages/f0/89/0e30f9eddf7d44ccf9d25979030754fd0457af61fa4279acb8c293a04f97/ast_serialize-0.13.1-cp315-cp315-pyemscripten_2026_5_wasm32.whl", hash = "sha256:bf53a3ba1cbe45399fc1e4ccd684b8f2a11cca450f89706b79122f478534c6f5", size = 897546, upload-time = "2026-10-17T00:03:50.093Z" }, + { url = "https://files.pythonhosted.org/packages/81/92/d705be88ff452b9ba0088b554a0cbd308fd01879da092b33fd2ad7d1aa60/ast_serialize-0.13.1-cp39-abi3-macosx_10_12_x86_64.whl", hash = "sha256:4bcf1d5f4eefecaa325a34ecf079b2741189e7d0821523f92cb343a389a67489", size = 1242416, upload-time = "2026-10-17T00:03:51.521Z" }, + { url = "https://files.pythonhosted.org/packages/60/c2/98370845a7f35cb8a25782e78284b48e01bf3128339881d48d613f304f8f/ast_serialize-0.13.1-cp39-abi3-macosx_11_0_arm64.whl", hash = "sha256:1b158f1c9e3a0d386913924c57995d6df78224868a4d0f215bdd41587c97b34a", size = 1229729, upload-time = "2026-10-17T00:03:52.825Z" }, + { url = "https://files.pythonhosted.org/packages/d8/8b/2d7ffed76addd9d3fcf37fb171400942735c8912264c763561a85407f6a8/ast_serialize-0.13.1-cp39-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:77a6201b69ce42e919f2fd9a559138d5410b5d8afff7c3a6b1f500b0481ff7d8", size = 1292255, upload-time = "2026-10-17T00:03:54.148Z" }, + { url = "https://files.pythonhosted.org/packages/6b/2a/bb9e0e719d89cc950fadfcfcc9cb4bc7640419c4228c852f031ab8abf440/ast_serialize-0.13.1-cp39-abi3-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:6eb0be64c9b8f1ed26637eef345abe75ea90351c92c85a8aec7838b3af971011", size = 1298501, upload-time = "2026-10-17T00:03:55.559Z" }, + { url = "https://files.pythonhosted.org/packages/7a/32/13ce07dce48226f5bd9cfd8f708ec101a8be05aa430cda4918ce31ce8c82/ast_serialize-0.13.1-cp39-abi3-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:7f2427bddfca208e84de700044fadf9aef2769a70bae740a1bdabb89ee9e1117", size = 1553758, upload-time = "2026-10-17T00:03:56.952Z" }, + { url = "https://files.pythonhosted.org/packages/e2/fb/9b51d186db0c20ca28cbaaefd50f03b573c89327b9a2627820cbce22196b/ast_serialize-0.13.1-cp39-abi3-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:88df960e67184a71874e5b2ee014f87d1254a0dbc1f903c7bd7b1ab7733ecaef", size = 1318258, upload-time = "2026-10-17T00:03:58.418Z" }, + { url = "https://files.pythonhosted.org/packages/c5/fa/da311559dd3dae9af5825cf21660775a929b970f72e3786af3f2cd667944/ast_serialize-0.13.1-cp39-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9f99786e0d62082a5b121b3437f3167562133711df22128de1e9886f57f0b226", size = 1313260, upload-time = "2026-10-17T00:04:00.194Z" }, + { url = "https://files.pythonhosted.org/packages/2b/11/97a4b9e5b4776d72f47fcd9a09a497bbf68ec8c1ae074307a2c51e410d85/ast_serialize-0.13.1-cp39-abi3-manylinux_2_31_riscv64.whl", hash = "sha256:a01b515b25a03184eff4acef25b981ae007916379682e908fc8785b342a0bf3e", size = 1309992, upload-time = "2026-10-17T00:04:01.575Z" }, + { url = "https://files.pythonhosted.org/packages/2e/c4/62f85121a80cd451ef04f550cf0f7ea0ad9ff46cc4e9a5b9ae439b6527b1/ast_serialize-0.13.1-cp39-abi3-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:29422d7bcd9e7f39411571c36cec45ce8a7a9b3ad4b2e7aa64497c15a9e397f6", size = 1362715, upload-time = "2026-10-17T00:04:02.881Z" }, + { url = "https://files.pythonhosted.org/packages/c1/fa/c5f4a545f72a7681e3295bab6e3600ee0862ec4391bed961fe9f735b67e0/ast_serialize-0.13.1-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:6ffb0f548a7dc126067fdfb7b2325ab5dfcdeecc29faf5e0f0461c96d6ebfa3d", size = 1469931, upload-time = "2026-10-17T00:04:04.181Z" }, + { url = "https://files.pythonhosted.org/packages/38/a9/65aed4f8fa7a001a7cfdc03e68e844517ab041ba6fb614b7d78a1d6ac056/ast_serialize-0.13.1-cp39-abi3-musllinux_1_2_armv7l.whl", hash = "sha256:2876444a5f87a7c76f371af3c07c2fda563a08bc8af52568df812e8aba4bf568", size = 1570945, upload-time = "2026-10-17T00:04:05.778Z" }, + { url = "https://files.pythonhosted.org/packages/fb/8c/44b2da991cede79bfbf52089f33a5f0168945466b3d9cd38b5dcf08e7130/ast_serialize-0.13.1-cp39-abi3-musllinux_1_2_i686.whl", hash = "sha256:885a62ec6481ce58ab24c6357360d7a82023b62dd7e5e7ceccf59e9662a3272b", size = 1569978, upload-time = "2026-10-17T00:04:07.347Z" }, + { url = "https://files.pythonhosted.org/packages/46/e4/109b2a5beca700237767d5add920c2f8e1ba9bd5799b0faf143d0e9cf4ef/ast_serialize-0.13.1-cp39-abi3-musllinux_1_2_ppc64le.whl", hash = "sha256:2015fd0165e463aac3b1aadc6a1fa1e5820c14ca950821f4fe02f8a3f6a388d6", size = 1676082, upload-time = "2026-10-17T00:04:08.7Z" }, + { url = "https://files.pythonhosted.org/packages/73/e0/7df70f6dbb11b5762da5416318f08316a1c51348e0d69ec79ca5f98f836a/ast_serialize-0.13.1-cp39-abi3-musllinux_1_2_riscv64.whl", hash = "sha256:eb41e1906502ac80d24ff343f45008552a3f5b5158607959fe6a07dbfc6eb037", size = 1483207, upload-time = "2026-10-17T00:04:10.162Z" }, + { url = "https://files.pythonhosted.org/packages/1f/bc/523aa1c08bd69b5654621beb3dc1a9035715a4a63762fb8d219d6fb3eb81/ast_serialize-0.13.1-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:ca9acc67f796aa2554fa3037dccc022a4b08b38b2ad153edfac9c9bb7cb1f3c6", size = 1512140, upload-time = "2026-10-17T00:04:11.589Z" }, + { url = "https://files.pythonhosted.org/packages/66/83/6607060659998f00afdea0d8375c1e6e2b7d515ab905090d9a5a02f48851/ast_serialize-0.13.1-cp39-abi3-win32.whl", hash = "sha256:4f98da562e5901d69c7dd30885594c5438f859edf354e9ac7517d188fb026c3a", size = 1131889, upload-time = "2026-10-17T00:04:12.953Z" }, + { url = "https://files.pythonhosted.org/packages/9f/6f/bafd6490fe7b355627fabe95f4417e3d02da93102c8552550eb9a0774e1e/ast_serialize-0.13.1-cp39-abi3-win_amd64.whl", hash = "sha256:ddf7cbc9c8abf70102c4a088efe154bb86bfb825b0a10e556d2b15972cf99bd7", size = 1171153, upload-time = "2026-10-17T00:04:14.362Z" }, + { url = "https://files.pythonhosted.org/packages/11/25/4235f4b375a67a37ac595bf478a5407a744eaf7b64113c1c3a5432b8d954/ast_serialize-0.13.1-cp39-abi3-win_arm64.whl", hash = "sha256:48f11d96c9ec71119612f8e79a8c55c12f2b136716d68347433c561d27a25f43", size = 1139035, upload-time = "2026-10-17T00:04:15.767Z" }, +] + +[[package]] +name = "backports-tarfile" +version = "1.2.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/86/72/cd9b395f25e290e633655a100af28cb253e4393396264a98bd5f5951d50f/backports_tarfile-1.2.0.tar.gz", hash = "sha256:d75e02c268746e1b8144c278978b6e98e85de6ad16f8e4b0844a154557eca991", size = 86406, upload-time = "2024-05-28T17:01:54.731Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b9/fa/123043af240e49752f1c4bd24da5053b6bd00cad78c2be53c0d1e8b975bc/backports.tarfile-1.2.0-py3-none-any.whl", hash = "sha256:77e284d754527b01fb1e6fa8a1afe577858ebe4e9dad8919e34c862cb399bc34", size = 30181, upload-time = "2024-05-28T17:01:53.112Z" }, +] + +[[package]] +name = "build" +version = "1.6.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "colorama", marker = "os_name == 'nt'" }, + { name = "packaging" }, + { name = "pyproject-hooks" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/bd/67/4898a44ea4f3f8e213b0954ec0aa0a16971d62a6212d6ea3931e97115b99/build-1.6.1.tar.gz", hash = "sha256:51cc11666391ab6f092070437ac747002ff46f3e4113a3622177ee6b488bfc53", size = 113427, upload-time = "2026-09-10T07:56:00.417Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ad/9b/9fb3585dabcd73a1b2a6267f63f62649347c9e6d072c9fde365b105abb2c/build-1.6.1-py3-none-any.whl", hash = "sha256:ecd351a4be9d35a9eaaba244a7687143c9c7d4aea6ac964e7e7ddab20cbcf4e7", size = 31179, upload-time = "2026-09-10T07:55:59.148Z" }, +] + +[[package]] +name = "certifi" +version = "2026.10.23" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/fd/11/b524cbd9bbdaca58608e4cf4053fd463417549e1959fa8d3aa18319f9555/certifi-2026.10.23.tar.gz", hash = "sha256:a9895e6e2758b371e0545e321a3a8fd1fcfd9829ada8824a936dfb16aaaf36cd", size = 136225, upload-time = "2026-10-23T11:36:16.478Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/32/d1/a3652fe2c19134d0d15922177821d863cbd7e842d53a21bbe7e8e3a1b5ac/certifi-2026.10.23-py3-none-any.whl", hash = "sha256:e9b54de76e530bb6cf0ccd036787103acb58fd42ba930ea8bf948ddbaa2f61d1", size = 135082, upload-time = "2026-10-23T11:36:14.763Z" }, +] + +[[package]] +name = "cffi" +version = "2.1.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pycparser", marker = "implementation_name != 'PyPy'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/9e/ef/008a1939e372c06329a3fce4279c02f328488f3526744906eeec3da7ad5f/cffi-2.1.1.tar.gz", hash = "sha256:dd31f52ea1086513bb9df30f8fcee9b8918323ae067a3d5b78bc826a000712be", size = 530807, upload-time = "2026-08-03T21:21:18.939Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ad/5a/4707a0dc1f203f5dde5a907b0d4e3c25d71120241048bd5bc6f1bb9d4e71/cffi-2.1.1-cp311-cp311-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:154852545011f779917b11c78db2358d095da62a9a172b78ad0a583ee5adc0d0", size = 211805, upload-time = "2026-08-03T21:19:31.867Z" }, + { url = "https://files.pythonhosted.org/packages/ad/66/c19feabb28485b6e0bbaaafa90837a1ef5d302e90f2178bd33f17a49879b/cffi-2.1.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:3311ed60d36f83378794e1009ac6258bafbf81f7888b4caa7b35a521e3f95813", size = 218716, upload-time = "2026-08-03T21:19:32.896Z" }, + { url = "https://files.pythonhosted.org/packages/f7/a4/4399daaf8f7dfee9d7c3327fdb0426ee041cc63edc358b93911ceb2bfc7a/cffi-2.1.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:34e261f78cb6ceaaa36f42f2613f4380d94d9c759a9c73c769ee6e0247364632", size = 217807, upload-time = "2026-08-03T21:19:36.286Z" }, + { url = "https://files.pythonhosted.org/packages/28/f7/dabe6da2466ecbd82dc62e7342dc6b1065dad990c06f00f0ede9ebf2a0ed/cffi-2.1.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:7225e4514edb64eb6740324353e0da0711954fd8d7da4576755b1c6e09b697cd", size = 221252, upload-time = "2026-08-03T21:19:37.416Z" }, + { url = "https://files.pythonhosted.org/packages/ce/87/616202d8e51342c07d2534c510111c4cc37201775ce8f60802c9335d1edd/cffi-2.1.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:df913725b79db7bcf03448f36b7bf8815363417d5b58deecf9305e3e30f0f21a", size = 214214, upload-time = "2026-08-03T21:19:38.507Z" }, + { url = "https://files.pythonhosted.org/packages/b4/c6/ab025d75d2c26c19b087c0124e75ee31cb65032f4fe345d356d8c507ab97/cffi-2.1.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:f5cfbc5fe74540d335175b656c725d74d90e3730c626d92575eea35029d9afaa", size = 219408, upload-time = "2026-08-03T21:19:39.809Z" }, + { url = "https://files.pythonhosted.org/packages/56/e6/8941622732edec876dd17d0453dce07317ae96db34f2ec1436c9d3785986/cffi-2.1.1-cp312-cp312-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:811bd1e21d32de12efca32393a0ab3f5133b54fce9bd44b8bd77ab07da14bf6a", size = 214799, upload-time = "2026-08-03T21:19:47.218Z" }, + { url = "https://files.pythonhosted.org/packages/44/de/f98430906df1545ffde0d543dd124a7a439bc2cd32b36b9c53f805df7333/cffi-2.1.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:68e62fe11f30d5ca8289242866f0a5291402d8529ca2178ab8afc5c9694ae890", size = 222389, upload-time = "2026-08-03T21:19:48.331Z" }, + { url = "https://files.pythonhosted.org/packages/b1/db/dceb9dd5b231e1da801793f8acc9f3c52a7e1afe40bb1aae37e02b0faad5/cffi-2.1.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:c1453022f490d2459a11819d83ad1d586e9ff65a12ac3e705ffebd46d3685dcf", size = 221822, upload-time = "2026-08-03T21:19:52.054Z" }, + { url = "https://files.pythonhosted.org/packages/a0/d2/6cd24ae3be000a634109c247d1475d62e5616d0dc78c82770942ec384248/cffi-2.1.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:208f941bb9d18e768138677f0a6d2ce01f590df56043dda1df1535ac57c88517", size = 225232, upload-time = "2026-08-03T21:19:53.109Z" }, + { url = "https://files.pythonhosted.org/packages/cb/52/3fa190537004dd7f0ab860a6dc7c0175b8667f68d1e618a46f5498d30250/cffi-2.1.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:210019b6c7cf07f081b4c54635c8cf744377001350e29cc0f81c4377b4797735", size = 223597, upload-time = "2026-08-03T21:19:54.515Z" }, + { url = "https://files.pythonhosted.org/packages/9d/f4/035513d4117049066b4779dc3b7c0c0fdad175fa13731c9f4003f1cd1478/cffi-2.1.1-cp313-cp313-ios_13_0_arm64_iphoneos.whl", hash = "sha256:b5bdfd1c873d4e093aabc0ca84c4ca6dbc4f752afb5c86f146d9742580c9da2e", size = 194248, upload-time = "2026-08-03T21:19:59.399Z" }, + { url = "https://files.pythonhosted.org/packages/76/af/2aeb4dbb5fc41a04161ae9ff1518de7cec08e164f44a8ce6a4cf7fd2cd1d/cffi-2.1.1-cp313-cp313-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:31348097ff5bbe827ccc41795d4dd099d9f0625e7def00ee653c137a490c2a6c", size = 196908, upload-time = "2026-08-03T21:20:00.746Z" }, + { url = "https://files.pythonhosted.org/packages/43/1f/1c3d90d91811c8f86ced9ed637956c54bfe5b79ca98fe976d7f8c8979f6b/cffi-2.1.1-cp313-cp313-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:6a8dddef476fab96d066d578fc88526767b836ab5ab21754e1d5bf3879c31c7c", size = 214722, upload-time = "2026-08-03T21:20:04.377Z" }, + { url = "https://files.pythonhosted.org/packages/37/6f/3b5ce4c3b2192d250f04908f2bfd91ef34552ec8f7716a5d4abdb8d67bb2/cffi-2.1.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:f16c709686a78c727bbbf059f92b0bf41c6fc60deec706d2dc19f529175a6125", size = 222369, upload-time = "2026-08-03T21:20:05.544Z" }, + { url = "https://files.pythonhosted.org/packages/95/95/86342356ff5953b3fb06f7ef7c5bee212d45e770abc7218d451b9148313c/cffi-2.1.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:a931079504ecc49efed7744c476a5c343a92fabf66dec2db95edb1b2fdc770e2", size = 221824, upload-time = "2026-08-03T21:20:09.274Z" }, + { url = "https://files.pythonhosted.org/packages/eb/ff/7b3429ff53aafe931ed8a5fc69f481bbef7ba6de87ddcbb63d08f483f613/cffi-2.1.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:a2d7755bef5a12ed488f4ef1f1b69ee9191d7396083b755a5d2295f6edb4768b", size = 225148, upload-time = "2026-08-03T21:20:10.7Z" }, + { url = "https://files.pythonhosted.org/packages/34/34/a95870b9221e09cf4f2ce3178b1a210abdfe63a1bd357da940418d7b8d15/cffi-2.1.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:e0bcb7e0f677f543555d2adff3bf19c05f66cdb4796e5ff602442ab2fe3c4ef7", size = 223564, upload-time = "2026-08-03T21:20:12.165Z" }, + { url = "https://files.pythonhosted.org/packages/d3/7b/d6bbf82b8b96e7391438898c42f5bd96dd02030fd5b64937d248220003e2/cffi-2.1.1-cp314-cp314-ios_13_0_arm64_iphoneos.whl", hash = "sha256:7dbb61fe3a7699468030f71bbe5f8a0e326a151daa91beb11a6fc1f980c55e1c", size = 194064, upload-time = "2026-08-03T21:20:17.148Z" }, + { url = "https://files.pythonhosted.org/packages/94/e6/bcc91b283be94735e268487a054004f0aa19947b6348fa367db53230abc8/cffi-2.1.1-cp314-cp314-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:f24fb43132a4c6b4cb4eb029492919b2db645be6808d738f244fd146c03c32cb", size = 196720, upload-time = "2026-08-03T21:20:18.268Z" }, + { url = "https://files.pythonhosted.org/packages/67/b8/b42132ca113dc567d37684437b46ca1dafc885902b02a110a02d5b511857/cffi-2.1.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:58acb8ab8e295e6c5ea12f888cbb13cf21511ef2a3303a23f4325c29d17fe5c1", size = 222328, upload-time = "2026-08-03T21:20:22.118Z" }, + { url = "https://files.pythonhosted.org/packages/e9/02/4e7d553a7ac4b4238b38b3c1b80d486e9d4436f8d2acbf87a0997fe3f402/cffi-2.1.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:b0431303acaea1089ad4b3e9ce4e6518193def1118d4073ca848635ee4ea2e96", size = 221525, upload-time = "2026-08-03T21:20:25.758Z" }, + { url = "https://files.pythonhosted.org/packages/82/1d/a4aaf9babd75acb4d5f223bff71533bee748dd770a382619a798960ee9ba/cffi-2.1.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:64faea20f4e2613363a1a9b9c7dd73058f3ecd00133a511e72ad7c511658f527", size = 225053, upload-time = "2026-08-03T21:20:26.985Z" }, + { url = "https://files.pythonhosted.org/packages/81/10/5dc0e7bdd18e22107054288283380fc97a06ae3f1656a106908d666a3c88/cffi-2.1.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:5c58fe613dc5e5336357eff555824a314d8e43282600435c8d1cb6a7a2fedd13", size = 223213, upload-time = "2026-08-03T21:20:28.277Z" }, + { url = "https://files.pythonhosted.org/packages/2a/9c/92934c3bea9f785b23eba304538c0b4d37a2a96d2431eb3a1bc87a11aa19/cffi-2.1.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:49cbc70e6542d4ccccb936558d1064a8012541e78f821f955cff24e357776c94", size = 223864, upload-time = "2026-08-03T21:20:32.571Z" }, + { url = "https://files.pythonhosted.org/packages/9a/95/eff5f0cee78d2eabc7eebffec40d3fc1876b5f3c95582e018bb4b99601f2/cffi-2.1.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:51b31d1c98274844cfd7838ce00bfc27c7423a4dc00fc0772fc3331c2cc90676", size = 223803, upload-time = "2026-08-03T21:20:36.564Z" }, + { url = "https://files.pythonhosted.org/packages/fa/01/579d39fb8bef00a335a23d83757b44feb24cd6345a2c451b64cb67b9c362/cffi-2.1.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:5e7cecbaadb83884793e05828cee59b210b24583b9c7425d0ba6a754fe22eb4e", size = 226763, upload-time = "2026-08-03T21:20:37.816Z" }, + { url = "https://files.pythonhosted.org/packages/8d/b0/0b44f47c60b01b57b6e2bbd92343f13a85a1d93bc46ccf6e47e244acd99c/cffi-2.1.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:25792eac27877609e7bb06d42ff88278a6624fff2ba9bbb523c09616b117e80f", size = 225688, upload-time = "2026-08-03T21:20:38.959Z" }, + { url = "https://files.pythonhosted.org/packages/c1/8f/9ebe220eab48a093d1a5a5e339ab0dc7316eef3bb04d63c42f0251b61f50/cffi-2.1.1-cp315-cp315-ios_13_0_arm64_iphoneos.whl", hash = "sha256:dddad92b554513a31f272570678ba307fb9f618f05e3d4a5eacafff9eae03e1d", size = 194043, upload-time = "2026-08-03T21:20:48.179Z" }, + { url = "https://files.pythonhosted.org/packages/ff/69/844bad3ece306c4782c2ecb93597035b6690d48704b803914c199da1e8b3/cffi-2.1.1-cp315-cp315-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:da0e573f9f97159390c89d9f1a9e41908b66d408cc5b58d08cf3847d844c531b", size = 196737, upload-time = "2026-08-03T21:20:49.457Z" }, + { url = "https://files.pythonhosted.org/packages/e2/31/9e1313b0a6e30e91b3b3d3fff51ae99c857c07738e3afcce1f7334e1b7ab/cffi-2.1.1-cp315-cp315-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:507a24c282e0f42f8ed737cf048572cbf580468da5555764a8331735e9c736b6", size = 222271, upload-time = "2026-08-03T21:20:53.462Z" }, + { url = "https://files.pythonhosted.org/packages/44/16/29e6d01b388bef055ecd6ca8244b3f4d336bd09e92d5d892187b9601084e/cffi-2.1.1-cp315-cp315-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:aeae0e330c9f6acd681f647d46cefd30c29f93e3392882e792e82080c9691399", size = 221630, upload-time = "2026-08-03T21:20:57.336Z" }, + { url = "https://files.pythonhosted.org/packages/a4/18/fa7f1f6857d5eb88a4ca99ffcbfb7c387a287ccc154c64a73e86314745d7/cffi-2.1.1-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:42a494cee34437f05546455144f2b5d9ac09b1face62bcfce597d2e521066688", size = 225134, upload-time = "2026-08-03T21:20:58.675Z" }, + { url = "https://files.pythonhosted.org/packages/e0/9f/e8e3dfa04a1b4c241f8c91faacad872b4d4efd051d49764ad4e2fd4b9fea/cffi-2.1.1-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:cc572dace3f60ef98d7b12ff411d20f5362feb31a0439eab0085bbfd349982d7", size = 223197, upload-time = "2026-08-03T21:20:59.968Z" }, + { url = "https://files.pythonhosted.org/packages/53/b2/6187f46f2912276a3ae284076109cc5c8680482f11f766ccf26db4a86427/cffi-2.1.1-cp315-cp315t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:937c0052c05a31ca1daf18de3158eed4dbfcb9cc107adbea227728d647be701e", size = 223779, upload-time = "2026-08-03T21:21:03.553Z" }, + { url = "https://files.pythonhosted.org/packages/52/86/2976131c639aead931c5bee5aba67e4b09fbeb8018b6f282f70803f923a7/cffi-2.1.1-cp315-cp315t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:363e05fa78e15116c3c32c210ee36884fd6b9afa6d440e47112c3bd511d64cb6", size = 223835, upload-time = "2026-08-03T21:21:07.539Z" }, + { url = "https://files.pythonhosted.org/packages/ac/0c/33a7aeab2f9c76918c52e084beb39c570db3588133412929e8ec06fab90b/cffi-2.1.1-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:770de9db11e84213beec501cfcaa013b019820ca881e03344dea5844f7876d94", size = 226705, upload-time = "2026-08-03T21:21:08.774Z" }, + { url = "https://files.pythonhosted.org/packages/e3/26/2cde30fdde421130bfc18f70395731a6e6b2053c6a1978a5258ff04e72fa/cffi-2.1.1-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:7da0c5eff80f0197f3b3d1232ec5a682a9325f4ae9016a78f5f5ca35f9ced1f5", size = 225539, upload-time = "2026-08-03T21:21:09.911Z" }, +] + +[[package]] +name = "cfgv" +version = "3.5.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/4e/b5/721b8799b04bf9afe054a3899c6cf4e880fcf8563cc71c15610242490a0c/cfgv-3.5.0.tar.gz", hash = "sha256:d5b1034354820651caa73ede66a6294d6e95c1b00acc5e9b098e917404669132", size = 7334, upload-time = "2025-11-19T20:55:51.612Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/db/3c/33bac158f8ab7f89b2e59426d5fe2e4f63f7ed25df84c036890172b412b5/cfgv-3.5.0-py2.py3-none-any.whl", hash = "sha256:a8dc6b26ad22ff227d2634a65cb388215ce6cc96bbcc5cfde7641ae87e8dacc0", size = 7445, upload-time = "2025-11-19T20:55:50.744Z" }, +] + +[[package]] +name = "charset-normalizer" +version = "3.5.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/33/1c/f41d4e74c28ab327ff3acd36053f7ea506c55872d7a90b0fa71aa3ab0c89/charset_normalizer-3.5.2.tar.gz", hash = "sha256:39de2a259fc954455c57274dc94c79d5842774e1247a016aff30bc0efed0f4ef", size = 172659, upload-time = "2026-09-30T04:39:23.398Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/22/67/6a0b94a7960d5e1b5eacd2fb529f3fccc47db4644f7f0a7cfdcfc3be578a/charset_normalizer-3.5.2-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:3d21b8b13c7592db2ac5e544a6d83187b995257472b0c9e8351b6d507ae37ed6", size = 370642, upload-time = "2026-09-30T04:35:06.91Z" }, + { url = "https://files.pythonhosted.org/packages/fb/94/01009e13b94041599004edf32e56e382c24e570f60f79bab8efe45cfe1eb/charset_normalizer-3.5.2-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d760fe2a4d7c3b226cb9026d6a842868d52a7901bd98420e1baf14e80da85cf5", size = 259280, upload-time = "2026-09-30T04:35:08.448Z" }, + { url = "https://files.pythonhosted.org/packages/66/85/3b5358f60a13210f0b67d3755c168ef758701b021e655d88d4da28554467/charset_normalizer-3.5.2-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:c9790464842f85f437dbbb54417eda1e0e6bfc52dd8d22d6fd1c994b73b2dc74", size = 245335, upload-time = "2026-09-30T04:35:10.104Z" }, + { url = "https://files.pythonhosted.org/packages/74/75/77c1c479b09ecd751d1e767b251ea5c14d4d50ff757bf404afab2692f600/charset_normalizer-3.5.2-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:4685902cf26edf013ed7a3da0f426ebba7a00ebb9541386d835afbf002c11cab", size = 291707, upload-time = "2026-09-30T04:35:11.575Z" }, + { url = "https://files.pythonhosted.org/packages/0b/0d/363f78cacb70f58f15f4b083961bbd9d292f335d3f5c66fc4f1cfe69cb90/charset_normalizer-3.5.2-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:4495c5002a7b28557e7e222e77e0b661183e432b7d6d2e788101e3f240e05b8c", size = 286747, upload-time = "2026-09-30T04:35:13.022Z" }, + { url = "https://files.pythonhosted.org/packages/e4/ed/cf505d3011ffceb12c2067a7a5d3cfe92b875d4d44bb0ff0d69375e2c184/charset_normalizer-3.5.2-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:211d5a3eb6af8f513b8d4ca19a8c1b7accab1b5f0d3175f9826b03c1a920dc1f", size = 269972, upload-time = "2026-09-30T04:35:14.606Z" }, + { url = "https://files.pythonhosted.org/packages/15/d8/f0a93a431d170e7ca681d4f6650fee3de934d18560e474e7267eb4b0f987/charset_normalizer-3.5.2-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:ef4fcbf3327382cd4c9f540babd61248208af7b93eec4de397b4d5f58a09e288", size = 269339, upload-time = "2026-09-30T04:35:16.087Z" }, + { url = "https://files.pythonhosted.org/packages/86/bd/9b2bd1c5b7af02462c9752d33994834ff972a96b4c483eefde9e594488e2/charset_normalizer-3.5.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:bd16aabe4a02a297c23417aa17ac6299dbd8c49f673bcd645b4929b11f5a4400", size = 261683, upload-time = "2026-09-30T04:35:17.488Z" }, + { url = "https://files.pythonhosted.org/packages/76/a5/cac540ab0fd61f3fec88ad3dbb64509e71424593d73cfdfff5ab3e4db279/charset_normalizer-3.5.2-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:fb9e68df06293761f9fe66ade60a9bc6d0f5e42b8acf2939a9158af86ab0e5bd", size = 248143, upload-time = "2026-09-30T04:35:18.849Z" }, + { url = "https://files.pythonhosted.org/packages/71/7a/ff467301deef2089fad87f72df9e000a26a78fec7acbb18e1999371b8369/charset_normalizer-3.5.2-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:59f63901b0031c3136cf64704dcb21de0bbae62ce2c9529bc39d27665463de37", size = 292358, upload-time = "2026-09-30T04:35:20.326Z" }, + { url = "https://files.pythonhosted.org/packages/ad/77/22d7e785d1e210afc2e2f58600dd1799d17a35665faf84383f002826c5f8/charset_normalizer-3.5.2-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:304d5463e65a35d7bb0850550e0780395395f6fcf452f04db7d5ca7cecc425ac", size = 268766, upload-time = "2026-09-30T04:35:21.72Z" }, + { url = "https://files.pythonhosted.org/packages/ae/91/e8e946267f1c2d9e2bd651726e2fbd2addf02c4d36cea5069e32ca9d7bb5/charset_normalizer-3.5.2-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:9cf9b1a857e25c4baceeb3624e92a56df3668f398c4acba74e174d81fb4d1d3a", size = 287432, upload-time = "2026-09-30T04:35:23.273Z" }, + { url = "https://files.pythonhosted.org/packages/4e/88/7561d8a88d555e7df6623abe7c0070b4baf47549b9408783a2ae0a1a6cf7/charset_normalizer-3.5.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:114e4d0c92d618409ed82a99e22b5c5e768fe995f2973f78265f4524f49d4640", size = 272470, upload-time = "2026-09-30T04:35:24.655Z" }, + { url = "https://files.pythonhosted.org/packages/35/7e/578c702301ec036f01455f30744a08d2b42f6ab35b9b2d4bf8cae0ef2a80/charset_normalizer-3.5.2-cp311-cp311-win32.whl", hash = "sha256:2625388c6c754520c37abaf3b41eb34d1cc4a373f457898f08606c8e362b891d", size = 186688, upload-time = "2026-09-30T04:35:26.225Z" }, + { url = "https://files.pythonhosted.org/packages/e8/fc/fdf8cf52ff21cd5bf158f20978991cf985325842f74283eb6df26c8a39d8/charset_normalizer-3.5.2-cp311-cp311-win_amd64.whl", hash = "sha256:87e50a3e7cb90af586b6c5faf23e302a970415ac73bd7bd90a515a04b427ef96", size = 214932, upload-time = "2026-09-30T04:35:27.796Z" }, + { url = "https://files.pythonhosted.org/packages/97/66/3e45a506d8110b632541faf9a9470185aa9878f1ed44020f31346c1c5e5b/charset_normalizer-3.5.2-cp311-cp311-win_arm64.whl", hash = "sha256:254eb48b9fa5ee9898a3c445825a1f340fe53712a098904b39b0bddba8ea3cb1", size = 202828, upload-time = "2026-09-30T04:35:29.259Z" }, + { url = "https://files.pythonhosted.org/packages/e7/c8/693809898870237d82785a03f3b2b58fe4c9f14669f84a7d4e623c92a59e/charset_normalizer-3.5.2-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:ed2a239c0ea213acc1908150a3037257083c7c083128f1a4cec2ec4b97dca491", size = 367780, upload-time = "2026-09-30T04:35:30.888Z" }, + { url = "https://files.pythonhosted.org/packages/c9/87/2fea8c13dc24b3ca9c6f803a5b2dfdeae73eb4f9e12c7885ed908ff0433c/charset_normalizer-3.5.2-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b91363207bd9dc966a691e959bb47f64b30f7ac4b072be9968b366982f7db77c", size = 246730, upload-time = "2026-09-30T04:35:32.286Z" }, + { url = "https://files.pythonhosted.org/packages/a8/9e/09efac30b937722f46d3110ba30b875b24b2e3a266ed746cc4e376a94d80/charset_normalizer-3.5.2-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:38a873987f3be698494da8b2e3085e29da02da7b633dce73e79c699a113d7bf0", size = 237707, upload-time = "2026-09-30T04:35:33.709Z" }, + { url = "https://files.pythonhosted.org/packages/9e/18/70d76670b13686237863a379928d60bd10e021f17d243ab3d7014c4a5f4e/charset_normalizer-3.5.2-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:355ad8011081dec5412240c087a9a0c9d4d5039f3ed11a3f13e18c2b29b56c51", size = 273050, upload-time = "2026-09-30T04:35:35.138Z" }, + { url = "https://files.pythonhosted.org/packages/54/e2/77a8b09d5adc013ed07b95b01b8b8fa5441c4e810e83ee7e4aae2fa4d91a/charset_normalizer-3.5.2-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:ee21e28f0430bd6dc9086c6e525d5e818a44a5ad19720c8a0ef766792f3eb5e5", size = 270345, upload-time = "2026-09-30T04:35:36.502Z" }, + { url = "https://files.pythonhosted.org/packages/7f/c5/38806a25ab5e65fc178f39affeda20858efafede2fce1ffc2556cfc9fe73/charset_normalizer-3.5.2-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:3d31298449090ab8d47b7b1b2a555ff73cac7ed438a08b7ac160980c7ebed649", size = 257601, upload-time = "2026-09-30T04:35:37.919Z" }, + { url = "https://files.pythonhosted.org/packages/ae/8d/213565184708fdb263ae55e2c04ee1ff748129dd65d48ed0e3502da9c85a/charset_normalizer-3.5.2-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:5cde776b7cc66e4f6c99612cea4aa7269aa65863f7a15841b2c264f103822f4e", size = 252222, upload-time = "2026-09-30T04:35:39.544Z" }, + { url = "https://files.pythonhosted.org/packages/7e/24/76d2cefc25472531e4c5c7dfff68865eb1c39b78482f0fdc15b46f047830/charset_normalizer-3.5.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:ae4f5fea5b8b8ccff88238cc8569303e5ee95efae67fa62922a311397a71f346", size = 248482, upload-time = "2026-09-30T04:35:41.088Z" }, + { url = "https://files.pythonhosted.org/packages/7d/dc/65a801b66ab4c197e22c433ab25e7ac24324ac6f45a2269aca42cce309bf/charset_normalizer-3.5.2-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:f7d486c83842422badd511868fd8a9a20e9407ace71564b6af47ce7e60a336c1", size = 241206, upload-time = "2026-09-30T04:35:42.59Z" }, + { url = "https://files.pythonhosted.org/packages/a7/95/ca9b5eabde673002c6f1e7ada1b223916fe18f6d661da7aabd4d643718f1/charset_normalizer-3.5.2-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:11a4d68a6ecda3292cb1e50239e111543ba5d709bb62a6b4ea1afcfa729d8875", size = 273190, upload-time = "2026-09-30T04:35:44.347Z" }, + { url = "https://files.pythonhosted.org/packages/2d/8b/803b4d2a3f6e1740f63f1e87b04d14b42f3d4fdfe6ed7d4db2d34102b14f/charset_normalizer-3.5.2-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:d6734d2ef8a50fbf8445c139477da401f50d62a0606bf00e20ec6d87773fefb1", size = 253527, upload-time = "2026-09-30T04:35:45.915Z" }, + { url = "https://files.pythonhosted.org/packages/a9/55/93c0e5dbd085ae0471346026abbe7e0db9ea2d6fea74e51f0b5a46f233a7/charset_normalizer-3.5.2-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:a815775b6c38d4e0ff7bcffbeba67feded90202bb6a226b8dd35f1c855217413", size = 271285, upload-time = "2026-09-30T04:35:47.49Z" }, + { url = "https://files.pythonhosted.org/packages/95/69/0dbd0e0b9b16cfa816cdfcb3e2e3854a1f680dc07fb1245ea125e7448060/charset_normalizer-3.5.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:23851fb4e1b85ed3f6c2a27b777cdfe2e19fb5b38429a8faf38c7542b7665869", size = 260010, upload-time = "2026-09-30T04:35:48.996Z" }, + { url = "https://files.pythonhosted.org/packages/58/9d/e7b88e7b1bf403590c3b573277b5e1e488c68c7a6fbacca310a2c324e90c/charset_normalizer-3.5.2-cp312-cp312-win32.whl", hash = "sha256:db19d07e2e0129e974a0e65d0064fc222a446cd5122c2fd4184d2af9fc734a9e", size = 184125, upload-time = "2026-09-30T04:35:50.777Z" }, + { url = "https://files.pythonhosted.org/packages/eb/e6/e6e083884cbcfd49c64865af05027fe7011be7b2d9179524f099a1b611f3/charset_normalizer-3.5.2-cp312-cp312-win_amd64.whl", hash = "sha256:780fbe7cab297b81dad9fb8dc5eb003c0468ffb0d9e5f65068c53a34661a96bc", size = 207486, upload-time = "2026-09-30T04:35:52.194Z" }, + { url = "https://files.pythonhosted.org/packages/c4/e3/017aea0911ada7405a825c7d937eb3a13009664e2f5b38e8c4bbf2abf894/charset_normalizer-3.5.2-cp312-cp312-win_arm64.whl", hash = "sha256:e2af3aad578aa6bd1384bcf4750fc285e5a9de53f40b7d41e5a0bf748edeb2b3", size = 196734, upload-time = "2026-09-30T04:35:53.636Z" }, + { url = "https://files.pythonhosted.org/packages/c5/34/68292d68512768591aaff07c59bb53ee31341c87759433a859c4641a50c2/charset_normalizer-3.5.2-cp313-cp313-android_24_arm64_v8a.whl", hash = "sha256:ed905975ab14056a2e5eb1c376cb2e1ebc5396baf84163939c518556fccde9f5", size = 225946, upload-time = "2026-09-30T04:35:55.313Z" }, + { url = "https://files.pythonhosted.org/packages/e3/80/bee0b01b90ccd5322ae1d0abb33fab1bd95b7c2eadaf02aeccf22e04ee83/charset_normalizer-3.5.2-cp313-cp313-android_24_x86_64.whl", hash = "sha256:a66c3bc5ab1f0ff2164fc9965ddd611ff0802173f4b9d24554c563f6ab7e1d6e", size = 238619, upload-time = "2026-09-30T04:35:56.863Z" }, + { url = "https://files.pythonhosted.org/packages/78/6e/60ce52a85a7fd631ae8482ae6d74521014ca2f255892679484dc04d7ef56/charset_normalizer-3.5.2-cp313-cp313-ios_13_0_arm64_iphoneos.whl", hash = "sha256:d2374b62878abb00cd8309b32af6c0b715cd02dec0ca74ef12e5069bdc64144a", size = 206701, upload-time = "2026-09-30T04:35:58.639Z" }, + { url = "https://files.pythonhosted.org/packages/36/8c/71aafad23f971afc84c2b295bc0c560739ce1dac558aad9fec22e39f3639/charset_normalizer-3.5.2-cp313-cp313-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:d376bbd28b3a8999db1a103b3b388aee6f1ddeb3e51bc2172993efdcd86e064d", size = 210506, upload-time = "2026-09-30T04:36:00.147Z" }, + { url = "https://files.pythonhosted.org/packages/91/da/3c5a7798c046df7d2d68ad653cf5b6c5a8bfee225055a843c6f2f42aac1a/charset_normalizer-3.5.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:6045373d5a89a5ec71afde535db987ca28e76dfa276c2d4c818265b375d4b055", size = 366626, upload-time = "2026-09-30T04:36:01.77Z" }, + { url = "https://files.pythonhosted.org/packages/e1/16/710ac3de2ee354e2bd1a9c94efe45a2d27b5c6ad39b2d6a905be2c094b6c/charset_normalizer-3.5.2-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:849df64e889b2e17230d58410a03dba311a65b163508fd33679b2b737d4b7858", size = 244624, upload-time = "2026-09-30T04:36:03.389Z" }, + { url = "https://files.pythonhosted.org/packages/d6/39/45c7439f5b63d24f7d5b2a1d760f34af7628782d7144b4cc8ded45c2d4bc/charset_normalizer-3.5.2-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:15c44f7edfd477b06f517a5cc317fc1707edb9de2c865f43d4b6513907473234", size = 235731, upload-time = "2026-09-30T04:36:04.987Z" }, + { url = "https://files.pythonhosted.org/packages/4d/34/38f3154785ce92e9f56eb226f4d35bdfae6b008480dd055f58837a89c810/charset_normalizer-3.5.2-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a89012d6d5476ee112d20d998570ed58df2260a852afb1758809cd6900411d21", size = 270352, upload-time = "2026-09-30T04:36:06.412Z" }, + { url = "https://files.pythonhosted.org/packages/04/f3/859f74e7babc977705026b30593b3be04049632a522fb7000f83c033d747/charset_normalizer-3.5.2-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:0c951d5e6dd9c2ff60609476752bee49da4206adde960ebc247766937f72e718", size = 267393, upload-time = "2026-09-30T04:36:07.865Z" }, + { url = "https://files.pythonhosted.org/packages/4b/85/41d27f234b82e47c167a5f6c0f62501dc0c640585ff4aba79e08a390336a/charset_normalizer-3.5.2-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7218e8f32b0956cfcd048fd42d9d5779809745ca1d86113ca56f66e7ae1549c4", size = 254660, upload-time = "2026-09-30T04:36:09.248Z" }, + { url = "https://files.pythonhosted.org/packages/58/ca/5d1a997587febe5b26d8daffe363b5c1a091cece19828eec6502fd09c5ef/charset_normalizer-3.5.2-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:a19a731138fc27d5682277d3b9df22855cea1239bce7fcec5f78f42ef2d1f3c3", size = 249996, upload-time = "2026-09-30T04:36:10.73Z" }, + { url = "https://files.pythonhosted.org/packages/b3/1f/d1e78246f7ed60c8c8d606b4ac27f66ce49cc3e95f24893ccbeba9f77302/charset_normalizer-3.5.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:62603db9a7caa0802eaa28c1c46fecd7b3a263a774069c24c3c28c302448721c", size = 247028, upload-time = "2026-09-30T04:36:12.294Z" }, + { url = "https://files.pythonhosted.org/packages/8e/37/eba316edd4f0c4d3a5d945924c4eeeae59abac4056aa815d8a4268f863a2/charset_normalizer-3.5.2-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:b6856554c4f44d79fc2307d5768854310a8f0096e501c75637542c82292b0429", size = 240562, upload-time = "2026-09-30T04:36:13.887Z" }, + { url = "https://files.pythonhosted.org/packages/c8/8e/aaa037d40ca9ef045977f1a661048b1aa33f223adfce3452fe9be9f79d14/charset_normalizer-3.5.2-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:1bc0baf5ef96b6ede57d47f4b8fe4d9d84019c3bfcbeb20a41edc6a6ee341f1f", size = 271699, upload-time = "2026-09-30T04:36:15.41Z" }, + { url = "https://files.pythonhosted.org/packages/26/19/1c1c9f75974adf523b87f34b8a2adc5a435cd65916812bcbd0dfa45f9a29/charset_normalizer-3.5.2-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:56bc200a365efb37383b7852e4cc5898d3b2da5987289b543956cf8cad71018a", size = 252030, upload-time = "2026-09-30T04:36:16.839Z" }, + { url = "https://files.pythonhosted.org/packages/bc/90/0660ef18e18df0a4d2a1a0edff7dfbba42d4e50ef2425557a5bb7051f77b/charset_normalizer-3.5.2-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:2c9ad19a6cfcd5ea5c0d41161d22f9df1dcc277e9bef2751391334546a314c00", size = 268565, upload-time = "2026-09-30T04:36:18.468Z" }, + { url = "https://files.pythonhosted.org/packages/79/ba/57adc269824e8658f1a0f97a9e514c247445a9632b3419b97e0ba37f16dc/charset_normalizer-3.5.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:e243bd13217235fc7290c621941c3f5cc8b66e4872495be821d7436ba2fb838d", size = 257627, upload-time = "2026-09-30T04:36:19.938Z" }, + { url = "https://files.pythonhosted.org/packages/9a/85/33abd4315c052d3d4f54c92b1ee49bfbc0dc7115a981e462a793b6d2ab87/charset_normalizer-3.5.2-cp313-cp313-pyemscripten_2025_0_wasm32.whl", hash = "sha256:a090bb2c68df85450502e3e20d665e3a5af9c65a84d6508ed477badd49166fd3", size = 143407, upload-time = "2026-09-30T04:36:21.376Z" }, + { url = "https://files.pythonhosted.org/packages/4f/de/6435e18d1aaa5d910b896d551411c96af1f42a0c56c29afc2016c61ccc2e/charset_normalizer-3.5.2-cp313-cp313-win32.whl", hash = "sha256:2b7b3bbfb4fe8ef40600792d762fbaa9057559f9d3fad209525b7a22b99e91fd", size = 183207, upload-time = "2026-09-30T04:36:22.776Z" }, + { url = "https://files.pythonhosted.org/packages/9c/76/b8ec57f4e9ee3253541abf95e4a462c0175fe8032dcd070f1f2421240942/charset_normalizer-3.5.2-cp313-cp313-win_amd64.whl", hash = "sha256:78456a747de8dc58360ffa581f30a002baf5aa28cb262536545e91f113ed7639", size = 206489, upload-time = "2026-09-30T04:36:24.306Z" }, + { url = "https://files.pythonhosted.org/packages/3e/60/c647c6ae47480221e875ea5d743ff94946f7416e3c69415ab772928e8d32/charset_normalizer-3.5.2-cp313-cp313-win_arm64.whl", hash = "sha256:11912e4bb14baae7c5d8791aa55ba0a3a03ec6729073307b0f57270abaa713d3", size = 195501, upload-time = "2026-09-30T04:36:25.846Z" }, + { url = "https://files.pythonhosted.org/packages/58/ca/7aa91362a2f77ac8e9e28a9b902a74f7d0e11a851ef0d27a74308da8cd90/charset_normalizer-3.5.2-cp314-cp314-android_24_arm64_v8a.whl", hash = "sha256:1afb975bd5d68d5ce9f6b6d44fdf2f7e34b895a35e95708a7a91b20a3b51d187", size = 226010, upload-time = "2026-09-30T04:36:27.669Z" }, + { url = "https://files.pythonhosted.org/packages/a8/cf/ac8878d0322cf88a1aad4c7b147db32ca0bd806eb0060957b2e31486dbe6/charset_normalizer-3.5.2-cp314-cp314-android_24_x86_64.whl", hash = "sha256:bbbfc8e28816f19d7c0f1816664980c0a9875d01b27cdf8eedddb639d9e108ad", size = 239266, upload-time = "2026-09-30T04:36:29.434Z" }, + { url = "https://files.pythonhosted.org/packages/c9/6d/9a08d7e0b29b7208e2c6c01dc56c8e0520e7c7beadbbfb024b58fd69c8a5/charset_normalizer-3.5.2-cp314-cp314-ios_13_0_arm64_iphoneos.whl", hash = "sha256:7967d08cf06dee78443b874f98c98036f624f3a4e73e11f9f64f5be4d25393cf", size = 206783, upload-time = "2026-09-30T04:36:30.872Z" }, + { url = "https://files.pythonhosted.org/packages/82/44/b0aa350280e6ff5a5492d17cf10460dd39d5ee848f872f7ba2df10607f60/charset_normalizer-3.5.2-cp314-cp314-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:4c2b5031f63e331e3839b40aed2dd6f191e9c07edbde303e7876846ea1946995", size = 210449, upload-time = "2026-09-30T04:36:32.625Z" }, + { url = "https://files.pythonhosted.org/packages/7c/8a/40db9aa9f5907bb0e6f8b6d64064bf8852fb33d4b813ff9414911df7647c/charset_normalizer-3.5.2-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:fcff63213e8e6e47770541a4607175404f47cbb3ebea7b6058cc82d524a0e424", size = 367815, upload-time = "2026-09-30T04:36:34.197Z" }, + { url = "https://files.pythonhosted.org/packages/7f/72/9c5e7707b57c8ddfa9ddf7b0b1d009d7fbab9e9e887d5b721060f37e307d/charset_normalizer-3.5.2-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8d86d6fc60743dc916eb79e2eb1ec4818e21e427731543af40a3021851174a13", size = 247095, upload-time = "2026-09-30T04:36:35.803Z" }, + { url = "https://files.pythonhosted.org/packages/83/09/71e453691e927de4ddf792770cfaab3f49d494e222f66ea5e404bbd5e39c/charset_normalizer-3.5.2-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:7a881931aa470808df94a8c380eed2bbbc76cd9dc622310f99665658c821eb6d", size = 233942, upload-time = "2026-09-30T04:36:37.407Z" }, + { url = "https://files.pythonhosted.org/packages/9f/86/85c84e4da8b27dd409577d9437926ff581c5f9d3c66038dc68c1a526de51/charset_normalizer-3.5.2-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:8024d00c3faf3fc0c16e07a69f4405e8eac7cc0ab15f65fe6cf43827c4cf72b4", size = 273762, upload-time = "2026-09-30T04:36:38.904Z" }, + { url = "https://files.pythonhosted.org/packages/92/08/564955a4b5f2ccb410ab480bbe8c6a18063ff27f2d35458731c4a5335df9/charset_normalizer-3.5.2-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:4d48f2d08b9de5864e2c8744d4461b862fb149a18274abc8b698c45975573438", size = 269514, upload-time = "2026-09-30T04:36:40.469Z" }, + { url = "https://files.pythonhosted.org/packages/18/24/bad3ac4271589df29cf5ce2f5ae490518a5739358052bd0d61209e6fea54/charset_normalizer-3.5.2-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:34276fd796040bf0993ab33a369aa572e6979c7aab225a88893667ad8eac8f7a", size = 255056, upload-time = "2026-09-30T04:36:42.02Z" }, + { url = "https://files.pythonhosted.org/packages/d6/3e/350d89ad49916b86554d6f5f2d03ec1152148f87e5ff735106c6a03b1a36/charset_normalizer-3.5.2-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:0521c5665880b33d603717defa76c094048900010897909952397feb3039da56", size = 251311, upload-time = "2026-09-30T04:36:43.577Z" }, + { url = "https://files.pythonhosted.org/packages/56/5b/4970a2d154df502e133402906dd04e3ae7cada7b3011283c88d0479a2585/charset_normalizer-3.5.2-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:eff0ac9dbe711a4aee69bf04a83896aa9b85f19641264053a9f6d48573abb7dd", size = 250190, upload-time = "2026-09-30T04:36:45.185Z" }, + { url = "https://files.pythonhosted.org/packages/88/8c/f1a91bddc8fb47c2889e29ea7ea49a194eb0d9868675d786806519c00d76/charset_normalizer-3.5.2-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:1503bccbeb36d5527790c3930327704c39af22de3112f1b1666a9f3ce15ee204", size = 237098, upload-time = "2026-09-30T04:36:46.689Z" }, + { url = "https://files.pythonhosted.org/packages/24/0e/bb5dace3cc7e79068425386a6589c19b5a2ab5fefc2a46abea6919683332/charset_normalizer-3.5.2-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:52aa6992700996af31f375de0c6bacd402b0097fe40b53c426b9f51a90ebabc7", size = 274228, upload-time = "2026-09-30T04:36:48.31Z" }, + { url = "https://files.pythonhosted.org/packages/9d/79/b849ad523017ea9f5a45581bbebed91439e0cf42fd2860a6f64e358eb5a6/charset_normalizer-3.5.2-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:e09a3942ecbdee5cce73ea9d42da82b81b72ac1bf031ce069b93b5adf4eac8cd", size = 252401, upload-time = "2026-09-30T04:36:50.091Z" }, + { url = "https://files.pythonhosted.org/packages/89/8c/75469d690cf47200bce8f6cad7655724fc23148e147abfc5ce78b5f65863/charset_normalizer-3.5.2-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:c7c9ab723cde841fefb34efbad91e87f00a674b1fe1cd0784fde742bf2c154dc", size = 271846, upload-time = "2026-09-30T04:36:51.719Z" }, + { url = "https://files.pythonhosted.org/packages/26/cd/6d52d3c7437cdcf2e310ce9f28f282e733d4ef60ed19105d1819c356255f/charset_normalizer-3.5.2-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:ddc7dacc8ece3a182e7f15cb862d1fd616b46d076cb1ae9dd232b2c38b655874", size = 258151, upload-time = "2026-09-30T04:36:53.234Z" }, + { url = "https://files.pythonhosted.org/packages/f7/4c/070b38bdb5f49a70199fce923ec0726a49536a63ab262abbfcaaf351110b/charset_normalizer-3.5.2-cp314-cp314-pyemscripten_2026_0_wasm32.whl", hash = "sha256:ee43c17b173d46a3212baa6ead3ae258eeabdae48c263a01ccf0218c366dd655", size = 143570, upload-time = "2026-09-30T04:36:54.816Z" }, + { url = "https://files.pythonhosted.org/packages/81/84/9ebfc8ed6c8c4fcd8e726ff6bf220cc8deb3966e31dce9be8dd8aa017e64/charset_normalizer-3.5.2-cp314-cp314-win32.whl", hash = "sha256:4f87960d57feabfb618e4e0af6e7371645fa26a277860739d6e5d6e0012c92f0", size = 186412, upload-time = "2026-09-30T04:36:56.643Z" }, + { url = "https://files.pythonhosted.org/packages/d1/78/5ed86f743d4bc350db307e7636419a0a5ee1d91806d30c7f667bd5c80dae/charset_normalizer-3.5.2-cp314-cp314-win_amd64.whl", hash = "sha256:e4e81e09c1578b8df602e3db08b0b3ea0a6947ad612f52bf8dc5ea8d47691f0c", size = 210965, upload-time = "2026-09-30T04:36:58.205Z" }, + { url = "https://files.pythonhosted.org/packages/53/94/a3a7698e9b1a395e1eb99ccd9a324be9347973bff4e72db2a06496d7cd27/charset_normalizer-3.5.2-cp314-cp314-win_arm64.whl", hash = "sha256:80d02b6f04e92601a081dd97b23d3128033098bff5d35d392ddcc0476ea11253", size = 200406, upload-time = "2026-09-30T04:36:59.764Z" }, + { url = "https://files.pythonhosted.org/packages/c1/48/c5dd00d5ef7791f02666de250a5bb6071e29b7e133cf4b835800b6d3bc27/charset_normalizer-3.5.2-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:dca9ab98072a5a54ebacebdc45f53e645336b320c667410b061be1ca588ae709", size = 396871, upload-time = "2026-09-30T04:37:01.543Z" }, + { url = "https://files.pythonhosted.org/packages/12/c8/8379554b42e8368161d898476686947a0fdbd3e8865170d7909dcabfdee8/charset_normalizer-3.5.2-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f0aa869112ef88429ae17820d99c3dd9504c9e9c671d3c246f3d7442cb051084", size = 249711, upload-time = "2026-09-30T04:37:03.111Z" }, + { url = "https://files.pythonhosted.org/packages/4a/eb/2ddb1035d17320caa9f41682935123a9a250277b261c3efc86b2d2a21343/charset_normalizer-3.5.2-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:c0afc6800ba57ccc350374c5bd6150419915d95ce93cdbab2d783d75eaf30ecb", size = 231146, upload-time = "2026-09-30T04:37:04.721Z" }, + { url = "https://files.pythonhosted.org/packages/4a/24/2ecb4bde104322cd7859d6594fcfa74649f8d90b3221c9feecbef149875b/charset_normalizer-3.5.2-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:7dcd882da75ef9adf94903b1e3b9419e8aa8fb4c7396822b834b9ef7fb96954f", size = 271552, upload-time = "2026-09-30T04:37:06.295Z" }, + { url = "https://files.pythonhosted.org/packages/3f/98/9d5f6ebc3aee9fef5d30b4aff11fb2ab7a1222b4064f8ef2c7c87cde217a/charset_normalizer-3.5.2-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:2e06a3a98f916dd41d27f3105e02e7a40181c98c94b9158733d03a6f80506c09", size = 269810, upload-time = "2026-09-30T04:37:07.905Z" }, + { url = "https://files.pythonhosted.org/packages/09/e1/a3b06a10461b1b7628853c934c644e03bc28e42767116afb52f19a56519b/charset_normalizer-3.5.2-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6bd128f206a7752ae1f2ab6c61bf8a24ba28913a10df8b14c2637b973ff97a80", size = 259845, upload-time = "2026-09-30T04:37:09.554Z" }, + { url = "https://files.pythonhosted.org/packages/fd/d3/6f561f74a296cf27d61775a1dc665ad13f3bff6a798810ca05907f37a7c4/charset_normalizer-3.5.2-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:c8f3d67aeaf55f017982b73683f0e7342ba2f6635a78f69ce89ebb26aa411e5c", size = 252825, upload-time = "2026-09-30T04:37:11.274Z" }, + { url = "https://files.pythonhosted.org/packages/26/9f/69e13ca3b18f43e0eafcd34c04a45b732ae22a43b54a5fc9e119103356eb/charset_normalizer-3.5.2-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:fe9753dfee015c570d73df76f899f18444d41388bffcde097deba51c4fadbb9f", size = 252659, upload-time = "2026-09-30T04:37:12.941Z" }, + { url = "https://files.pythonhosted.org/packages/73/a9/ace29806a0dae18939919c76ba526472d83214afa101105fabff2cf30625/charset_normalizer-3.5.2-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:92888bb3187c5ba50500b00b3b310c9f2c651709d28036077680cb5255450a03", size = 238819, upload-time = "2026-09-30T04:37:14.659Z" }, + { url = "https://files.pythonhosted.org/packages/f8/c1/6116d52a2e3311ec80f21f5fb5e17b27405f10b9608af8f6e69516841a1b/charset_normalizer-3.5.2-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:d008d90a7f2471519aef0c90dfbe73b3e6e4d5e66ac48e19154c17e89e98b604", size = 272973, upload-time = "2026-09-30T04:37:16.346Z" }, + { url = "https://files.pythonhosted.org/packages/19/aa/9955c7e93bba10a9c7e8f7a5031b7ced66f3a1883a55c00712b8d5850ff3/charset_normalizer-3.5.2-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:31f3930700408d211f13378ccbe1c40845d8da54bd0681fac3a9b5aae81c7aa8", size = 253692, upload-time = "2026-09-30T04:37:18.212Z" }, + { url = "https://files.pythonhosted.org/packages/bb/33/2a6ae7fdc1b10cb581cef91addd8cdfc5f40d50abb5702309369d5834579/charset_normalizer-3.5.2-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:2a925889534b3748302dae5dead07cc13480de1dac3aea80a941b729b471ef93", size = 268757, upload-time = "2026-09-30T04:37:19.877Z" }, + { url = "https://files.pythonhosted.org/packages/a2/22/80992720a0282cd39bba1db35868e6b9c22f41281160143a836544bc1d8a/charset_normalizer-3.5.2-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:f5ec61164adcec446f8969a3358ec3f9b26bbda3b9213e5586d219afa8df2915", size = 262220, upload-time = "2026-09-30T04:37:21.583Z" }, + { url = "https://files.pythonhosted.org/packages/92/9f/181fd07e1bffea1d95cd80c84ac537354f50699c22cfc4d3c02b6fc16208/charset_normalizer-3.5.2-cp314-cp314t-win32.whl", hash = "sha256:598a11a2c7ebaa5334bf698bf29568c9c390abac6a154d8170fedecd1cea38c5", size = 197797, upload-time = "2026-09-30T04:37:23.235Z" }, + { url = "https://files.pythonhosted.org/packages/49/1c/25d8415ec1c4f2f41f1680435e4c87cfb378ff2f677d950946f2a45d0632/charset_normalizer-3.5.2-cp314-cp314t-win_amd64.whl", hash = "sha256:7fdde2c9fd9e3eca40631e024664cf2584272cc8f96308cbe5fdfc930f51d8bc", size = 222765, upload-time = "2026-09-30T04:37:24.891Z" }, + { url = "https://files.pythonhosted.org/packages/3e/b4/46b48f013dadfc0d0d33b375438e31bdf5a989dc68389c6bf627054d4df9/charset_normalizer-3.5.2-cp314-cp314t-win_arm64.whl", hash = "sha256:d1befeed746d247c81127bb14de9dc3d30edb6e5976d34f83f86ed262b1d9105", size = 210985, upload-time = "2026-09-30T04:37:26.634Z" }, + { url = "https://files.pythonhosted.org/packages/ca/e9/34e597dee616d0b8ee4b34d29399e85c2204ade174157a48505d42baa4ff/charset_normalizer-3.5.2-cp315-cp315-macosx_10_15_universal2.whl", hash = "sha256:87475fabc8d9996fd9c27debb395e642e8c838d78a00b6e932227a0e06b81e26", size = 367676, upload-time = "2026-09-30T04:37:28.329Z" }, + { url = "https://files.pythonhosted.org/packages/60/9f/a5d1c91c0263745e2cd344c5a4415d787c575501ab1d449f1148ac6b495d/charset_normalizer-3.5.2-cp315-cp315-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9409a8bf35cf78353942504b24a57de3d75b708997a1e4bd8db71ac8633ce364", size = 248414, upload-time = "2026-09-30T04:37:30.167Z" }, + { url = "https://files.pythonhosted.org/packages/26/79/e697f77464748a3ee3cf490c83d592459400d4898380d66c38366b03080c/charset_normalizer-3.5.2-cp315-cp315-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:498dc3188ca05a68231ac3fdbfc7f57eb67e1343c30e0fea17f8218c1599b253", size = 244775, upload-time = "2026-09-30T04:37:31.964Z" }, + { url = "https://files.pythonhosted.org/packages/ca/87/3d42a42e18ea066e2513936fd678a00696e77878b5ae04528976abdbcb83/charset_normalizer-3.5.2-cp315-cp315-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:e242bb1c5e76e97dfa9e7f209a71e93a01d7f19ffdd5cfbb2e2d55b4f08f8ab0", size = 273877, upload-time = "2026-09-30T04:37:33.661Z" }, + { url = "https://files.pythonhosted.org/packages/c3/76/8a28136f3938ba9836f84280ce0c4d61ed1cf15a036b2034900c62634162/charset_normalizer-3.5.2-cp315-cp315-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:def79fa35ef0cef8d2accec024f4fdc7ead3012ff02f5215c783f39f03ef8cfc", size = 269455, upload-time = "2026-09-30T04:37:35.573Z" }, + { url = "https://files.pythonhosted.org/packages/a0/a1/4fbf5d0f0f1b2a080474c1cf9a2f12c4c6531bb0e8ba591055e846d2b4e9/charset_normalizer-3.5.2-cp315-cp315-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:3df041de8887954562c9b261cba85ca0e9ded74048daf125f45edcfaa4832229", size = 257336, upload-time = "2026-09-30T04:37:37.397Z" }, + { url = "https://files.pythonhosted.org/packages/ba/a2/8b50aa320adb880ad579518e6f718f24944804b42a88b83d267d5d444125/charset_normalizer-3.5.2-cp315-cp315-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:04851f73ae72b8413dddadb16a49dfee95263553741fd42d546f7d66907e6be5", size = 257584, upload-time = "2026-09-30T04:37:39.522Z" }, + { url = "https://files.pythonhosted.org/packages/a5/57/50e3fed84e175f40349bd0da7a4fce94c87f0378f52d74f511d89e0bdc20/charset_normalizer-3.5.2-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:183b88127acdb4fabe59d951ab424faf1af7b63cdbb5f776186c1ea2ffcaed98", size = 251854, upload-time = "2026-09-30T04:37:41.23Z" }, + { url = "https://files.pythonhosted.org/packages/d6/54/f7fbb3493c9f49091213b9c2d6dd65800696f1ce1a3f196a4205f50417b1/charset_normalizer-3.5.2-cp315-cp315-musllinux_1_2_armv7l.whl", hash = "sha256:16fa0eccf81304b79c5cd87f9271c3b85dd9dd99245e4422ae9c0dd45e0f99d3", size = 248767, upload-time = "2026-09-30T04:37:42.883Z" }, + { url = "https://files.pythonhosted.org/packages/d9/37/b3a6385acc5a1e45b39ae9c90bfb9cf838a09b9dd37ef2740ab4c6b4a2eb/charset_normalizer-3.5.2-cp315-cp315-musllinux_1_2_ppc64le.whl", hash = "sha256:7441d755b7ab94f8d4eb3e43ec05482d760842fd263d003a99102d742cd835e2", size = 274479, upload-time = "2026-09-30T04:37:44.658Z" }, + { url = "https://files.pythonhosted.org/packages/89/44/809913e2cfd279e635a9294fdbbfb1b1dc62a8189d473d561f649fce98d8/charset_normalizer-3.5.2-cp315-cp315-musllinux_1_2_riscv64.whl", hash = "sha256:ca403d7e4798f525fdfc78e258820419cbbd0f0ecbab9de7840e3c017cf6b8cf", size = 258310, upload-time = "2026-09-30T04:37:46.529Z" }, + { url = "https://files.pythonhosted.org/packages/af/a2/f28400ab13359d91bd39179df8e149376b9bf36588e739a3a4f9de2b84b2/charset_normalizer-3.5.2-cp315-cp315-musllinux_1_2_s390x.whl", hash = "sha256:df29a0a7107f7011e77f4eebdddec4c7331e24d787a0b21a46d63bdf7445da95", size = 271100, upload-time = "2026-09-30T04:37:48.399Z" }, + { url = "https://files.pythonhosted.org/packages/e9/89/9bab37955edf0adb3b66f8a3a6617d9f2f487e0d56f295a6a286cb640aa6/charset_normalizer-3.5.2-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:f3c96f633825733f735c5a9cf21d21a257d8e1edf0b1cee0a064b9c424ca0f7d", size = 259936, upload-time = "2026-09-30T04:37:50.023Z" }, + { url = "https://files.pythonhosted.org/packages/23/b5/4459e08d45a679f903d50fea08bc52cfa728cca4d7bd02c757b5e5abda2e/charset_normalizer-3.5.2-cp315-cp315-win32.whl", hash = "sha256:281cb91036248400f4cc957495cccd44c275c2e0c5854f7e45ac5cf7dc193847", size = 186301, upload-time = "2026-09-30T04:37:51.722Z" }, + { url = "https://files.pythonhosted.org/packages/98/e8/55d5fd3935b4bce6da4fe0df61898e8c82653e317e677bd58aceb9c60f13/charset_normalizer-3.5.2-cp315-cp315-win_amd64.whl", hash = "sha256:89b53f3cda69831909888e0494f4fa0bcd3537e3e138dabeb620bd6ad946bae8", size = 210858, upload-time = "2026-09-30T04:37:53.427Z" }, + { url = "https://files.pythonhosted.org/packages/a9/5b/974423c2fd8e524c7a7f64318c1e02240ef954912fa2b4d70344107b9c68/charset_normalizer-3.5.2-cp315-cp315-win_arm64.whl", hash = "sha256:6be488a102b8cf28d0391d8c4ba7748938ae28b78ad901f8585520fca33ead1a", size = 200309, upload-time = "2026-09-30T04:37:55.015Z" }, + { url = "https://files.pythonhosted.org/packages/ee/f9/00ee0195db1013d8f7c416fd770fbeb560bb46eb2e36b054d05cb56f6cfa/charset_normalizer-3.5.2-cp315-cp315t-macosx_10_15_universal2.whl", hash = "sha256:915563965d418f986e7e145accc592eae9e1a1be3566ff98a05d7a9ec42a76e1", size = 395343, upload-time = "2026-09-30T04:37:56.743Z" }, + { url = "https://files.pythonhosted.org/packages/04/3a/c00b50e94c964cf934c7899cd47c97952fc11dad71cc5884b3c61795b09b/charset_normalizer-3.5.2-cp315-cp315t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:65cd72beeeca9d3aaea1201e5923859f308f952f9c71de93f06063c79f0f7a3b", size = 250114, upload-time = "2026-09-30T04:37:58.607Z" }, + { url = "https://files.pythonhosted.org/packages/50/27/d102dc880bbcffd0479ab64dfc1fb96777a854355a55e2bda72a71efadcb/charset_normalizer-3.5.2-cp315-cp315t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:b7fd005a73d9e657273b7a10dc71a9e03c8fb9ee6999798d6918ce095b81ac7f", size = 239997, upload-time = "2026-09-30T04:38:00.511Z" }, + { url = "https://files.pythonhosted.org/packages/a5/4a/bf7ef45794dd293fab5f98a9309817977fbb845b9998f171b8cc5d8437a3/charset_normalizer-3.5.2-cp315-cp315t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:e54da4baf05720032d527874d40b65fa4d7e5c6c6a43d0c3adbeffcaf275a2b3", size = 272313, upload-time = "2026-09-30T04:38:02.509Z" }, + { url = "https://files.pythonhosted.org/packages/e8/ee/008a2837737991474c5754bb3191010007663860979701990982a502cbaf/charset_normalizer-3.5.2-cp315-cp315t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:124fbf1a8ff966d87ae05bb8bd45a71f966055ed8bba320d0c7cf450bc5f4d0e", size = 269986, upload-time = "2026-09-30T04:38:04.435Z" }, + { url = "https://files.pythonhosted.org/packages/93/ad/bd74a283940dc910c5b14f8e4f80a248082bc9c0fcbe1f54530cb6d9cc5e/charset_normalizer-3.5.2-cp315-cp315t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:28b4f0d66fb834ff90f28209ac7bce77868c45d8c93e26f906709d9b7c2e1af9", size = 260202, upload-time = "2026-09-30T04:38:06.549Z" }, + { url = "https://files.pythonhosted.org/packages/8a/7b/ed341c66f69f688723501fac752be3d63c7159ca0d0d4174fc611e5710bb/charset_normalizer-3.5.2-cp315-cp315t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:58ca3755ee7ff7f59b57789ec9833c9de9ea275405cdd240eda1f193112e398a", size = 259083, upload-time = "2026-09-30T04:38:08.311Z" }, + { url = "https://files.pythonhosted.org/packages/cc/9d/e41588b777965e5031a43128a1e96173ebb35ac75fc53ec3b517e7c21cd4/charset_normalizer-3.5.2-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:443eae2bf318abeaf6f15d785138f71fd6de770e99a92158b8b814265e079115", size = 253081, upload-time = "2026-09-30T04:38:10.402Z" }, + { url = "https://files.pythonhosted.org/packages/81/35/b761eb6d8c1eb218b9b42b9b4d5ac902afdc399fb6dac6f9a9aac7bda589/charset_normalizer-3.5.2-cp315-cp315t-musllinux_1_2_armv7l.whl", hash = "sha256:58f361dcbab699cf8f42db3f47c8e7fd1036f138c23a5d08de9fde5f425a730c", size = 248712, upload-time = "2026-09-30T04:38:12.317Z" }, + { url = "https://files.pythonhosted.org/packages/4d/2c/147169a041b747759f37405c0a97157e8e92de967968373101ff14915cba/charset_normalizer-3.5.2-cp315-cp315t-musllinux_1_2_ppc64le.whl", hash = "sha256:1b4cbc7c3491ccb4aa17fcd8165649d01cf39f76de1696da8631b5f71b85401d", size = 274176, upload-time = "2026-09-30T04:38:14.138Z" }, + { url = "https://files.pythonhosted.org/packages/f0/2d/0ff8db0d373ba8538db686db11cd7e8912031490b9e4f383b41912e8d594/charset_normalizer-3.5.2-cp315-cp315t-musllinux_1_2_riscv64.whl", hash = "sha256:ba0b1d2620edf869789c3879223f52bf2afc5d31b3cb47cc57b3a12c05e2aa9d", size = 259413, upload-time = "2026-09-30T04:38:15.841Z" }, + { url = "https://files.pythonhosted.org/packages/8a/8e/b4a085fb47c9d3a7e43576a4784fdd8fe23f907514a972de8086edaf7a48/charset_normalizer-3.5.2-cp315-cp315t-musllinux_1_2_s390x.whl", hash = "sha256:5e2b6b57e9733d39f0c9fd3185efa6b8e29652c4cd8fe94180272cf6ed9a78c4", size = 269434, upload-time = "2026-09-30T04:38:17.626Z" }, + { url = "https://files.pythonhosted.org/packages/83/1c/d8d8d7322a7c3eecdf3237a4a419cf41d2eaad8e006ce7dfdd9d4c8fa2eb/charset_normalizer-3.5.2-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:51cf45226a9b588d0d2b4880c62d686934b63ab0bd79ca23ab0e9762eb27441b", size = 262716, upload-time = "2026-09-30T04:38:19.214Z" }, + { url = "https://files.pythonhosted.org/packages/a0/16/0e4c6ba9b44e97a2da150e52d331e8f9c968b21b358fbffa6c856cebcd89/charset_normalizer-3.5.2-cp315-cp315t-win32.whl", hash = "sha256:5fb29fb8cd1a46c27a1bf9613ad5ec2599310d46b4025d9556404a6b6a292800", size = 197159, upload-time = "2026-09-30T04:38:21.037Z" }, + { url = "https://files.pythonhosted.org/packages/be/33/e90bc2b1374f7f36ef106f56620de5a783907e19ca857efe2277e31cac3e/charset_normalizer-3.5.2-cp315-cp315t-win_amd64.whl", hash = "sha256:a192e2c40070d92c3ccf777e3a5c4ff515573cd2bb7ed0c537fdadbbec5bbf21", size = 221322, upload-time = "2026-09-30T04:38:22.886Z" }, + { url = "https://files.pythonhosted.org/packages/66/89/dfa6dcb08c200b7830ab56439e8c1890f2971d51aafbb3937894a2e7fcfc/charset_normalizer-3.5.2-cp315-cp315t-win_arm64.whl", hash = "sha256:749e97e1b32313717a565abbe321bc2190bc8b35f1a67e4cdbc7c56c8d8ffe58", size = 209192, upload-time = "2026-09-30T04:38:24.648Z" }, + { url = "https://files.pythonhosted.org/packages/8c/ab/176fbfd5b64939c55d652366aa5b9ef1d767af207a3aa6ebeb0d226c484d/charset_normalizer-3.5.2-cp37-abi3-macosx_10_9_universal2.whl", hash = "sha256:4275811936e2f06feff5e598fb42a1b7ae852da8e39605211892b56b81a34efd", size = 331815, upload-time = "2026-09-30T04:38:26.216Z" }, + { url = "https://files.pythonhosted.org/packages/7e/84/371eac6b30bdbcbf2d632a1a01809103459216fcaae61b8b8d922c1bfb8a/charset_normalizer-3.5.2-cp37-abi3-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:1c50fe28bbc2ced33386f298650d91218076c05420e6cbd790b913adc41659e7", size = 253276, upload-time = "2026-09-30T04:38:28.032Z" }, + { url = "https://files.pythonhosted.org/packages/43/6f/c4fbae58febff71709c51bc7e18fdfa55341dc382704740f9f0cbf03817b/charset_normalizer-3.5.2-cp37-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d19fbd981a488e22cd04883659ca6b08f50b5974f9fd7c95655ef6a043e5893f", size = 241239, upload-time = "2026-09-30T04:38:29.732Z" }, + { url = "https://files.pythonhosted.org/packages/61/71/458c3f42164a07d0c5210798e9e704b39e540a6793b05aba67f3a35243a9/charset_normalizer-3.5.2-cp37-abi3-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:0fed1d06615f022ee3b13caf5e8b180cfea32bb2c5aded8a9d44277afc040f93", size = 231121, upload-time = "2026-09-30T04:38:31.462Z" }, + { url = "https://files.pythonhosted.org/packages/09/54/ab9e89367076f6331bb6c65c4bf14a5361fa5191cb6561bf534f18504e1b/charset_normalizer-3.5.2-cp37-abi3-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:838dcc90063569a0448120554591a1d6c4a4ffe11babf048908793154ab86ade", size = 260350, upload-time = "2026-09-30T04:38:33.239Z" }, + { url = "https://files.pythonhosted.org/packages/7c/c1/061431ecc688d9d76602502cb57cc01e691e682c18f1beb45f9673b5bbd2/charset_normalizer-3.5.2-cp37-abi3-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:2ce45c6627b22c47e390bc91a41c3d13032192e699fa0bea96e9671b373d69b0", size = 255430, upload-time = "2026-09-30T04:38:34.865Z" }, + { url = "https://files.pythonhosted.org/packages/8d/1f/20c8949f0676f7ab811abdeb7f4d7f1cbc6e61ff20bef08b44edeb092bc8/charset_normalizer-3.5.2-cp37-abi3-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:0774bf9bf620249fee3e0b8b9fd3065de213be30f3aa94ce2494b3b638949e26", size = 250612, upload-time = "2026-09-30T04:38:36.649Z" }, + { url = "https://files.pythonhosted.org/packages/2b/9e/46f2fa4c431fc98c4ae76a8cb5bdca54e0341e3cfc3fcfd8e82740250818/charset_normalizer-3.5.2-cp37-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:1db38f4c5496827c1a501846d64d14c3b80c7e6714e406cd7dc36a9899fa1011", size = 242083, upload-time = "2026-09-30T04:38:38.26Z" }, + { url = "https://files.pythonhosted.org/packages/bd/39/559be29a0c0f086e0bba6922babd38916cc5e0b58ced4de13ee01ea05508/charset_normalizer-3.5.2-cp37-abi3-musllinux_1_2_armv7l.whl", hash = "sha256:304d8e4d493af723536393eee0c689eb7813f4a474c8b479dee63f1fdd98f621", size = 232738, upload-time = "2026-09-30T04:38:39.81Z" }, + { url = "https://files.pythonhosted.org/packages/ff/6c/387b0e4f756a282831c1d9fc6aeb6c51ca4507ca202767c8de15ce9b12e2/charset_normalizer-3.5.2-cp37-abi3-musllinux_1_2_ppc64le.whl", hash = "sha256:9b7f416ff0978e2f2249330527f0ad6fa02f4932e6199692d3b52da2048c19e4", size = 260703, upload-time = "2026-09-30T04:38:41.346Z" }, + { url = "https://files.pythonhosted.org/packages/96/92/1fdf015f09ef449f50d3ac4b67c90887c9c318b727daa95cc4f866e6521d/charset_normalizer-3.5.2-cp37-abi3-musllinux_1_2_riscv64.whl", hash = "sha256:01077390b03f7988f11d700a2194e69b119741a86b1a638b1db88891e3eced8e", size = 247622, upload-time = "2026-09-30T04:38:42.937Z" }, + { url = "https://files.pythonhosted.org/packages/dc/3c/8e7b8a5671ad5d433669fb2a76f1a0164df2d9b1718b0206bc2a16d840cc/charset_normalizer-3.5.2-cp37-abi3-musllinux_1_2_s390x.whl", hash = "sha256:7e841fb9010836c992c9f12fcbd43a831de93a5f726fc1ccd8ca1d0268c5014c", size = 257500, upload-time = "2026-09-30T04:38:44.604Z" }, + { url = "https://files.pythonhosted.org/packages/b4/f0/45b579df5cabc1d5d53ea1cc35e8437d3ca768c0acccc7041517cb6fbb32/charset_normalizer-3.5.2-cp37-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:9cae88599c7219005d879f98e5ed53341e9a122af585e1091200358a3003d2a0", size = 255100, upload-time = "2026-09-30T04:38:46.289Z" }, + { url = "https://files.pythonhosted.org/packages/31/68/fdec18a343f5fb3f310588dd478b09ac4799e0b187dbade3a8cd776f03ef/charset_normalizer-3.5.2-cp37-abi3-win32.whl", hash = "sha256:01b0c0d2262a9e28e8484a278c7e1b5d650e3ac8cf2683d2967e25899f208bdf", size = 174499, upload-time = "2026-09-30T04:38:47.999Z" }, + { url = "https://files.pythonhosted.org/packages/9d/8a/b618149cc5207943a0242068d7a27897f56a62947b5a039085f2a22029f8/charset_normalizer-3.5.2-cp37-abi3-win_amd64.whl", hash = "sha256:9f56f72050826f63dcee7a7f55b0a77168cb3bfc553fd405e7f8f9ece75a4036", size = 200092, upload-time = "2026-09-30T04:38:49.707Z" }, + { url = "https://files.pythonhosted.org/packages/03/cf/4c66866fa9e2b1c78e3c911516d1de497a677b7ac60f1eceda74ce777ca3/charset_normalizer-3.5.2-cp37-abi3-win_arm64.whl", hash = "sha256:40ab6bffa02ae10a0581e6c198be7d2d8ca5c2a0c64e4ed3465d766df457573e", size = 294363, upload-time = "2026-09-30T04:38:51.312Z" }, + { url = "https://files.pythonhosted.org/packages/fc/ad/d07d7862a62ffa6d79d68074d14823243dd235a77c45262acbf6adeb28bf/charset_normalizer-3.5.2-py3-none-any.whl", hash = "sha256:b6b751274acb69d77b3323d6b7dbaa3c7fdfc1eb829b7eb61d262f32e1af9685", size = 68872, upload-time = "2026-09-30T04:39:21.828Z" }, +] + +[[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 = "coverage" +version = "7.17.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/02/9b/639ff6f5b3158999fab6f03cb7597526ad57e15cad0c6cfa9b64bac874dc/coverage-7.17.1.tar.gz", hash = "sha256:5c5c77f95a0e83e6b79eff948d251c9911cfd61d67f5059159fc25b7bc4aec27", size = 995565, upload-time = "2026-11-03T12:38:47.608Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f8/28/bc914aa69f2dd27cfcebedc62acf472fca357389ba80295a8fa693d6ea59/coverage-7.17.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:e7429e44cf754fec4baf895307d7b3b906140df82f5c8637777e9cf4227afd87", size = 227529, upload-time = "2026-11-03T12:36:03.283Z" }, + { url = "https://files.pythonhosted.org/packages/97/46/60f46d3219278e53455a4fdb4b755e7c47a0be5b14b89f2c827bf28bc8eb/coverage-7.17.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:08d773b49e0001ef360a4ee7cf8e7a2101a52007fcc5b46ef56ad1032bd403b7", size = 227947, upload-time = "2026-11-03T12:36:06.739Z" }, + { url = "https://files.pythonhosted.org/packages/27/18/791ca5cf2f4b38c1e3e421d80992a67be4f0c09b5add22ff1e3c164899ea/coverage-7.17.1-cp311-cp311-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:fa52a8600a7cd6f219b41254bb6a04e000da4a79bb993d3c5b21a625f93425f8", size = 259977, upload-time = "2026-11-03T12:36:08.067Z" }, + { url = "https://files.pythonhosted.org/packages/b8/ed/952fea2330a020cd2bb4315aee09d75716c20f2920d0c3b952e7bf28c992/coverage-7.17.1-cp311-cp311-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:c33792ae97208a5a978ac63b16e70d344946ed1a0db3abb1ea64f1f7b110b5b5", size = 262198, upload-time = "2026-11-03T12:36:09.452Z" }, + { url = "https://files.pythonhosted.org/packages/b5/e6/761f6eefeee17b634b104004214cccd08b0350295ad5d0fd8bec447c5224/coverage-7.17.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:23a49c5949e96b5eae1cf16aa3f37ab6fbcf1a15602cdab9c7c31cf2ebd49307", size = 264294, upload-time = "2026-11-03T12:36:10.725Z" }, + { url = "https://files.pythonhosted.org/packages/ae/dc/4ebdbb17f038dc1e1b8677514af2e832705085327dbe4ca5760914aad83a/coverage-7.17.1-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:adc720c43f820c91e3b89158ab6b6d162532fd925b0d06ad32baf2bdf130f41c", size = 266304, upload-time = "2026-11-03T12:36:12.32Z" }, + { url = "https://files.pythonhosted.org/packages/8f/34/7597613c900c361370d2a8a7345939072aa8c751fe54dc374ee55fed0bb4/coverage-7.17.1-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:f96ac45a2adb46bc59c2c2c3dc4303501397a906a7ed953832d2f03712a82774", size = 260091, upload-time = "2026-11-03T12:36:13.759Z" }, + { url = "https://files.pythonhosted.org/packages/3d/36/b6b0dc241df22b3f61ef2fd26675fc14309bc3642a6f9c9d9cfb5f689383/coverage-7.17.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:f75d95a0fbbfa4095c307027e9a9286063f12c4f4b9f5df46023f9011175b32e", size = 261993, upload-time = "2026-11-03T12:36:15.072Z" }, + { url = "https://files.pythonhosted.org/packages/f6/c9/c8d973fe07fd67378d49a45085c7fde6f2da5a01329541fb26cc83afd0a1/coverage-7.17.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:06ee57242ba8b5da8a38289f4d70c767529e089c5e5f5492dec1851e3c0981a2", size = 260006, upload-time = "2026-11-03T12:36:16.487Z" }, + { url = "https://files.pythonhosted.org/packages/a0/b0/1f321be70939ffc74ede6b1387f5b727397870cb867382873fa6b23c047d/coverage-7.17.1-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:eb3e0fa955355da7cca2b4b55d93a4c59b60862e5563f9fac506e35e245cd302", size = 263932, upload-time = "2026-11-03T12:36:17.855Z" }, + { url = "https://files.pythonhosted.org/packages/a7/d5/5cd76e78fceab21289e344768660638b2373aebb4155c6fa76007a2e25b9/coverage-7.17.1-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:2dbdfb11dd06d10829e13724b4858e61925bbb16c5b396f7d9ccc250bcee916d", size = 259534, upload-time = "2026-11-03T12:36:19.331Z" }, + { url = "https://files.pythonhosted.org/packages/e9/52/265f3b4eef6b51f7cb5ac12f356e186388861530719437b29a8d76f5c218/coverage-7.17.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:23faef6b1b30335aff610b70f4203ae19b19deb6abd637fa9736f01da4d5588c", size = 260733, upload-time = "2026-11-03T12:36:20.643Z" }, + { url = "https://files.pythonhosted.org/packages/92/b9/fe77b52f2ded65934e0d9a559ca8385400fd54401988004dfe4242af9606/coverage-7.17.1-cp311-cp311-win32.whl", hash = "sha256:110ecef18899cbe49d7a904bb45e3c5f13a7d9c2114ba39daa9a0f3ca9eaf41b", size = 229397, upload-time = "2026-11-03T12:36:22.021Z" }, + { url = "https://files.pythonhosted.org/packages/57/f6/6b856eba8d5bcdb521c9cc41b4c4edf88a4ac61aa04e0e463f67b38872ee/coverage-7.17.1-cp311-cp311-win_amd64.whl", hash = "sha256:c4935efed225aa96f39b5ed7db08baa96996efa85c5a9d3ae2bde3ff8487631b", size = 230001, upload-time = "2026-11-03T12:36:23.372Z" }, + { url = "https://files.pythonhosted.org/packages/77/d8/11cd7ebb5b80f5570705a10f9f3ddd11e6a0b8ff9d6580f46707145dd458/coverage-7.17.1-cp311-cp311-win_arm64.whl", hash = "sha256:6c7182c03dcea5e457553f38ee0005dda781bc26c734d10659365775d5a02fe7", size = 229910, upload-time = "2026-11-03T12:36:24.679Z" }, + { url = "https://files.pythonhosted.org/packages/64/37/0e501535cfd4c71555ac26fc951cd926d6200f20ba5146cb34de429f5e36/coverage-7.17.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:7ae17b0127df7298fffec6866d45969620ca70267cf8961c5102a872abfd0198", size = 227626, upload-time = "2026-11-03T12:36:26.151Z" }, + { url = "https://files.pythonhosted.org/packages/84/f8/619e48ba82da0ff2fea7e377e427d5a1d4e918dd90613240145576aa76c9/coverage-7.17.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:b8a8f0b1d662828e7cfd52ba6d4e8d79496d4711057c33daaf29f50414d5f8c6", size = 227859, upload-time = "2026-11-03T12:36:27.659Z" }, + { url = "https://files.pythonhosted.org/packages/45/9c/93a83fdb0120538192d38b0fe77deb6036eae357a803a1e62b9bb7d1cf57/coverage-7.17.1-cp312-cp312-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:710a02c4a2f7de5f08c2ecd26fced31099032b8c3fcf2f602e4cef5190008baf", size = 260153, upload-time = "2026-11-03T12:36:29.012Z" }, + { url = "https://files.pythonhosted.org/packages/35/be/2704ac4e51ef9075255314cf547e44f43cd4bde96c9efb7da826ce39ce57/coverage-7.17.1-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:622f0d4869db8fdfa3a7ee2c6b0207b17abe59b462617599c8c3def27f482d78", size = 263480, upload-time = "2026-11-03T12:36:30.308Z" }, + { url = "https://files.pythonhosted.org/packages/ef/83/64edd51a572196239890825cdfefce0c38f634de439d3d840bbe33e09271/coverage-7.17.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6d8ba77c22882009f4f6599ccc88a9170b9c6e69f4464c2ef235e9ca24b62f68", size = 264016, upload-time = "2026-11-03T12:36:31.667Z" }, + { url = "https://files.pythonhosted.org/packages/71/95/c9998e7e718e86f85142a0cbf517d100ba2bb4c068f814245f96a253772c/coverage-7.17.1-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:8ff5288d8b03519e05697cc7065e75c55a10ce4d7581108978b549516c7edaab", size = 266294, upload-time = "2026-11-03T12:36:33.03Z" }, + { url = "https://files.pythonhosted.org/packages/46/b0/73c6276d5c75239b725207e60b19ed23a4d8c564a92232890d7ba9e70bef/coverage-7.17.1-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:6c461a379dbacd1b92c3800f529025e3b85a41a90b97e49d3b004ec690a13847", size = 260386, upload-time = "2026-11-03T12:36:34.463Z" }, + { url = "https://files.pythonhosted.org/packages/3b/57/9374f6513341d07c1a02bdbd37ee7e98fbc8d963da9e71dc4b580ef86994/coverage-7.17.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:bf29880edc2dbe589f3bc9fc7ea9a4c81cdce118a69feb52bf4dc420b475ed9b", size = 261901, upload-time = "2026-11-03T12:36:36.001Z" }, + { url = "https://files.pythonhosted.org/packages/ea/ca/50a4fab6983deb19d0ef8941c64e69e09d9428523c16e38262a0a28d379e/coverage-7.17.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:d416449f86fa1af6a9c1031fbd27ad7c1d30f57945bb52cd28250266c46ae549", size = 260066, upload-time = "2026-11-03T12:36:37.426Z" }, + { url = "https://files.pythonhosted.org/packages/66/db/4c5e12596e68084a59a108712f2a89e5cedf30fc3f2fd8b2b38e62d300a5/coverage-7.17.1-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:a7858779514aa04242f7fd7b4a92dd395d08fe791ba33624187d6c68f96245c6", size = 264114, upload-time = "2026-11-03T12:36:38.937Z" }, + { url = "https://files.pythonhosted.org/packages/bc/9b/2c8bc32551e15080c894d7f7d8c13589c91980923a11a96b51ca7c538eee/coverage-7.17.1-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:b367f16bf32939fafa8f26669fdb59ab21ee601527ad716aab7cd178ed3bd28f", size = 259566, upload-time = "2026-11-03T12:36:40.514Z" }, + { url = "https://files.pythonhosted.org/packages/f3/54/9cbf5e95496e2f8d8684eea3e7f1f4911375d01c73ccb51b067385c0d77c/coverage-7.17.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:a20b2945e275fe76ed2ed6be6103aa4d8e923b8f2678f1f3dc31c6ec8849c8a1", size = 262053, upload-time = "2026-11-03T12:36:41.975Z" }, + { url = "https://files.pythonhosted.org/packages/d1/3e/ef5728364207026031aac8f068e68f15bf71c1a84046efbca4623617cd2a/coverage-7.17.1-cp312-cp312-win32.whl", hash = "sha256:6c89aa3497bd593e1bfd9f57ebdecc5544387b5e94e6d4c6cb7597565eb551e6", size = 229457, upload-time = "2026-11-03T12:36:43.227Z" }, + { url = "https://files.pythonhosted.org/packages/e9/a9/8830de67aa3b16f94e6cc456dde07db95d0ea8001cf8224340cdb6d47cb4/coverage-7.17.1-cp312-cp312-win_amd64.whl", hash = "sha256:6e6c9759a42cf946ca427dbbd772305516401ff6d280b93cc52e7b11fcedfb2a", size = 230037, upload-time = "2026-11-03T12:36:44.547Z" }, + { url = "https://files.pythonhosted.org/packages/6b/00/a932037e8a27705d8f1aded46edf879d8f2592392dcd025349fa72d9b5a8/coverage-7.17.1-cp312-cp312-win_arm64.whl", hash = "sha256:1c06c40a9fb03ab43ace3ee27a11e61ebf233161fb9ebabfb2b51f78cf1602e0", size = 229843, upload-time = "2026-11-03T12:36:45.821Z" }, + { url = "https://files.pythonhosted.org/packages/04/e0/ff26f5a74cfcfe131bebe09649a9c9dc84a8fe8fed5cbed0117c57f7efeb/coverage-7.17.1-cp313-cp313-android_24_arm64_v8a.whl", hash = "sha256:9b8d68b2330cda90e1972e78c93c6fd572453c5b4e29594aa98550694efb0466", size = 228775, upload-time = "2026-11-03T12:36:47.054Z" }, + { url = "https://files.pythonhosted.org/packages/df/af/b83c4a7d7ed81458298c137aeefbfb7a088d36fff6fb60a0f8375e731990/coverage-7.17.1-cp313-cp313-android_24_x86_64.whl", hash = "sha256:b975d0bd867eefeff37ba28aee6ee08a0987ca3ce6bfb5e0d3ddc1b40cf3e52e", size = 228845, upload-time = "2026-11-03T12:36:48.362Z" }, + { url = "https://files.pythonhosted.org/packages/52/07/3156d72bb538d05aa4cf51d90a86cc705e9cb570d8a0eeef80880cb21d09/coverage-7.17.1-cp313-cp313-ios_13_0_arm64_iphoneos.whl", hash = "sha256:60002a0ea7f5e5f64006aba9f37aa29a4b1e52756bc0fbbc2471188b2732e4ed", size = 227091, upload-time = "2026-11-03T12:36:49.687Z" }, + { url = "https://files.pythonhosted.org/packages/cb/50/03128c382b303e02a48b1f9658bda6412288fa1d83b478696a08e410c0f6/coverage-7.17.1-cp313-cp313-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:80b613bd68caa146d090023a18dfc504eb958ff525e31e6f2368b363502bb1ea", size = 227396, upload-time = "2026-11-03T12:36:51.162Z" }, + { url = "https://files.pythonhosted.org/packages/90/83/b617213e11609d6d5d64afc701e40384bbfb39c9999531ef747b6d1259cb/coverage-7.17.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:8c2e67f95c8de089ba0ff11c7b7ee83ec0890d418e8d0185e863367f5250a087", size = 227516, upload-time = "2026-11-03T12:36:52.897Z" }, + { url = "https://files.pythonhosted.org/packages/44/98/71e36bd7bc121a33c5c78a1f687587802b2806299feb4b9f2fcf21616007/coverage-7.17.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:56f81ec13a8790a0f2ea30a14d2f39dec2374115eb88cb25cc2c0226f72f8b0e", size = 227781, upload-time = "2026-11-03T12:36:54.144Z" }, + { url = "https://files.pythonhosted.org/packages/04/e8/28f4c350e124242a757b86cd19d71d807eda8b202126c39fb57eb1495f7b/coverage-7.17.1-cp313-cp313-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:b7fb16b5c4fa1a37d69204ec5f7b8b187d2cfc54a2c084e2750ceee443748ac0", size = 258947, upload-time = "2026-11-03T12:36:55.461Z" }, + { url = "https://files.pythonhosted.org/packages/64/94/f99d4cbd1b187ac1029cadf293a934f8a2300908d8055b5c9de11577a875/coverage-7.17.1-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:b05c06318fd46706c9055a1acc6f4aa0d3a63b211bf3b6114d3c1feab76e37f2", size = 261858, upload-time = "2026-11-03T12:36:56.804Z" }, + { url = "https://files.pythonhosted.org/packages/58/9c/b91da5d4790ac926e6bede81a1bac0b8e216d2574f5c332c7494d23b88de/coverage-7.17.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8f3bbb5f9c074e97f7082987ead736036aa522cb39b996b8ed9c5aa8eee008be", size = 262791, upload-time = "2026-11-03T12:36:58.072Z" }, + { url = "https://files.pythonhosted.org/packages/4b/15/2527c7e46bcc7f69e792b7a0eba1e70d9effb5ae29f29d704487954975ba/coverage-7.17.1-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:6eb807f5eb02f64eb19f39b63015de046b312b847e3919b639a0ca19ae9a10eb", size = 264857, upload-time = "2026-11-03T12:36:59.79Z" }, + { url = "https://files.pythonhosted.org/packages/b8/83/6cf7a9cc1a4188227dc74e9293dd006e6e76b97e24747452f3b17b300f30/coverage-7.17.1-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:0bf74f2960a3d0f39067bddd658db1331a17828c93102922864699401df82dc7", size = 258994, upload-time = "2026-11-03T12:37:01.07Z" }, + { url = "https://files.pythonhosted.org/packages/98/0d/1f027bbe75df8b9553e87ad49889a288409e25bad00032391678b612c5ab/coverage-7.17.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:3da4fe4cd099239c10691ff6deb9fd291e5438ad77c2583cf235a5b9aa9250ae", size = 260950, upload-time = "2026-11-03T12:37:02.553Z" }, + { url = "https://files.pythonhosted.org/packages/a4/25/5f02f89f262a126a90fda3061ea5beb0721202d9b8469b4a50adb85b2e2a/coverage-7.17.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:d2c2973dcbcd883ec94305f513b7c05be6359679f25ad7134adf0cc512cf405e", size = 258871, upload-time = "2026-11-03T12:37:03.896Z" }, + { url = "https://files.pythonhosted.org/packages/50/2e/61f046a3ecddb2fc6e44350de857840e01fffbe83246302aa2382e8b9ac5/coverage-7.17.1-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:deea769f5199ea3e8053d5274e737e84f4a9cfbb1e69330066101825b098aac6", size = 262967, upload-time = "2026-11-03T12:37:05.191Z" }, + { url = "https://files.pythonhosted.org/packages/33/41/a45075de5bb61a646882912b7fc21cd594a83fe9be0ee6c77ffafa3a2ba7/coverage-7.17.1-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:7fdea302c956e1e85526a294ce64495b0029edc451b4655e2a9a85af6029fa24", size = 258721, upload-time = "2026-11-03T12:37:06.44Z" }, + { url = "https://files.pythonhosted.org/packages/89/ac/a58424f93baf37f1f36a9ad60d622d84482e26b017157e101ad87e965e28/coverage-7.17.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:32141eb9f9d228da33d45baf789736bc3c00a31ea9150aa7f48bbc08cfe2849f", size = 260799, upload-time = "2026-11-03T12:37:08.058Z" }, + { url = "https://files.pythonhosted.org/packages/27/10/9c424a67004ebeff99a03030115c4f8562eefabf0fa2ae889289efa85aa9/coverage-7.17.1-cp313-cp313-win32.whl", hash = "sha256:fc7b1ee12d7376ea85f6d09a272da3011c879e605d2f354d4a1c21c890cb571c", size = 229400, upload-time = "2026-11-03T12:37:09.337Z" }, + { url = "https://files.pythonhosted.org/packages/9e/0c/1b92a40cf24fa09e1bc2e7f9120a312e0b4a792b5f907852cbf64b75ab98/coverage-7.17.1-cp313-cp313-win_amd64.whl", hash = "sha256:26d0fa82cd76c888058c182b8ebb6326578f89f01cc1e576dde76bba8e446261", size = 230128, upload-time = "2026-11-03T12:37:10.69Z" }, + { url = "https://files.pythonhosted.org/packages/c3/af/67fa4bc27bdd15514810ac43c1f1285ca46e9b7af29859655948574f419a/coverage-7.17.1-cp313-cp313-win_arm64.whl", hash = "sha256:ddaca2c745275aede7b7511618aba9e1e17728f772edd1d2016529def73df01d", size = 229853, upload-time = "2026-11-03T12:37:12.173Z" }, + { url = "https://files.pythonhosted.org/packages/80/3b/41fb1e5297e4a14ec9a4f8d620b7c5bc4acd62ad8247a84287c5f05a3611/coverage-7.17.1-cp314-cp314-android_24_arm64_v8a.whl", hash = "sha256:932a542ea396dc842d0d2882ac95f33242c0029ddc226323c243d7e35978bfde", size = 228890, upload-time = "2026-11-03T12:37:13.495Z" }, + { url = "https://files.pythonhosted.org/packages/80/a0/e7b12a2e40f9af75ed4e64cbf7a9bfd17b9e1834bebd4e46b5965cb0be06/coverage-7.17.1-cp314-cp314-android_24_x86_64.whl", hash = "sha256:6cd9deae02bf24bf16fd72d1c505e81beb4cd0bbfc1b75af8ba1096a8461e62f", size = 229006, upload-time = "2026-11-03T12:37:14.729Z" }, + { url = "https://files.pythonhosted.org/packages/6e/d7/3b69b6d1fdaeb399c6a0f0dee5b94b337f5248c0d0d5b78d736563d7eda6/coverage-7.17.1-cp314-cp314-ios_13_0_arm64_iphoneos.whl", hash = "sha256:d1d62732067fe938796db0b460b0788db69cef8f91e802747eb59b2d4c1da9f9", size = 227174, upload-time = "2026-11-03T12:37:16.022Z" }, + { url = "https://files.pythonhosted.org/packages/1f/5a/a7fa52b9a98b98fbbeecc18abbd0bdacb292c4121a31497b39f54146a0d1/coverage-7.17.1-cp314-cp314-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:7681bd8f1eb33c778fff244bd06dacabf1e4325fa578c8265367216ac8b5a059", size = 227475, upload-time = "2026-11-03T12:37:17.356Z" }, + { url = "https://files.pythonhosted.org/packages/12/d3/394272eadeb616010db92d4d650b983c54b0596be87685c242b9e1f35b1f/coverage-7.17.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:4c948f185d1ca81ee2f1383f1a51387277bf6da5b14a469136031827d51d0ced", size = 227712, upload-time = "2026-11-03T12:37:19.062Z" }, + { url = "https://files.pythonhosted.org/packages/3a/5a/35108cca71cb81b671492aede98a422330bca2558aa07d2cf3ee249ff06e/coverage-7.17.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:9db719b76551607ca01b5b5464f554bec78344fff4a7f09c58f4d55cf9499cd7", size = 227866, upload-time = "2026-11-03T12:37:20.408Z" }, + { url = "https://files.pythonhosted.org/packages/5d/56/21400d3216320c3214bcd88b6d57e7217a4475d37494cfc05b2c2984b6f0/coverage-7.17.1-cp314-cp314-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:612b22d9322a0728bc209122847fd48d6353eea92e314f70a1278350dcd48de3", size = 259786, upload-time = "2026-11-03T12:37:21.688Z" }, + { url = "https://files.pythonhosted.org/packages/0c/ba/a8ab57e646da306d854613bbf2972a8a20257fecb5edb13ca2378774af9b/coverage-7.17.1-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:22edba362121a928bb4bff377915e5ce9b8f2e254239f93f38931de021485d32", size = 262792, upload-time = "2026-11-03T12:37:23.015Z" }, + { url = "https://files.pythonhosted.org/packages/c1/94/5e40670e4893e8e8cb338ae80f7c43e6cc47ce1f49891a2d02b94184605f/coverage-7.17.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f5ee8e36fd04c566fdf3d0e978b343eb1b96e9444484c199a32648cd60b0c2e4", size = 263774, upload-time = "2026-11-03T12:37:24.314Z" }, + { url = "https://files.pythonhosted.org/packages/af/1e/cf67121055a6540e7ad0060dac0d2061bd39ac9bc45fe9168a47c0fa40c9/coverage-7.17.1-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:4a87e4286f0743d0e2a0eba077453595afb6cfb2d0d18b25dea74dc9553e8dad", size = 266251, upload-time = "2026-11-03T12:37:25.535Z" }, + { url = "https://files.pythonhosted.org/packages/18/8d/b2884aa3cee232c924393ba0b7db5d44f520e02a56497e176e5128e9a4ef/coverage-7.17.1-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:806ab974da8a718697a329a126ae3655f0c8d8bfd12a7ca6c2089a2350ed0485", size = 259565, upload-time = "2026-11-03T12:37:26.798Z" }, + { url = "https://files.pythonhosted.org/packages/fc/11/1c0ccea4d6d35ac421d10f2b210bb61f3e412ad769bd5cc08011876c7577/coverage-7.17.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:2cd58acb64ad41f2e01a4d35e35c1060a1dd64699a146caef8c360cf7408083a", size = 261626, upload-time = "2026-11-03T12:37:28.196Z" }, + { url = "https://files.pythonhosted.org/packages/13/1a/ba1b45a8da773e70e5b1cdd08450a5a7cda84ab31a7aeb2c2a8c94361b2b/coverage-7.17.1-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:354ceff3c2233ed017df0f4d5d65dcd87c350ca6a129fcaa9478a7031957b03c", size = 259668, upload-time = "2026-11-03T12:37:29.526Z" }, + { url = "https://files.pythonhosted.org/packages/fc/ff/5e4ca2c677569f439269a0aab412f8e198751660412b4613ffa3f2473e5f/coverage-7.17.1-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:b927e5e4708344f94011bcb36a58023f82d2f0c8757ff2c5bf869d5c6ca0aa16", size = 263965, upload-time = "2026-11-03T12:37:30.912Z" }, + { url = "https://files.pythonhosted.org/packages/14/28/d0880224c1f8182e523c454aadd30c89af959b477245463decc7bf166cc1/coverage-7.17.1-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:65ad67be7eb4c9c48814c35c53f5fc1cf6ba17892b0e183ef3413b991085df62", size = 259298, upload-time = "2026-11-03T12:37:32.282Z" }, + { url = "https://files.pythonhosted.org/packages/5a/64/0f7c0ba50b6d3083478be28b0ffdc1de9d16df1d8abfc920de164e8ef60c/coverage-7.17.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:9e85d83d4e41e7ec7fcd026765947ae1b068eb134ba820c8ebb3bba290878972", size = 261408, upload-time = "2026-11-03T12:37:33.999Z" }, + { url = "https://files.pythonhosted.org/packages/92/71/6eab8cd02e941a8473b1e1ed579848e51a3ecaaf8300e1a43d4059d32fa0/coverage-7.17.1-cp314-cp314-win32.whl", hash = "sha256:457ad13b8ec34f5dd607cc9b68c4f6af579dfe1bb6368a25e334976860c03329", size = 229639, upload-time = "2026-11-03T12:37:35.238Z" }, + { url = "https://files.pythonhosted.org/packages/54/42/fb8cedbe674bcdecf37327b014764c98a6bbcbdf2b5faf4ff12ad850555e/coverage-7.17.1-cp314-cp314-win_amd64.whl", hash = "sha256:73a8278e7dcd338e8be66eb66deea97dc290cdc0b50e176bf96095dd498addb3", size = 230271, upload-time = "2026-11-03T12:37:36.738Z" }, + { url = "https://files.pythonhosted.org/packages/08/78/2fc61e1a128f21a6673e3ee5273e494f02489c6f2b818152db534d0c879f/coverage-7.17.1-cp314-cp314-win_arm64.whl", hash = "sha256:3be94c7a728f5bdeb09fe6d0b89542e57e0162a80555a205eec849fc25e45695", size = 230121, upload-time = "2026-11-03T12:37:38.417Z" }, + { url = "https://files.pythonhosted.org/packages/f4/ab/bcbd5e621a8c6e14336fbb0570a2d4268e1259e7ed1f0704701c314608b9/coverage-7.17.1-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:5208b4cbd83fdbf6cce21fb6137e1986c9c5a5eda6400029ab1b448c5b8f9747", size = 228174, upload-time = "2026-11-03T12:37:39.637Z" }, + { url = "https://files.pythonhosted.org/packages/9a/0b/d0307ba45d2f46d1ebfd421e9eb8201bb3bbdc5edd388432e33c3c2f850b/coverage-7.17.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:efb34d2401f0ef64502f46f9f077b376836cb5cdb98b5d481da534487f7d3f15", size = 228551, upload-time = "2026-11-03T12:37:41.044Z" }, + { url = "https://files.pythonhosted.org/packages/ce/b3/d855372f3e102e3ad9f4bdb8fbdd71df501a932b17b8da9dcd14dd2188f3/coverage-7.17.1-cp314-cp314t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:70c1747f2c7b146396da314ec0a7e45ac3dc25b883f39fc7e73cbbb42ee02a6a", size = 268543, upload-time = "2026-11-03T12:37:42.233Z" }, + { url = "https://files.pythonhosted.org/packages/5a/2c/c0dffce72ab78176d2fc9d0c695399394b172a8fef880f73670bd9061759/coverage-7.17.1-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:9412b525747a004fb450432aba6b0ed28891c6d224507020f2c1b05787b9c9da", size = 271097, upload-time = "2026-11-03T12:37:43.461Z" }, + { url = "https://files.pythonhosted.org/packages/cb/54/1e810bf8040b335a9a1434aa29ac278027413b0209638674481a7a4439e6/coverage-7.17.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:45946d12c25ceb14967e873a0a46526cfe337b075b6dff917603fd4b5448b90a", size = 273718, upload-time = "2026-11-03T12:37:44.734Z" }, + { url = "https://files.pythonhosted.org/packages/0a/5d/c8c8becee8228047577f7b352902fe34a4cca5691be12120caf3faf71d5d/coverage-7.17.1-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:76e08d61b3791098befa989da61b899ad0e4b36686534cd0078d68e940a97eed", size = 275208, upload-time = "2026-11-03T12:37:46.06Z" }, + { url = "https://files.pythonhosted.org/packages/26/fb/b00edd3abb50265c7165922b1a6820fd4b34d2917f5d573fa19ae32f73dc/coverage-7.17.1-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:c5b025803be4dee29fafc44aa6bc20255842ab26dc27de19cd0e90c4e8bf6ac9", size = 268433, upload-time = "2026-11-03T12:37:47.833Z" }, + { url = "https://files.pythonhosted.org/packages/45/af/42809663d7a98ba6f95dd976527a0b5d762eed87701dab71af4e14e60adb/coverage-7.17.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:782d2f15f59864202d3939e9bea35b8a6fae6a1d4ef489beca7bacd24058b160", size = 271007, upload-time = "2026-11-03T12:37:49.118Z" }, + { url = "https://files.pythonhosted.org/packages/92/4f/9b93e96f43f8dcc10bba69ac1ade3e707b91581d04847e05f29abf0b0136/coverage-7.17.1-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:b34dac11d9e03897f64732e3cb3a3e8dba29a7f32a34eacb9536591099fc254f", size = 268434, upload-time = "2026-11-03T12:37:50.413Z" }, + { url = "https://files.pythonhosted.org/packages/5b/ee/bc1983e6715cd211c21dc0389d1d32b789f7dfec31988cc67016aa5ed7a9/coverage-7.17.1-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:a01f6f44bd92958dba923aa414d1b868a74d175574adb50d50d60157f85da242", size = 272731, upload-time = "2026-11-03T12:37:51.802Z" }, + { url = "https://files.pythonhosted.org/packages/53/29/7a7be7b0f778d48f13908f1bb8eb0d02f9e09448d3852974cc235effbe0f/coverage-7.17.1-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:62726d1c435d1476de876bd9c6656cc69d157e0e3c419cceb4a8a588db55017c", size = 267851, upload-time = "2026-11-03T12:37:53.083Z" }, + { url = "https://files.pythonhosted.org/packages/f1/80/9b8e09889158a06d9776551d7765ac2627ae21428189af39d21818a314f3/coverage-7.17.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:05858414f6c3557c9ce2d4348215997c3834bdb95a9f6f62e97ab558d1960fc5", size = 269785, upload-time = "2026-11-03T12:37:54.396Z" }, + { url = "https://files.pythonhosted.org/packages/1b/d6/975b76074ce079c3a91248b94bab4f938f5fc39970b384cb292d26b3bfa2/coverage-7.17.1-cp314-cp314t-win32.whl", hash = "sha256:04d8ce47c70cc3f8e760cfabac5c3182f3e03829dc3cecfbfca69ff7d7ee48a6", size = 229953, upload-time = "2026-11-03T12:37:55.731Z" }, + { url = "https://files.pythonhosted.org/packages/bb/34/b55e15f3a916bb9111bad357a44413bc123346f4b72ee002f810c2e8eecc/coverage-7.17.1-cp314-cp314t-win_amd64.whl", hash = "sha256:006453b2515ea4c44a857e07b985429038b164080fa777cabea6d22d2e686325", size = 230884, upload-time = "2026-11-03T12:37:56.971Z" }, + { url = "https://files.pythonhosted.org/packages/d1/73/55ce659eb8a4e31c48ff433f4910dc48fb843a672a64f51fc6dd918d00b1/coverage-7.17.1-cp314-cp314t-win_arm64.whl", hash = "sha256:b1dc930b405b761efbfef2b3782ae5d12e22708d8086875c5f1e64318b2b857f", size = 230453, upload-time = "2026-11-03T12:37:58.467Z" }, + { url = "https://files.pythonhosted.org/packages/8d/76/a3443e64fd29e8709f274875d56f9d0c399d13d2146ff785865ec8df7766/coverage-7.17.1-cp315-cp315-android_24_arm64_v8a.whl", hash = "sha256:67e193d7c93aa93870d78594adfbe2926e9ca8bbc92c963c011092441880edb0", size = 228888, upload-time = "2026-11-03T12:37:59.709Z" }, + { url = "https://files.pythonhosted.org/packages/28/37/de21f8bebe25f3bf95f368451db12e884147514139fd0b8bc18990b2a1bb/coverage-7.17.1-cp315-cp315-android_24_x86_64.whl", hash = "sha256:eea6030a00b96f656016ea58b19d61fad3de7add8340e2e7c3b032d1516561d5", size = 229006, upload-time = "2026-11-03T12:38:01.022Z" }, + { url = "https://files.pythonhosted.org/packages/a5/41/fbf7073c3d6b053106352bfd2b4de8e0c9d27756fccc22d6b0ee20a892e9/coverage-7.17.1-cp315-cp315-ios_13_0_arm64_iphoneos.whl", hash = "sha256:603b5795c56fabfe2d0fcd64685eacba5eff1c7797741fa9b898564bb53a9207", size = 227185, upload-time = "2026-11-03T12:38:02.539Z" }, + { url = "https://files.pythonhosted.org/packages/2e/b1/e758d35cf81d6c4f405f66578ed59c1dcfbb1de5deb5662c5bf23057b6e5/coverage-7.17.1-cp315-cp315-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:ae938f631ffdf9183851140a245b44f74e35f25fc7d72edb261546ffbe8e5dde", size = 227486, upload-time = "2026-11-03T12:38:03.816Z" }, + { url = "https://files.pythonhosted.org/packages/7e/f3/c9c3d530bb7bb6142095e5d0a10e9d73107964b4b6345c922809806f6eb7/coverage-7.17.1-cp315-cp315-macosx_10_15_x86_64.whl", hash = "sha256:65f74048adacb5b031186becc29ce2a12a8aa6f86df86562a947120f5d8e58bc", size = 227716, upload-time = "2026-11-03T12:38:05.14Z" }, + { url = "https://files.pythonhosted.org/packages/1f/40/cc5395ca5038c96637510122da45d58d023e50491a2796cb920eb25ee266/coverage-7.17.1-cp315-cp315-macosx_11_0_arm64.whl", hash = "sha256:185ff7348ca70b1663b558a9a8ec66f34451c7a9428627543a0e9575045bed0a", size = 227882, upload-time = "2026-11-03T12:38:06.491Z" }, + { url = "https://files.pythonhosted.org/packages/73/89/5b8f9051cc86dba736c3b35538faa8dc4792e1b7140641531e65661274c6/coverage-7.17.1-cp315-cp315-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:5b0b4793548784c9986a4df4c90b9f672447a25c40783f1a736c7fe171a79cf0", size = 259735, upload-time = "2026-11-03T12:38:07.752Z" }, + { url = "https://files.pythonhosted.org/packages/47/5e/14081087f40abde7006010ba12cc3a0412de8088ab4afb857bf19ece28c9/coverage-7.17.1-cp315-cp315-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:834a15c96d92d2fa9503674c42615f843cc2f427b93d0a0a6c8e437ec728b1b3", size = 263426, upload-time = "2026-11-03T12:38:09.139Z" }, + { url = "https://files.pythonhosted.org/packages/ba/2c/8c41550d3280cc71640905f0961e734488328627bd367e95451fd2b10df3/coverage-7.17.1-cp315-cp315-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:16903fc7d3e60fb9336ade7b12a8343f0381a1ca719d008b3d94a051b520a1c1", size = 264509, upload-time = "2026-11-03T12:38:10.656Z" }, + { url = "https://files.pythonhosted.org/packages/0b/d7/37d4eaf0313b042b26decc8b3d4f90baae3302b0e940074b4720b724392b/coverage-7.17.1-cp315-cp315-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:f6611d1cceadef78a6c136bb94d4e1d1db9024fe8f14b6ba4424e95bb2ac9e1a", size = 266883, upload-time = "2026-11-03T12:38:11.916Z" }, + { url = "https://files.pythonhosted.org/packages/c9/c5/45823bfbb8d0c0d3ac69f6ad1fda556d87ee3d2bc930790ad12d54bc3484/coverage-7.17.1-cp315-cp315-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:efaa35a6671a9ce23d568e291edc5f97efe689eaa291a6468007cf12d3402e85", size = 260122, upload-time = "2026-11-03T12:38:13.282Z" }, + { url = "https://files.pythonhosted.org/packages/80/22/3b7eb82197af8a7b11ce57b1a3b2ecb891287a9016a77d3587051147ed8e/coverage-7.17.1-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:125b5146f8624275df6ade5b10d40fb18231ed8f79650a4c522adf7e300db963", size = 262389, upload-time = "2026-11-03T12:38:14.568Z" }, + { url = "https://files.pythonhosted.org/packages/fa/ba/460b53c3ba449af2c70cb2ca5f2583d483b57fb9a15f2a964badbd8c18bd/coverage-7.17.1-cp315-cp315-musllinux_1_2_i686.whl", hash = "sha256:08e6db8cef186e7954861705102d50d56f273026fce963135a029b1eed870955", size = 260339, upload-time = "2026-11-03T12:38:15.907Z" }, + { url = "https://files.pythonhosted.org/packages/5d/6e/9a6f1abdcc0ce00de6aa28a2ccb5c622c0f4c4fc2365d4b18d54073eec9b/coverage-7.17.1-cp315-cp315-musllinux_1_2_ppc64le.whl", hash = "sha256:3832721ed2cae5d70ee4c6549ef166d16b41ff5c351fa0aae24463b620e65bec", size = 264672, upload-time = "2026-11-03T12:38:17.149Z" }, + { url = "https://files.pythonhosted.org/packages/82/b5/cdd25a9319af55fa504ba6cfc063cd38c1326b7382aa2f73a66e376ce5a6/coverage-7.17.1-cp315-cp315-musllinux_1_2_riscv64.whl", hash = "sha256:b785cc3b82f469db18ca5b123c5eab7cf739d6a99be1fc5b4eb1c395dace5ab4", size = 259651, upload-time = "2026-11-03T12:38:18.475Z" }, + { url = "https://files.pythonhosted.org/packages/d6/80/273c406302ca223d3c72d2a277b1e776b4b21a2391c22fd2c4f41582949c/coverage-7.17.1-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:2f09e92d9f3bc2f7193fd6b354a45817c89d3cebfdd0912900f67c7822af105f", size = 262195, upload-time = "2026-11-03T12:38:19.983Z" }, + { url = "https://files.pythonhosted.org/packages/81/ec/f2d4baf81838d3fe269090b26c98f5c48f6efb482ca365f852d72d0671a3/coverage-7.17.1-cp315-cp315-win32.whl", hash = "sha256:d27344a94963356614e884c5739871190438bce03d2973ff9c13be37d40c7371", size = 229634, upload-time = "2026-11-03T12:38:21.688Z" }, + { url = "https://files.pythonhosted.org/packages/e5/bd/6b6467a081d5da4c5fbd65908070bb9c6b90471738d74239a23ab8ef1e59/coverage-7.17.1-cp315-cp315-win_amd64.whl", hash = "sha256:4ebb24cdee700ba3987aa5c9bc773677cafb6d88edc6f6d9cf79bc0df96b473e", size = 230256, upload-time = "2026-11-03T12:38:23.307Z" }, + { url = "https://files.pythonhosted.org/packages/00/1f/522e0d03e2cdf4a7f2538d6858b64fb95a3193003bb0d79a42b6e1426bc2/coverage-7.17.1-cp315-cp315-win_arm64.whl", hash = "sha256:cbbfb4b9d99766653447f664622168e0d00fef41e6d25a7700eaf6d9f10ae0fd", size = 230120, upload-time = "2026-11-03T12:38:24.514Z" }, + { url = "https://files.pythonhosted.org/packages/bf/47/7ea4bdf31bf175b53067998a6e9b1e4e50fef191f0e3d4c426843dcc1801/coverage-7.17.1-cp315-cp315t-macosx_10_15_x86_64.whl", hash = "sha256:9cd33f622f11927736fcacf884fc6a61605e9c15e489d24dc77cf84c7015ffe5", size = 228174, upload-time = "2026-11-03T12:38:25.837Z" }, + { url = "https://files.pythonhosted.org/packages/14/bd/05a784dffccc384aa939e3d4afbfed7c03dbbd4e56c15fa2262fc665a789/coverage-7.17.1-cp315-cp315t-macosx_11_0_arm64.whl", hash = "sha256:719b3925108a2ce55a6a9dd5bfd9bf9114c7da1c57b9ea39e59f0fc1ba9d4fa7", size = 228566, upload-time = "2026-11-03T12:38:27.073Z" }, + { url = "https://files.pythonhosted.org/packages/dc/c7/c91c08cb288588711eaf448873536472aa6bec8e97e8f5c4bb7c3472f9a6/coverage-7.17.1-cp315-cp315t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:15981f51ef23c16de05e740677e1dbc59fd078fbf60ce4cb89687135585a791e", size = 268923, upload-time = "2026-11-03T12:38:28.267Z" }, + { url = "https://files.pythonhosted.org/packages/9c/96/99fc10e4eb6e64e6c613158c79805653366991b93293d18a1a62748e2038/coverage-7.17.1-cp315-cp315t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:042e093be797b929741fb71238da028f0f2d9d669a3a7ab3588967d77f860b51", size = 271762, upload-time = "2026-11-03T12:38:29.534Z" }, + { url = "https://files.pythonhosted.org/packages/5e/33/fd2aa355efe9cceca9518a7b1f73623ff9a1deb2709cac2b8a096a1773ee/coverage-7.17.1-cp315-cp315t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:118f9bacb98a78b5e81c3a4721adcfb1b404942a5a2ec34e0d47a1ee7d772b3d", size = 274461, upload-time = "2026-11-03T12:38:30.828Z" }, + { url = "https://files.pythonhosted.org/packages/e8/ad/e67a208e56876a5b632cfeff790804e331db581c9c5f439235bf40cfc13f/coverage-7.17.1-cp315-cp315t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:0411fe8b17b7f481cdfe9138bd5b266bb18de124114cfab0cf796b61383ef321", size = 275794, upload-time = "2026-11-03T12:38:32.203Z" }, + { url = "https://files.pythonhosted.org/packages/ad/c9/90717d790b248e1f081f9498d91050969de86d35c687a755db1c48ada4f8/coverage-7.17.1-cp315-cp315t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:af1f1c7057ff655f0e2673ca931ab9e69683c26841d7838a9677eb6484c637fd", size = 269483, upload-time = "2026-11-03T12:38:33.602Z" }, + { url = "https://files.pythonhosted.org/packages/3e/bc/162be11201171171e084cb388bdd8a44ccb820733a3cf13bd3da398e46a5/coverage-7.17.1-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:0bc7c1dbd90be3ddb3bab347deb91996bcb33828aa662acbe83334c55ee0642d", size = 271952, upload-time = "2026-11-03T12:38:34.874Z" }, + { url = "https://files.pythonhosted.org/packages/cb/2d/9ae1eb08020d998d4c9bb6e539b096642129eaec5cc423b0eca6ea216a3a/coverage-7.17.1-cp315-cp315t-musllinux_1_2_i686.whl", hash = "sha256:7c93a389c1f696ab7ca4764f6629dae187f41aac19ae763e18b35cd60dd7d2b4", size = 268977, upload-time = "2026-11-03T12:38:36.164Z" }, + { url = "https://files.pythonhosted.org/packages/81/6c/33577528fdb8a9d6af5e5f188c28a364d5ed82c57c49dcade7e96682da06/coverage-7.17.1-cp315-cp315t-musllinux_1_2_ppc64le.whl", hash = "sha256:208ecaaa274e8c97ff8939baa15cfd4e9a5ed0b7a0132206548277e7938e96e7", size = 273587, upload-time = "2026-11-03T12:38:37.412Z" }, + { url = "https://files.pythonhosted.org/packages/5f/a7/6449f497df0012d8e793bab0788d0265d9d2753b33b64fbd47ce8dc50eed/coverage-7.17.1-cp315-cp315t-musllinux_1_2_riscv64.whl", hash = "sha256:043af54ef18a5ea6ec5c5347408d21165fd5ddff4f62f63efea32cf3c0ba6ca1", size = 269072, upload-time = "2026-11-03T12:38:38.858Z" }, + { url = "https://files.pythonhosted.org/packages/9f/08/35148999d7e8bef6e596cc056d5a7a403d2c702daa5b51e22d138056b254/coverage-7.17.1-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:8830f81b489c1fcba77338cf9e176d253117dd886fb58e587a137f9f5bf9b062", size = 270684, upload-time = "2026-11-03T12:38:40.155Z" }, + { url = "https://files.pythonhosted.org/packages/fd/bb/6c0714bcd3ed4b9ec00902281dc17fcf59eb308185ae78e7bea2f037dc20/coverage-7.17.1-cp315-cp315t-win32.whl", hash = "sha256:f705761e5187ba08bbc80fd4b5b6d675e23ecc4f468daee2f5b22cfc8f5ed96b", size = 229942, upload-time = "2026-11-03T12:38:41.524Z" }, + { url = "https://files.pythonhosted.org/packages/5c/34/8d88d51ff9c3da15430c902aca5409a98c01b8d7fad18d631daa53df734b/coverage-7.17.1-cp315-cp315t-win_amd64.whl", hash = "sha256:87e86e0c7712ce64316f649c6d0b30225aaa64da25ff201bf6a1d86d21168d73", size = 230870, upload-time = "2026-11-03T12:38:43.146Z" }, + { url = "https://files.pythonhosted.org/packages/8e/58/9cdb5667edcd9bd5b17293e96620e50e89d425d8a450a1fa57f18e68b5d9/coverage-7.17.1-cp315-cp315t-win_arm64.whl", hash = "sha256:9cd4319b51f18519688baf38e01424ec439a5da5ef034a7e429bc631afa95e63", size = 230443, upload-time = "2026-11-03T12:38:44.433Z" }, + { url = "https://files.pythonhosted.org/packages/18/61/7ad3e5f92557c73044d3dfaf88cc65fb7b1ad589c744e8629af8e6370224/coverage-7.17.1-py3-none-any.whl", hash = "sha256:fda1023828e4a9f4a40ef06783e005f3630f805f839edc679c87f597f33e041f", size = 219074, upload-time = "2026-11-03T12:38:46.229Z" }, +] + +[[package]] +name = "cryptography" +version = "50.0.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "cffi", marker = "platform_python_implementation != 'PyPy'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/9d/af/182eb91b0df3fe75c4d9f26fe70684569566745f6ba7e5c9c73a862c5252/cryptography-50.0.2.tar.gz", hash = "sha256:7b46165bb56eb4704e2eaaf86f3c940d19154535d9b0ca7d6d590b04060e00d5", size = 880623, upload-time = "2026-09-30T15:30:04.884Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d9/69/c9bd862c3bf43d6399c433caf002df16e2dffd4be49bdf515cda38038711/cryptography-50.0.2-cp311-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:79def8d059362e7831389ed3be0ecdf58a89386e1271e35dd9f5af84e81bffd0", size = 4731146, upload-time = "2026-09-30T14:43:47.113Z" }, + { url = "https://files.pythonhosted.org/packages/21/69/64cef1f702bf6657e0cc186ed1a2891d50d29fb41586b254e1c07adea261/cryptography-50.0.2-cp311-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:630ebfea3bf689d075f82316324ff7433dc447fe6bc1bfc76524b74b4a9567d2", size = 4719841, upload-time = "2026-09-30T14:43:49.01Z" }, + { url = "https://files.pythonhosted.org/packages/38/6b/61a3f8d8c5e1e49a6cddccafc4015cc1c0021360ab0acb4080e7a423644a/cryptography-50.0.2-cp311-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:f9f6143a8c75945eb960d9eb98905a441394abfa24afaae239d514ffb2586480", size = 4738340, upload-time = "2026-09-30T14:43:50.932Z" }, + { url = "https://files.pythonhosted.org/packages/1a/f1/b474e930c4d910328780e3940da76f5aa5cbc48ce1fc14e44d239d9ea9db/cryptography-50.0.2-cp311-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:4061c0079120205fb760c58acab6443e217307dcf05e3702cf970e0689972856", size = 4753050, upload-time = "2026-09-30T14:43:55.272Z" }, + { url = "https://files.pythonhosted.org/packages/7c/52/9af10e80ac16b0fcc2123f9cbd5e7afbd0fd5075bb7a607c592258a39cda/cryptography-50.0.2-cp311-abi3-manylinux_2_31_armv7l.whl", hash = "sha256:ac9ed99d81760c62fe89d5f0815cdfa1ba9a35141cf30f1c2d044f04b4803d2e", size = 4376724, upload-time = "2026-09-30T14:43:57.24Z" }, + { url = "https://files.pythonhosted.org/packages/71/37/6202e488cc1eb625ea110c292c6bda92823176e023f427d8d5660ce8d632/cryptography-50.0.2-cp311-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:87e9ce85beb6b328ba370cc6e6aea483c92617b4c95b1d33a49297eb662bfb04", size = 4737859, upload-time = "2026-09-30T14:43:59.541Z" }, + { url = "https://files.pythonhosted.org/packages/d3/69/2c833a049475e0a3444e94c7d0aca0aa51d166374a449b09e92ac98138de/cryptography-50.0.2-cp311-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:9dab55f57c74c3cad24c323bacbbd04be4705ba6eb0d92e920b1fc4837ed5079", size = 4752576, upload-time = "2026-09-30T14:44:04.545Z" }, + { url = "https://files.pythonhosted.org/packages/6c/5d/906970b83bbfc1f5bbfb677a143c181f2801f23b6a7204a3b47c42c97e65/cryptography-50.0.2-cp311-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:25784ce8b9621c90c643efb9e1e2162ab3b0224cae446ad5e70e7fcb1ce18b51", size = 4870819, upload-time = "2026-09-30T14:44:06.884Z" }, + { url = "https://files.pythonhosted.org/packages/68/e3/f2298d3bb55e0c4a91841ec4d01b3f020ba8c5fbf15ccdcc6dcf03f97025/cryptography-50.0.2-cp311-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:85d0d9a31b9098e98534226d5686b47264b95e62ce459dc2e62fdfc809f9fe93", size = 5030152, upload-time = "2026-09-30T14:44:09.443Z" }, + { url = "https://files.pythonhosted.org/packages/19/8e/aa1fc533d4546b127b45de8aa024eb5933d23eff9debfe25931e56861095/cryptography-50.0.2-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:0ecbc5652bdb6fc9eaf89a7d196e20941adfe812f43bc4ca05d9150496821047", size = 4710431, upload-time = "2026-09-30T14:44:15.427Z" }, + { url = "https://files.pythonhosted.org/packages/6a/64/72bc3f75176e7e406b748a3e3830432b8c51297b38368713df04dc04898a/cryptography-50.0.2-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:ab50ee449bf968271e820086f10a33d101dd060370abc10bcd22279be2656539", size = 4694824, upload-time = "2026-09-30T14:44:17.69Z" }, + { url = "https://files.pythonhosted.org/packages/4e/c6/62c77550edfa5ca3f14bf44a1e6739b9fa09d6e998a11d97ed8213bccc98/cryptography-50.0.2-cp314-cp314t-manylinux_2_28_aarch64.whl", hash = "sha256:a9f7355e6fab51f6c369b86fb7571cffa05edee2c2121e0380a37fb9ac1cd5c1", size = 4716967, upload-time = "2026-09-30T14:44:19.661Z" }, + { url = "https://files.pythonhosted.org/packages/aa/9a/6f2f0304d634ceafdeaf23e84537336664ac419b5d07611675c2ad3f6b7a/cryptography-50.0.2-cp314-cp314t-manylinux_2_28_x86_64.whl", hash = "sha256:241449bf940a5d27309bd317e6f9a2af6932113818bb2b8f5c59ddc7ef16da18", size = 4727698, upload-time = "2026-09-30T14:44:24.178Z" }, + { url = "https://files.pythonhosted.org/packages/1d/de/66bcf9244d118663b2e1aaded8990f4640e3d7b7411870a5765f252074d2/cryptography-50.0.2-cp314-cp314t-manylinux_2_31_armv7l.whl", hash = "sha256:d8947001be83df1394050758ce0e745dd74fb134eef0a4b5124208dfc3a68c37", size = 4354821, upload-time = "2026-09-30T14:44:26.263Z" }, + { url = "https://files.pythonhosted.org/packages/bd/e6/db28a28c7b6c676addce89136de3d8db49ea825a8c863472e36e42ead4ad/cryptography-50.0.2-cp314-cp314t-manylinux_2_34_aarch64.whl", hash = "sha256:4a20ce1e5cb4284a86692fdcba7cb8754185c6b2e5c56fcef3751cf451d3cdc2", size = 4716748, upload-time = "2026-09-30T14:44:28.447Z" }, + { url = "https://files.pythonhosted.org/packages/6c/01/03263395f74d50b071e9e66daace3f8bef80493e5d410726f2ba8554736b/cryptography-50.0.2-cp314-cp314t-manylinux_2_34_x86_64.whl", hash = "sha256:828d49b0ff5a0e3975865571c5d91dbbdd0d38d8289b249a163e9425413a5e05", size = 4727268, upload-time = "2026-09-30T14:44:32.92Z" }, + { url = "https://files.pythonhosted.org/packages/eb/94/2bfe8f29ec0cc9c0d99359c4161adf32858e4934b72c6d100d2ac0bbe962/cryptography-50.0.2-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:deb9fde5c60e437ee4821bc9bc39ff31b42135c27e1dc61ef0a629389c1de62e", size = 4849503, upload-time = "2026-09-30T14:44:34.969Z" }, + { url = "https://files.pythonhosted.org/packages/54/44/e80651ecbf0e42b62e2bb5f5768916e07eea72e1297338956a61df361f88/cryptography-50.0.2-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:8c71ba2cd31fc93748c38e1b613200ff1c2665cbfd5341fe3a61cfde35a1430e", size = 5004057, upload-time = "2026-09-30T14:44:37.064Z" }, + { url = "https://files.pythonhosted.org/packages/8c/75/32ac2a56243d778805c16ca6a32b8f74fb757df7e28d7ecb560afafb59cf/cryptography-50.0.2-cp315-abi3.abi3t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:d370b8d1dfcdf7130178137f6fbee6140774a1acc6cacefc4b42643ec11d0a3a", size = 4956267, upload-time = "2026-09-30T14:44:43.693Z" }, + { url = "https://files.pythonhosted.org/packages/aa/a4/2c8d734e43d97f0842ee9f1b7b4bfb3d0cf5e19edebf43c2afe6675c2320/cryptography-50.0.2-cp315-abi3.abi3t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:f2f9bd7f90c64fe89253f0a2c05e3c4856072660429ce8831b4235bf29403a67", size = 4966465, upload-time = "2026-09-30T14:44:45.769Z" }, + { url = "https://files.pythonhosted.org/packages/c2/58/ee288c829a6f41f6235ae9dd33d82fd19b45442b65b4c8a3da36963d9f7a/cryptography-50.0.2-cp315-abi3.abi3t-manylinux_2_28_aarch64.whl", hash = "sha256:e275096ea1e60cc595cda2836fd4a6c725d1125108b868be17f53684d164e2cc", size = 4959356, upload-time = "2026-09-30T14:44:48.211Z" }, + { url = "https://files.pythonhosted.org/packages/02/a8/8df951850d6b31d2a00218f19e2b3f999523437ed7a819df7fa427942fca/cryptography-50.0.2-cp315-abi3.abi3t-manylinux_2_28_x86_64.whl", hash = "sha256:58a0c478eeca76fe5e07993c5a0703def34a6dc6a0cda4f5564639b33112ffe7", size = 5001199, upload-time = "2026-09-30T14:44:53.379Z" }, + { url = "https://files.pythonhosted.org/packages/8b/f9/36b3022218ce75b7cdf068fb95f809f9bd0d820e4955ef43b90c255cc7ac/cryptography-50.0.2-cp315-abi3.abi3t-manylinux_2_31_armv7l.whl", hash = "sha256:d38cdff612d06fa6a32840d5e1b1f7a27cee4a349aa9085d94a67789d6bfd408", size = 4629333, upload-time = "2026-09-30T14:44:55.635Z" }, + { url = "https://files.pythonhosted.org/packages/8c/72/20f99a219f6af47cdd1cbd978c243b92d71496e168a746138af44ded4f29/cryptography-50.0.2-cp315-abi3.abi3t-manylinux_2_34_aarch64.whl", hash = "sha256:fdd28f912fccfec1846a94e2e1e8f9b0012f557f0c46fe4f3eb0d7a87afcf90b", size = 4958822, upload-time = "2026-09-30T14:44:59.639Z" }, + { url = "https://files.pythonhosted.org/packages/24/95/83378121ef3eaaaf71d4b781577ff794acb39b9e1b87a3f156898c8497ed/cryptography-50.0.2-cp315-abi3.abi3t-manylinux_2_34_x86_64.whl", hash = "sha256:e105ab60406787da31fccc883fc0f733af1efd78f0136a4599692c4083a73d0c", size = 5000859, upload-time = "2026-09-30T14:45:05.009Z" }, + { url = "https://files.pythonhosted.org/packages/22/f7/70fd7ae4d1dbfa7ba29b02e1b9068771519a86027756510b700ce81086a8/cryptography-50.0.2-cp315-abi3.abi3t-musllinux_1_2_aarch64.whl", hash = "sha256:6f8700550aa1474a91e5dc07049c46f98b423b5b1ddd0483e0b51362eeeaf5be", size = 5092151, upload-time = "2026-09-30T15:29:15.932Z" }, + { url = "https://files.pythonhosted.org/packages/d4/be/688367b74de86984bd58d8efacfc7c9e68b89a6a22ced0fb4f38db50254a/cryptography-50.0.2-cp315-abi3.abi3t-musllinux_1_2_x86_64.whl", hash = "sha256:c71be1cbfa5cd9a41ee452acf1eccd82b2c05950358b106ec8ceb83411d1a020", size = 5286120, upload-time = "2026-09-30T15:29:18.309Z" }, + { url = "https://files.pythonhosted.org/packages/d5/8d/6d585339bedf85d45044c85d8412dac53f2bb6f918e8b7777efba1787844/cryptography-50.0.2-cp39-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:c5e67125c7dca78d199ec4e116aa93dbb83494808ecbb8211a2cb09b1bf41dbd", size = 4756166, upload-time = "2026-09-30T15:29:24.58Z" }, + { url = "https://files.pythonhosted.org/packages/bf/f1/1c1f6874e8550cfddd4b688ceb38cefb6ed15ceed224d56f133f3d88c214/cryptography-50.0.2-cp39-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:ee247f5c245c9a2fe7c8e2214e295918838e44e00a45a6718451e4004219e767", size = 4749145, upload-time = "2026-09-30T15:29:26.807Z" }, + { url = "https://files.pythonhosted.org/packages/c1/63/61b15dc1a8de03fe0adbe3fd7608b3ad5c73bf50993bbcb1faaa930afe33/cryptography-50.0.2-cp39-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:dfe9763530994147d9af1def057a5b9658b00e8f8fe8743d144d1e0911c2e454", size = 4763638, upload-time = "2026-09-30T15:29:28.588Z" }, + { url = "https://files.pythonhosted.org/packages/4f/87/ef344a9e616871f2519c22d6afcda79ddd5d35e9592d95eb6e677608d055/cryptography-50.0.2-cp39-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:f21e8a22c8605750c7af886bab299a363721264061b4ac0a30efb73cfd58efc5", size = 4781387, upload-time = "2026-09-30T15:29:32.605Z" }, + { url = "https://files.pythonhosted.org/packages/90/5b/f2fdb13cd0b96f6f932c8627bb292a45f11c64d21620a8e120aee9a3b848/cryptography-50.0.2-cp39-abi3-manylinux_2_31_armv7l.whl", hash = "sha256:9c8402a82ea0dc4ceeab793db05f0fafa8ca139ca34fcde5df0f596103c74107", size = 4403790, upload-time = "2026-09-30T15:29:34.374Z" }, + { url = "https://files.pythonhosted.org/packages/bc/ce/7e4f662b1e3c393513569e402cfc85ac7da0bd3d5435e122a3140219eb2d/cryptography-50.0.2-cp39-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:0ddc924c04591c2811ca024d62ecad4f7f6f08af8939c211438f48a16bd23602", size = 4764319, upload-time = "2026-09-30T15:29:36.149Z" }, + { url = "https://files.pythonhosted.org/packages/40/cf/6b5c8e2fd9202d98988ab7cb5cc5c991704c4ad55f492ff408e4969f83f1/cryptography-50.0.2-cp39-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:1981f1db4630889b9ef7803fadef12b056f428cb6b85c27ba57b774793b6093c", size = 4780973, upload-time = "2026-09-30T15:29:41.251Z" }, + { url = "https://files.pythonhosted.org/packages/10/bf/8d6ebc7dded797bd0f0160d52188021211f011a2b164ef0ae1dac4587465/cryptography-50.0.2-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:7a8701d6b584d76e909e3d305b7d126b41439876a5aaf76cddc67fc230eafa2e", size = 4897738, upload-time = "2026-09-30T15:29:43.106Z" }, + { url = "https://files.pythonhosted.org/packages/d4/aa/f3f6e0de7e6253b8baa8b2d8fb9d50924fa75cee3d4624bd4bc1208ee923/cryptography-50.0.2-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:ce47f66801c20ec6c6632453bb5960fe38939e9306970b48b3a5a26de7745d94", size = 5058280, upload-time = "2026-09-30T15:29:44.827Z" }, + { url = "https://files.pythonhosted.org/packages/1d/7a/f08d34ce09d60f89ebd391e2ebc6ba2b995e6dd7552f41820f8085f94e53/cryptography-50.0.2-pp311-pypy311_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:92e665960f25fcdc73725b9cec7a3824f279ba97a98653afe9ffac2e43668f67", size = 4716035, upload-time = "2026-09-30T15:29:48.681Z" }, + { url = "https://files.pythonhosted.org/packages/45/67/e18fb65592451a2acb76e9f2fbe14e0f47a8318b4c5430f1633851d03daa/cryptography-50.0.2-pp311-pypy311_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:eef4c2f3423810b3070ab391f85436d2f8bbfcb286ac15cbc73190b3563b1f1a", size = 4726917, upload-time = "2026-09-30T15:29:50.608Z" }, + { url = "https://files.pythonhosted.org/packages/83/28/38fdce17e60f6b825e69fc3b7f75e70a6612759980704697e1de4cbfaf6e/cryptography-50.0.2-pp311-pypy311_pp73-manylinux_2_34_aarch64.whl", hash = "sha256:7c6d0330c472d96f6a6afe24d80dfdf15176c33096f0a4397ae4c60f3dd3be48", size = 4715341, upload-time = "2026-09-30T15:29:52.522Z" }, + { url = "https://files.pythonhosted.org/packages/b6/b1/d9121a717e0f893c64bd6ca7702614778d7df2a5c309128a002421788516/cryptography-50.0.2-pp311-pypy311_pp73-manylinux_2_34_x86_64.whl", hash = "sha256:1ba34f04897fcdaa73f74145c25f3ec146fbd56593853e88adc2e811303c5f42", size = 4726322, upload-time = "2026-09-30T15:29:54.263Z" }, +] + +[[package]] +name = "cython" +version = "3.3.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/99/ca/18e324972e5cac914816fdd7bb03e19a455b90039c277a538f7781b50c85/cython-3.3.1.tar.gz", hash = "sha256:e0e45989e821bef6aa9ae15c7d583ab5e055f7406c4b3624e49e06d24e90375a", size = 3743354, upload-time = "2026-11-01T20:12:04.773Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/14/e1/bad59c9ce7931f5c2b7cd9d5228d16926373267bb841aa8a4b29a1ab3c3a/cython-3.3.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:0ce9efd76bfbf7b67be0da80d450231e1c1bdd5e755d7a8dc10ffc2669fc5edf", size = 3135399, upload-time = "2026-11-01T20:12:28.657Z" }, + { url = "https://files.pythonhosted.org/packages/21/33/cb2588a238d862ebc5e973acc3504ec28764bcc4273828f8e0915354415f/cython-3.3.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:43b16388665cb829c265060705900db8e26e9c3c04cc91f28af38c905d12293f", size = 3351071, upload-time = "2026-11-01T20:12:31.078Z" }, + { url = "https://files.pythonhosted.org/packages/5f/78/1e8562e6dc57f6b9398bc754dcaf574f71762a5a637bb6525ae06cdc7f91/cython-3.3.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:26a28e0ca5dffe9c7d69d1e3a0f78cb74f41b2b6b40771f620262a5d04862a00", size = 3483723, upload-time = "2026-11-01T20:12:33.044Z" }, + { url = "https://files.pythonhosted.org/packages/de/44/55cfaaba499dcd06fb998bf64d3839f7208e80b2acb1dabcdec515d26bf9/cython-3.3.1-cp311-cp311-win_amd64.whl", hash = "sha256:298d3e46d1d4e2f4405d2c934b51899482101a0b0dc43b1b13b2e38f87addf52", size = 2866366, upload-time = "2026-11-01T20:12:35.09Z" }, + { url = "https://files.pythonhosted.org/packages/40/3f/362d57b505de56a3a24f84a94b2e09772ebbc9d05402e9c3bbe7b1b780a5/cython-3.3.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:744bb804252cf204e6bc9b0fac06b3bad7bb14258cefb9f321c59c4c59e9bc17", size = 3145239, upload-time = "2026-11-01T20:12:37.11Z" }, + { url = "https://files.pythonhosted.org/packages/4f/9d/016dfaefc1a10e182fd770e6c331ebf79df88a527883b4ecbdd74abb9969/cython-3.3.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5f08b3eaa639005bea6ab119ebbd6e30656e448981e7a124d80b409760d06c15", size = 3262357, upload-time = "2026-11-01T20:12:38.861Z" }, + { url = "https://files.pythonhosted.org/packages/4a/c6/51ffdd996a1e6836792061ebe7ecf40480f1bd5693a721cea0ad4a689a81/cython-3.3.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:215669fd0ce792080cd4d0748db7e1e31f424b6706a6220d08339895e6a3a03a", size = 3418124, upload-time = "2026-11-01T20:12:41.076Z" }, + { url = "https://files.pythonhosted.org/packages/4c/6b/de4b5b3f43bccd82ef48071a33c48315098867eafe6ae3a39f1064f8d331/cython-3.3.1-cp312-cp312-win_amd64.whl", hash = "sha256:fd81cfc6e94c43c5c0fe50439c11b90dc89cc6b323f92b37edc6a951d0a619d7", size = 2875470, upload-time = "2026-11-01T20:12:43.169Z" }, + { url = "https://files.pythonhosted.org/packages/4c/c1/15881737c54e90c83ff314998b363a2069ec184bf642f2cce9222dc631c8/cython-3.3.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:6156be528b46e820ba834449716690d5065049ff355f261a8600f7da6b436d96", size = 3136530, upload-time = "2026-11-01T20:12:44.807Z" }, + { url = "https://files.pythonhosted.org/packages/64/db/73a6f5f560b7f77fa5f2b5dca15f761f0598776f47951356449e162a4514/cython-3.3.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d0f2610ce850d264e29a87b3d9b8ec4f0f2dec5bc1dce0398294251f09b149df", size = 3257359, upload-time = "2026-11-01T20:12:46.783Z" }, + { url = "https://files.pythonhosted.org/packages/a3/04/5445c845d08948b4006c72b5bc202b63f108ff0b87161a993dc5922106a0/cython-3.3.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:85be5442e8f465c7c5e80837ac2a85a2ce04034e616445113092e85b65d0ab94", size = 3413336, upload-time = "2026-11-01T20:12:48.701Z" }, + { url = "https://files.pythonhosted.org/packages/e2/2d/8afe74009f266c43033dc54d851f31edadc414842cc061bd2762ffc9737f/cython-3.3.1-cp313-cp313-win_amd64.whl", hash = "sha256:0f7d52979bf7730351cf9ca2e9257d4b80f729053b521159bab8666e6be7e3bd", size = 2869329, upload-time = "2026-11-01T20:12:50.577Z" }, + { url = "https://files.pythonhosted.org/packages/7c/f4/2892e59c7e75e75766021c40c165a30edbbfdae4efb6e10cb3fd23486b66/cython-3.3.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:3370326802b82cc7cb7df65e605e1acfebdce193077e27ed5734b9bc3f7c6ad0", size = 3188251, upload-time = "2026-11-01T20:12:52.507Z" }, + { url = "https://files.pythonhosted.org/packages/8d/94/dad3d60dcbf22616ee6564456ffc3b6594d5cac9b91735f34ab90633326c/cython-3.3.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b0eac1184dd57591a8f3d25691c7a6bf7db030f515b210691bd251772a7e70a4", size = 3335776, upload-time = "2026-11-01T20:12:54.507Z" }, + { url = "https://files.pythonhosted.org/packages/07/d4/6cb0c23f8f3e7081c3af03ccf685a73cfa86af85725b9f4c44040e5f8858/cython-3.3.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7a6c191617853f2e0d5936c73f5d5cd096548f4d9e0fa37612ef721591c42cb3", size = 3459005, upload-time = "2026-11-01T20:12:56.224Z" }, + { url = "https://files.pythonhosted.org/packages/82/69/8efe9179f9f139d4fbe367e5e76e40673c87450f3f4ed1a5c1350be365bf/cython-3.3.1-cp314-cp314-win_amd64.whl", hash = "sha256:7bcc6de1603d8180667b40f4014be142d7d62cfc10af0184ad8d6a83847a2ced", size = 2928989, upload-time = "2026-11-01T20:12:58.247Z" }, + { url = "https://files.pythonhosted.org/packages/cb/37/231f00ec8f6a56519aea9cef921ae9c5d4c39edd8b5557d0de9048211004/cython-3.3.1-cp315-cp315-macosx_11_0_arm64.whl", hash = "sha256:a1bfd7511fe8d83f5e681876df22878efac5cd5b2c174f272e6bf018c8fd4a91", size = 3179367, upload-time = "2026-11-01T20:12:59.906Z" }, + { url = "https://files.pythonhosted.org/packages/3c/b1/a0ed5165b268fe2d52929e08e9e89278b6f2eeee1c49c9976ba64ef194b7/cython-3.3.1-cp315-cp315-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:bce8f37f50add0432ac802cfc34e5bd16395f2918ad1eaeb50b26d02c9001014", size = 3331494, upload-time = "2026-11-01T20:13:01.774Z" }, + { url = "https://files.pythonhosted.org/packages/63/e4/4ef74af67d86067258187a24764df2d9d9bf9adb0b78712862dea051eaff/cython-3.3.1-cp315-cp315-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:fcb6c86dddaedd1da5d77ba2469c1a4bea52442e02d8f0653ff78667fbaaa8d9", size = 3456176, upload-time = "2026-11-01T20:13:03.833Z" }, + { url = "https://files.pythonhosted.org/packages/a2/0e/0458355eb10a33315ede98d91a40b5848f3302cf4e9b44c70211a592ae3a/cython-3.3.1-cp315-cp315-win_amd64.whl", hash = "sha256:45dd533a87c9629d02d77c9a5b48cf399907a99e4bb556aebafd2ac4b68580d2", size = 2927687, upload-time = "2026-11-01T20:13:05.712Z" }, + { url = "https://files.pythonhosted.org/packages/d7/4e/548df758dbbea481ab054e062933252753b8db86757894bbb1fa84bd9292/cython-3.3.1-cp39-abi3-macosx_10_9_x86_64.whl", hash = "sha256:c4e4132b03a6c6c11541f7498441224f55a9e101c615d49494983d2b10dd7669", size = 3066885, upload-time = "2026-11-01T20:13:07.719Z" }, + { url = "https://files.pythonhosted.org/packages/87/55/61840ec209f861887ca547c75c401a493be6c034c1d9ad8f9b628b607054/cython-3.3.1-cp39-abi3-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:226d791808ce95f20ab1b3589082be604b5b5b31e670bf773ef9c312d2f0a8c2", size = 3361449, upload-time = "2026-11-01T20:13:09.398Z" }, + { url = "https://files.pythonhosted.org/packages/96/b1/16e743c3fbfa6424d9c94430934b5bde3a696e7b72c1476e284fdcd1210f/cython-3.3.1-cp39-abi3-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:4d1f9d6fad7a8d9750b641a941cd841ec43740a375cb2fdb934329a17fa88b36", size = 3044439, upload-time = "2026-11-01T20:13:11.239Z" }, + { url = "https://files.pythonhosted.org/packages/59/4d/5e19712c074564e696731df56242c7626001b5695d09798115d788cbd771/cython-3.3.1-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:73f6f40f9308e77cbdb3259155d793ac189ead6687b9a432f1b4503170cb9a13", size = 3157847, upload-time = "2026-11-01T20:13:12.87Z" }, + { url = "https://files.pythonhosted.org/packages/39/16/d6517f078e69f0e5b224b0f1109851408f240af70982d1ef61c53f3a2df9/cython-3.3.1-cp39-abi3-musllinux_1_2_armv7l.whl", hash = "sha256:801730e5714a40dbab8a373af36110de8ff161ec056c855a9627cf05fbc8a6d1", size = 3049217, upload-time = "2026-11-01T20:13:14.506Z" }, + { url = "https://files.pythonhosted.org/packages/78/5c/539b55fa787a427b0dd0e2ba805c04acb108fa65c69ff76e901d44e4a2d2/cython-3.3.1-cp39-abi3-musllinux_1_2_i686.whl", hash = "sha256:a2bdb50e9fe8974447b68edc5b0201573b06d2c5683f472a5fc08e1792051277", size = 3376191, upload-time = "2026-11-01T20:13:16.383Z" }, + { url = "https://files.pythonhosted.org/packages/8d/dc/ca2ea10c22499e00d366a9252177ec9039b8d786c85fd28260d41ec2dda5/cython-3.3.1-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:5febfc8c52aced0cf9360e6f2304428a5fa0e66fd9aa7338d5c41f0ce26dd104", size = 3267528, upload-time = "2026-11-01T20:13:18.074Z" }, + { url = "https://files.pythonhosted.org/packages/66/89/b2fdb92a7ccedff602f362bdf3fe38d67016de8c6655bc60bffce98b923a/cython-3.3.1-cp39-abi3-win32.whl", hash = "sha256:b0265a0e186af3c38339c561507e98e2e3a0d377cdb2b0427f980138ceddd4af", size = 2590014, upload-time = "2026-11-01T20:13:19.925Z" }, + { url = "https://files.pythonhosted.org/packages/9f/d8/3d620697d89110b58937b1297dfdafbbfec4415b11b845b46ec9a04b52b5/cython-3.3.1-cp39-abi3-win_arm64.whl", hash = "sha256:8b4391d39260efedeff2e3914e958b9ed75cb2b40f10b62bb0e9ca002658563a", size = 2693762, upload-time = "2026-11-01T20:13:21.506Z" }, + { url = "https://files.pythonhosted.org/packages/9d/55/088578d75bc8dbcbc535af04b1d596ff227ca756dd74f9d3c1c526f955d0/cython-3.3.1-py3-none-any.whl", hash = "sha256:61abc7feedd20dac6c4ff7ab3a30e17136a067b242ab9253e2b4a6d9a72c2b61", size = 1352000, upload-time = "2026-11-01T20:12:01.888Z" }, +] + +[[package]] +name = "distlib" +version = "0.4.4" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/68/bc/d36966de7304047a1001a7559fbf266c464bb5d8cc85464536ef8c9bcc32/distlib-0.4.4.tar.gz", hash = "sha256:ca4175b4ac7f71223cc30ed7248c45d2b38c2439d8ee6e498ab67ed63cf3508d", size = 621304, upload-time = "2026-10-16T13:56:34.203Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c1/2b/238f02a4927fa2e27aa995371d240a468b52e42eae44a678434aff736b38/distlib-0.4.4-py2.py3-none-any.whl", hash = "sha256:cf09d55b1e85a89576b036aeb71550bfd68320f3f21761ca329eadadad918638", size = 472099, upload-time = "2026-10-16T13:56:32.053Z" }, +] + +[[package]] +name = "docutils" +version = "0.23" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/39/a4/5180d9afc57e8fca05601dd652bdff19604c218814037fe90ffc7625a50a/docutils-0.23.tar.gz", hash = "sha256:746f5060322511280a1e50eb76846ed6bf2342984b2ac04dc42caa1a8d78799e", size = 2303823, upload-time = "2026-05-27T17:41:06.934Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/32/91/30151a39f7570f448ed84529390628a651d7f27c87d73c9b887f8189695e/docutils-0.23-py3-none-any.whl", hash = "sha256:25d013af9bf23bc1c7b2b093dff4208166c53a94786c9e447808335ef1185fea", size = 634701, upload-time = "2026-05-27T17:40:58.442Z" }, +] + +[[package]] +name = "filelock" +version = "4.2.8" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/c8/51/6619729344deb33a55ead1fbf50ac6435f43e33d6d57e56acd1495b24233/filelock-4.2.8.tar.gz", hash = "sha256:23df640ac0c3351f8d15c9739072d63be9078758b7d102a2183277ceb96605a3", size = 662554, upload-time = "2026-11-04T07:46:45.354Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d2/ee/69ac34614c54831e0c4d34b92554d4df5b7ae71173d308040d44c432351f/filelock-4.2.8-py3-none-any.whl", hash = "sha256:c2be657e2c279cb032af8e4ea8ce2e20aa982e540be77fcaa34910d068ac2510", size = 164577, upload-time = "2026-11-04T07:46:43.907Z" }, +] + +[[package]] +name = "id" +version = "1.6.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "urllib3" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/6d/04/c2156091427636080787aac190019dc64096e56a23b7364d3c1764ee3a06/id-1.6.1.tar.gz", hash = "sha256:d0732d624fb46fd4e7bc4e5152f00214450953b9e772c182c1c22964def1a069", size = 18088, upload-time = "2026-02-04T16:19:41.26Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/42/77/de194443bf38daed9452139e960c632b0ef9f9a5dd9ce605fdf18ca9f1b1/id-1.6.1-py3-none-any.whl", hash = "sha256:f5ec41ed2629a508f5d0988eda142e190c9c6da971100612c4de9ad9f9b237ca", size = 14689, upload-time = "2026-02-04T16:19:40.051Z" }, +] + +[[package]] +name = "identify" +version = "2.6.20" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/53/35/d70c0006c7cee65999ea94a6273e60b2094f600a3d8b71b04318253fc643/identify-2.6.20.tar.gz", hash = "sha256:ad729860a923858d26917c2f4fb0a1d83d27a75b1e090c06440c573f048f3285", size = 99681, upload-time = "2026-09-26T20:29:07.187Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/fa/70/fffc9613501877c0a10a1ef73a165e6ded3e53f6e7502227fef56d973933/identify-2.6.20-py2.py3-none-any.whl", hash = "sha256:6a16b69b93187244e0548cbfd25b3e4a6f9a7a2ad784625c3bec2b8d27b81aaa", size = 99506, upload-time = "2026-09-26T20:29:06.054Z" }, +] + +[[package]] +name = "idna" +version = "3.20" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f5/08/8eea9d4b8302028f3abb2c0813953f7aec26d33b7a8960ed760e65ff29fa/idna-3.20.tar.gz", hash = "sha256:a7db850025b95ded1eae8a46181a1a6c56c92c96f0e2b005d9ff8dc0210cab44", size = 216463, upload-time = "2026-09-17T14:11:04.752Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/58/a2/bb081bab032533a855d44de1d56f8e8426114ff1ba5d1f07a438a0a654f8/idna-3.20-py3-none-any.whl", hash = "sha256:ab7ae7122974553370f0bdb919e1a960b2cd1bc1ef0276416d896db81c14582c", size = 69583, upload-time = "2026-09-17T14:11:03.168Z" }, +] + +[[package]] +name = "importlib-metadata" +version = "10.1.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "zipp" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/98/f6/4eda8458eb00ec03e715c376c6b23b3def69687924c68d36d1c4003d3bc4/importlib_metadata-10.1.0.tar.gz", hash = "sha256:82b04047fa09792c1a8cfeddfe08bec79e4b13c29c8469b0d3949860f61017e8", size = 67761, upload-time = "2026-10-24T00:01:44.856Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/65/b6/495438ad95e0102aff8f6786b5474202f38cd5d4700d03a72b77977dec10/importlib_metadata-10.1.0-py3-none-any.whl", hash = "sha256:cf45ce66a929c64e994185a809c04840d0501db17e663810d993d0f4829265c7", size = 32221, upload-time = "2026-10-24T00:01:43.507Z" }, +] + +[[package]] +name = "iniconfig" +version = "2.3.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/01/e1/2069291243c926a2ff1cd706c7f3eeb9b62144bf60f77c9fb9ff2fb26bd3/iniconfig-2.3.1.tar.gz", hash = "sha256:67f4b9c50da0dedf52af349e7749a80a9057a5031199791b906c3bb3ae878960", size = 21209, upload-time = "2026-10-06T22:48:38.076Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/56/43/4ca9e49d27a1fcf6bece6f6aec0ea46bb9112489b93d4b688fb415457bdb/iniconfig-2.3.1-py3-none-any.whl", hash = "sha256:9121e2c1fdb355232495be3194c8dfe87ccc2d5dee45947b78e68f499790d7a7", size = 7552, upload-time = "2026-10-06T22:48:36.959Z" }, +] + +[[package]] +name = "jaraco-classes" +version = "3.4.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "more-itertools" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/06/c0/ed4a27bc5571b99e3cff68f8a9fa5b56ff7df1c2251cc715a652ddd26402/jaraco.classes-3.4.0.tar.gz", hash = "sha256:47a024b51d0239c0dd8c8540c6c7f484be3b8fcf0b2d85c13825780d3b3f3acd", size = 11780, upload-time = "2024-03-31T07:27:36.643Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7f/66/b15ce62552d84bbfcec9a4873ab79d993a1dd4edb922cbfccae192bd5b5f/jaraco.classes-3.4.0-py3-none-any.whl", hash = "sha256:f662826b6bed8cace05e7ff873ce0f9283b5c924470fe664fff1c2f00f581790", size = 6777, upload-time = "2024-03-31T07:27:34.792Z" }, +] + +[[package]] +name = "jaraco-context" +version = "6.1.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "backports-tarfile", marker = "python_full_version < '3.12'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/af/50/4763cd07e722bb6285316d390a164bc7e479db9d90daa769f22578f698b4/jaraco_context-6.1.2.tar.gz", hash = "sha256:f1a6c9d391e661cc5b8d39861ff077a7dc24dc23833ccee564b234b81c82dfe3", size = 16801, upload-time = "2026-03-20T22:13:33.922Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f2/58/bc8954bda5fcda97bd7c19be11b85f91973d67a706ed4a3aec33e7de22db/jaraco_context-6.1.2-py3-none-any.whl", hash = "sha256:bf8150b79a2d5d91ae48629d8b427a8f7ba0e1097dd6202a9059f29a36379535", size = 7871, upload-time = "2026-03-20T22:13:32.808Z" }, +] + +[[package]] +name = "jaraco-functools" +version = "4.6.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "more-itertools" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/6c/1f/c23395957d41ccf27c4e535c3d334c4051e5395b3752057ba4cbaec35c56/jaraco_functools-4.6.0.tar.gz", hash = "sha256:880c577ec9720b3a052d5bc611fb9f2269b3d87902ef42440df443b88e443280", size = 20837, upload-time = "2026-07-14T01:28:02.544Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/02/36/ecc85bc96c273dc8a11273ed4782272975e6338d4a3e9228621175edf0e3/jaraco_functools-4.6.0-py3-none-any.whl", hash = "sha256:99e3dc0060c5cbe8fcd1cdb36258e2a65ca40f1566b2033b12abb1bb44dd3c30", size = 11677, upload-time = "2026-07-14T01:28:01.59Z" }, +] + +[[package]] +name = "jeepney" +version = "0.9.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/7b/6f/357efd7602486741aa73ffc0617fb310a29b588ed0fd69c2399acbb85b0c/jeepney-0.9.0.tar.gz", hash = "sha256:cf0e9e845622b81e4a28df94c40345400256ec608d0e55bb8a3feaa9163f5732", size = 106758, upload-time = "2025-02-27T18:51:01.684Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b2/a3/e137168c9c44d18eff0376253da9f1e9234d0239e0ee230d2fee6cea8e55/jeepney-0.9.0-py3-none-any.whl", hash = "sha256:97e5714520c16fc0a45695e5365a2e11b81ea79bba796e26f9f1d178cb182683", size = 49010, upload-time = "2025-02-27T18:51:00.104Z" }, +] + +[[package]] +name = "keyring" +version = "25.7.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "importlib-metadata", marker = "python_full_version < '3.12'" }, + { name = "jaraco-classes" }, + { name = "jaraco-context" }, + { name = "jaraco-functools" }, + { name = "jeepney", marker = "sys_platform == 'linux'" }, + { name = "pywin32-ctypes", marker = "sys_platform == 'win32'" }, + { name = "secretstorage", marker = "sys_platform == 'linux'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/43/4b/674af6ef2f97d56f0ab5153bf0bfa28ccb6c3ed4d1babf4305449668807b/keyring-25.7.0.tar.gz", hash = "sha256:fe01bd85eb3f8fb3dd0405defdeac9a5b4f6f0439edbb3149577f244a2e8245b", size = 63516, upload-time = "2025-11-16T16:26:09.482Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/81/db/e655086b7f3a705df045bf0933bdd9c2f79bb3c97bfef1384598bb79a217/keyring-25.7.0-py3-none-any.whl", hash = "sha256:be4a0b195f149690c166e850609a477c532ddbfbaed96a404d4e43f8d5e2689f", size = 39160, upload-time = "2025-11-16T16:26:08.402Z" }, +] + +[[package]] +name = "librt" +version = "0.16.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/04/f5/9dc696772d241814bacac7880bac32f2930b5a6ebc1f85317b83161a011c/librt-0.16.0.tar.gz", hash = "sha256:ac38d6d8d66bf3d744148dbbc0b8e193e195a51e364ed55e224631f5721891fc", size = 219839, upload-time = "2026-09-29T00:55:32.891Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ba/0e/b04fd2d76b6a78a02286938251b2c119fb36ddece92c76cb4886ef7d44b8/librt-0.16.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:fe4372c52d4849096c6cc1cda2817d293ec51440c890474ed59ef38d46556f18", size = 148058, upload-time = "2026-09-29T00:44:40.903Z" }, + { url = "https://files.pythonhosted.org/packages/a3/fc/e1ed24aadb32d38603c0c07f579d739eb4d90e64e90d525b024e4a999b4d/librt-0.16.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:c72c5295a84bd249526da9bdca38f2e176d15c31c13bb0063c5053f4ca023421", size = 153073, upload-time = "2026-09-29T00:44:42.165Z" }, + { url = "https://files.pythonhosted.org/packages/be/38/133ab655409420e0c34a9a9836a7f4e5ae75fba758d7fe177099130d58ba/librt-0.16.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:be56ba9c884143495b517f23fe794ae367d58cd89ea0fdd6d437e3c024a87f9f", size = 493052, upload-time = "2026-09-29T00:44:44.043Z" }, + { url = "https://files.pythonhosted.org/packages/94/42/aaa663bc9421f5bf7bbbe9d3316d7219749698ec7688ac3b519770a89c04/librt-0.16.0-cp311-cp311-manylinux2014_i686.manylinux_2_17_i686.manylinux_2_28_i686.whl", hash = "sha256:ef46c1a29ffb8c72e882e22618ec618778eacd0578fb22c6e7cf9c11d15f357b", size = 485506, upload-time = "2026-09-29T00:44:45.479Z" }, + { url = "https://files.pythonhosted.org/packages/7b/59/83a6eb5087ba8b45b083859e2085256963e06d4c2531944cdd962670bfb5/librt-0.16.0-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:d3c94211ee0c4f8d649ec06b7c115c0ec4eadb873a0e3154ca15cef3f814b071", size = 498708, upload-time = "2026-09-29T00:44:46.916Z" }, + { url = "https://files.pythonhosted.org/packages/a0/e4/15a8d62b2bc12935080ec7277e2e0b9b233047781eb784a51d3e25af669a/librt-0.16.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:94aed6a8308818b91677957d1bd03188869cd7aeb23c5dba7912a6c0402f7602", size = 515981, upload-time = "2026-09-29T00:44:48.316Z" }, + { url = "https://files.pythonhosted.org/packages/46/4f/287cc282ac5dd815204c0779e79401bb0a568c3a1335fb319bf0838fb566/librt-0.16.0-cp311-cp311-manylinux_2_34_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:349c0bcb87ebd07481b6ff781e25cdc699723dbe2212e57dabb27f7a13b7b87d", size = 508670, upload-time = "2026-09-29T00:44:49.726Z" }, + { url = "https://files.pythonhosted.org/packages/bf/5b/ab7292add898ade0d2b5b75d32a923aae315861671aa5c39f5491309f7ae/librt-0.16.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:001bfd59a7d45b17e3e75f2a8c6405280b35e7b84471792778e718c4f368950e", size = 530393, upload-time = "2026-09-29T00:44:51.356Z" }, + { url = "https://files.pythonhosted.org/packages/7a/9e/8e6bcf027d4bcbc16a4e864b3d158a1d3e5f55ffa53af0238020cad89271/librt-0.16.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:28e038895b998d7a0c7798922ce8a1dc157675df5cf1c9ef0aca809ed804b7a1", size = 534302, upload-time = "2026-09-29T00:44:52.893Z" }, + { url = "https://files.pythonhosted.org/packages/96/a4/8c5ab4f3b3a8e905ff8305d76976a2e666f52fe049edd398aed2402beb36/librt-0.16.0-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:0dbe4096a7ecc00fa835d24510ad8545a4efef738dac96e0e63516783ccde905", size = 536150, upload-time = "2026-09-29T00:44:54.421Z" }, + { url = "https://files.pythonhosted.org/packages/ea/5e/7c4bc267e3cd4b8bd288de9f62d61fff203829c9cc649ea2aa12e9218cf0/librt-0.16.0-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:5cd5b092441053364af968ea12084692cb9d4a22f3ce9524e377880bf028761e", size = 514316, upload-time = "2026-09-29T00:44:55.998Z" }, + { url = "https://files.pythonhosted.org/packages/e0/75/c8bc6b50f43c73819334233f5a3259c81216742cef56d2140c3dd377c3f0/librt-0.16.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:3ddeb3c9dedb461bb457c6c7d9aa7fbf35329da313d1a7543d00c8d0f3473c96", size = 557731, upload-time = "2026-09-29T00:44:57.581Z" }, + { url = "https://files.pythonhosted.org/packages/93/fb/e241f91bc8de6c7ac1c6a20ea6dd381bc52312b44d711ffcd97140db1e57/librt-0.16.0-cp311-cp311-win32.whl", hash = "sha256:e05108e0849966f53a8d2d3112a7af881d0efaa479bc735bba91108f9f2350a7", size = 104922, upload-time = "2026-09-29T00:44:59.078Z" }, + { url = "https://files.pythonhosted.org/packages/d1/38/c892383d2bb1a6a80b2ec8ede84970a265a792c56614a06282bf3008517c/librt-0.16.0-cp311-cp311-win_amd64.whl", hash = "sha256:5f49cff01bd608ef7d97104cb035c75455e79c2d70bf4a506cf773338ac1860d", size = 125093, upload-time = "2026-09-29T00:49:01.621Z" }, + { url = "https://files.pythonhosted.org/packages/e4/56/8bbde1ed0b21480163617648f638fdaec9374cf5e9c846ebcee34ec02a42/librt-0.16.0-cp311-cp311-win_arm64.whl", hash = "sha256:1d28ae980ae2218f9c5b95d191e947296f918c9bf0b400d467a9430275bbe678", size = 115910, upload-time = "2026-09-29T00:52:40.131Z" }, + { url = "https://files.pythonhosted.org/packages/ad/76/bbdaeb87b7c47b5c7343e90222b9bfa4e4a8a83f647e02933ad0129225b1/librt-0.16.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:fe52bf4641069e7978a14253b036cb9002def1926317e710f2e249f8a8c47742", size = 151028, upload-time = "2026-09-29T00:52:41.508Z" }, + { url = "https://files.pythonhosted.org/packages/fd/0c/ab8ed3dab0085931aec4a792c7eaac8dc6c5ff4691fda3a5360d9d8a9cd2/librt-0.16.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:5bcc2c4726ced915b00de0c9856a4eeabfb3fddb93e10e0b8f735b7709358b6d", size = 155283, upload-time = "2026-09-29T00:52:42.873Z" }, + { url = "https://files.pythonhosted.org/packages/eb/36/494e79d460c80c1f030661e8287c9eca5e1ad652dc2b2180b6cd42abce0a/librt-0.16.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ff7baa55f8e7c69851419e50a666015d02a74198716fd45c0125a2112e0a389f", size = 503185, upload-time = "2026-09-29T00:52:44.638Z" }, + { url = "https://files.pythonhosted.org/packages/9b/34/a8464038dd9db6e4381fa2b6eb73dc9a50888d77102c4c139304ac35cddc/librt-0.16.0-cp312-cp312-manylinux2014_i686.manylinux_2_17_i686.manylinux_2_28_i686.whl", hash = "sha256:b95d5d92ab83d39e760a52091bb1baba664f3a2351e39b1e16801e5747c2f0e9", size = 496738, upload-time = "2026-09-29T00:52:46.441Z" }, + { url = "https://files.pythonhosted.org/packages/6a/53/e0e5e334ef0c6ed27039d323819368b9ef6712be87d55ee2bf9799398afd/librt-0.16.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:b6d085d70bce51d43c5c7c36d63490770180d8779e71c49305c87b4213918de7", size = 513818, upload-time = "2026-09-29T00:52:48.068Z" }, + { url = "https://files.pythonhosted.org/packages/ad/f7/7ce72cbf19d0addd05090b339152fd0548a02562c2866a603e6e3b3da2df/librt-0.16.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:36e53948e99bbe3ffea257124cfcae1cfb01831555c9a9c903c9f9a72db7fd07", size = 531952, upload-time = "2026-09-29T00:52:49.816Z" }, + { url = "https://files.pythonhosted.org/packages/83/22/0b1bcb6a8e723c8b4fd60dfc8ae8ec6461c54073fbc8685efeb8d900d407/librt-0.16.0-cp312-cp312-manylinux_2_34_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:54d11f726aae9df5a6ffbbf0a03a52449bbac84a53ef03669cb41cdfd4ae41bf", size = 524465, upload-time = "2026-09-29T00:52:51.354Z" }, + { url = "https://files.pythonhosted.org/packages/64/2e/e9c23b8b9df1813da1be205deca9606beb7ddd033972246cd426d05374a0/librt-0.16.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:4323193ac0cd025f85af531df8ba91bf24d1973b401697347a6282e8fd3fcf5e", size = 543191, upload-time = "2026-09-29T00:52:53.284Z" }, + { url = "https://files.pythonhosted.org/packages/bc/e5/6a8b21b342c03ed7e230fa3afbfd2edc58e6e87ef1f0d11fa2b9a748c252/librt-0.16.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:e42f8e098b9c5396fefa05fb1cc7e33b0e08fc51da106b5de4a45fd22aac6743", size = 546979, upload-time = "2026-09-29T00:52:54.932Z" }, + { url = "https://files.pythonhosted.org/packages/84/9e/b5129023eced1be01e01c22757f53be551d463b1bb7264f787927404c1d6/librt-0.16.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:39ec1d5a14e37baf1450a6cabf03fe552340808bf1ad9d71824ab90117716459", size = 555317, upload-time = "2026-09-29T00:52:56.869Z" }, + { url = "https://files.pythonhosted.org/packages/71/89/28bba5938c725fe91f06bf93f7fa6c6b150229df53a87b454b0d5c2a796e/librt-0.16.0-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:d1aabe3925cbb4a08d15b7b20ba4011b53019da0c4173a25155139b7b1baed65", size = 535846, upload-time = "2026-09-29T00:52:58.475Z" }, + { url = "https://files.pythonhosted.org/packages/22/92/63773026614f888c5d4e370e395ce42ca604b89f70b3acdfedbf94851b80/librt-0.16.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:300c3ffdc459f4a779a8411ecb188e3ac0b1ff3a3a7b099642555dedae06c69b", size = 573700, upload-time = "2026-09-29T00:53:00.127Z" }, + { url = "https://files.pythonhosted.org/packages/66/8f/347d4677eefb57cd9f8e01d95a1dcee9a91b4e44e664173c32ff6f3752e5/librt-0.16.0-cp312-cp312-win32.whl", hash = "sha256:c17194318e4c0c0348b36f36c2ec7534436fe0a4c15582403162a4f08c80797a", size = 106158, upload-time = "2026-09-29T00:53:02.031Z" }, + { url = "https://files.pythonhosted.org/packages/f0/2c/5193dc81127cd5ddfad031391b046bf32dda219b38463ab872407ca30646/librt-0.16.0-cp312-cp312-win_amd64.whl", hash = "sha256:25a58a19ea8d83b68209f04912df765e9260635ef77646542ed4b4abe6bc7940", size = 126176, upload-time = "2026-09-29T00:53:03.445Z" }, + { url = "https://files.pythonhosted.org/packages/ff/3d/9668a400c8dd81d162eba38b33fa49fa6205f1a64493570a13fbb815c3ee/librt-0.16.0-cp312-cp312-win_arm64.whl", hash = "sha256:f7be7cf555bc30ec12622e9447299cc4a9b8ff307548b634794353db0c2065dc", size = 116572, upload-time = "2026-09-29T00:53:04.815Z" }, + { url = "https://files.pythonhosted.org/packages/46/cd/ae5e0e9dba45d1399aa04a5395bcc0bead40d9fa06dc903634a7b4d7473d/librt-0.16.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:c5e6144e68b577f157519f2ba88ca20e3ed61c29b00e5cdfa76cd2d45acf059a", size = 151036, upload-time = "2026-09-29T00:53:06.284Z" }, + { url = "https://files.pythonhosted.org/packages/41/5a/48a16e323c5f9447a94cce7b59babf60fa04e62c3365ecf060c77ed8b320/librt-0.16.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:33f41443a1f4e1f099331b3d8120e409fbff84b9760bc1cc9ea496f37ddaa5cc", size = 155211, upload-time = "2026-09-29T00:53:07.72Z" }, + { url = "https://files.pythonhosted.org/packages/3f/29/0f59299eb4251a409b2e690ad4b7d9f8a676db829d7817ec961f32b44f7e/librt-0.16.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7e510b7770bee609617a3374a96548eb114cae048023e3f049ee449e7ff2db32", size = 502587, upload-time = "2026-09-29T00:53:09.191Z" }, + { url = "https://files.pythonhosted.org/packages/de/ba/d6fb4ef8d1537c396079d72289f16be7cd35a366e5065c51253fea2760b6/librt-0.16.0-cp313-cp313-manylinux2014_i686.manylinux_2_17_i686.manylinux_2_28_i686.whl", hash = "sha256:efc49c462d4516b8a58b00b490078fa64689fd1fe66970cc190131d7afb8027e", size = 496146, upload-time = "2026-09-29T00:53:11.016Z" }, + { url = "https://files.pythonhosted.org/packages/52/fc/8c50dd4d7cc97c0ee8f252c8a3104980f234391cf1519b554e8b9de08b60/librt-0.16.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:92caf82ebef5e12d21c72242b70d1e92536f1711cf2a727a4c276de4b4469087", size = 513336, upload-time = "2026-09-29T00:53:12.655Z" }, + { url = "https://files.pythonhosted.org/packages/a9/59/16c409c56f708eda2db9a0553662845d45e3871c77d70a240dae3f3bdc56/librt-0.16.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:17bac7f7a16b328fff77e440287693eb017abde913595b5827ebccbc21ecd8a6", size = 531689, upload-time = "2026-09-29T00:53:14.39Z" }, + { url = "https://files.pythonhosted.org/packages/88/82/d34772a6c29d1446dcca6e64d74062efd508523ab351aa16625a4689d5cc/librt-0.16.0-cp313-cp313-manylinux_2_34_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:5b976054553670829985ed767feb78fb6bcede0175327c4844dd5c281c1be659", size = 524537, upload-time = "2026-09-29T00:53:16.064Z" }, + { url = "https://files.pythonhosted.org/packages/77/8f/24c5631313746131ccee53bc91fdc8374f9cf25e0082a1fee9c93bb98acc/librt-0.16.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:0058f9d68721094105917254c72ac0569117bb7b13b9769cf45d26d89f9d21cd", size = 543231, upload-time = "2026-09-29T00:53:17.939Z" }, + { url = "https://files.pythonhosted.org/packages/f2/cb/5f8e0d41dbd8b499c2265e939c31acc9ba59845565bf99539ad1c06aebcf/librt-0.16.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:30b7beaf3f4487b7d8adef1f158b49067cb4d5a19fa7a3bf31a4e7a820e435c5", size = 546499, upload-time = "2026-09-29T00:53:19.666Z" }, + { url = "https://files.pythonhosted.org/packages/be/61/063052de441d1385f59cea4223f184bf9e5d125de1ae3239b490aa1e486e/librt-0.16.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:468df902df016a06eb0e40b0747dc8d14e47d7a38b18b63b1fb167d85cb94d63", size = 555261, upload-time = "2026-09-29T00:53:21.292Z" }, + { url = "https://files.pythonhosted.org/packages/14/11/a2ada0529372268d6401afa9d457a095b68cd7753532b6f7f33049a19b43/librt-0.16.0-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:aea7b1f2b125dad5de85f049136651bff256c883c65e6b9209b2da0a1ac3cdef", size = 536029, upload-time = "2026-09-29T00:53:23.07Z" }, + { url = "https://files.pythonhosted.org/packages/23/9d/5bb6d38853382986dca702fc7e06c8256d30f5fa0676d882773b744610dc/librt-0.16.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:a8afb6557920860b7a3a596eb804cf37e09e7cf8a803db2478c202acc72d8c2e", size = 573748, upload-time = "2026-09-29T00:53:24.696Z" }, + { url = "https://files.pythonhosted.org/packages/99/f6/0025cde35ff7f607684dc775a2b2d732cce2561cec050a6ee1fb2e1fc6fe/librt-0.16.0-cp313-cp313-pyemscripten_2025_0_wasm32.whl", hash = "sha256:77c7a2b4fe2c1369e0d5aa1cade26740a7b14be32fbc9a5535d617d20065c39d", size = 79861, upload-time = "2026-09-29T00:53:26.089Z" }, + { url = "https://files.pythonhosted.org/packages/93/93/303b8592909bd583f83f02818ffbea3f7647ca1e22b1cd5465d04b8145fe/librt-0.16.0-cp313-cp313-win32.whl", hash = "sha256:02d89c813d5ff74b17df72d3a34819d132cd168e56b81bf755b809bd9e46b8c4", size = 106236, upload-time = "2026-09-29T00:53:27.43Z" }, + { url = "https://files.pythonhosted.org/packages/cf/24/80bbb463c60ed18e29cb26aba386ddb76609580e4e7160710e550587018c/librt-0.16.0-cp313-cp313-win_amd64.whl", hash = "sha256:14ed6ebe3e4f85f326d7920011ad30ff49ed9334e62cf88caef9ba973d9e3a92", size = 126180, upload-time = "2026-09-29T00:53:28.7Z" }, + { url = "https://files.pythonhosted.org/packages/43/80/b1a6fbdd7da825cdd55c71aa81eb6cfa82c513c360774152eacb50b4a771/librt-0.16.0-cp313-cp313-win_arm64.whl", hash = "sha256:83d4041a3d9b2fd053a8a4e1f22878b3e5833e2712956382d5c048d791454e91", size = 116557, upload-time = "2026-09-29T00:53:30.012Z" }, + { url = "https://files.pythonhosted.org/packages/1e/93/9e0cf7da129a93c3dc7f45bc3cd4a660f2aaa995aa8a6f95c2583ef41239/librt-0.16.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:931a0bb0fcac88f263e269e46eb30ba8e21402cd3c62ca40cb97034c0693fab1", size = 149844, upload-time = "2026-09-29T00:53:31.391Z" }, + { url = "https://files.pythonhosted.org/packages/8f/26/8a90d2a8f2b2e471bb486b7aec117b8ae622715ed6c39853aec48ea20073/librt-0.16.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:1bc17e54e5305f8d40b7ca203671ff5a9e59c1d0f8ea0f625dcca53a3984de11", size = 154111, upload-time = "2026-09-29T00:53:32.718Z" }, + { url = "https://files.pythonhosted.org/packages/35/ce/67abb46258da4d3e42ff5b141db6f38c59357bef84c7979f183b22f924f1/librt-0.16.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:877698bf6bca5721d8be345f2fe09778e40ecadea8b58c73075f2b1a53666bf2", size = 494234, upload-time = "2026-09-29T00:53:34.466Z" }, + { url = "https://files.pythonhosted.org/packages/12/f9/ea7162414a16f8f1bbd3b493ad6d22b926c5471916e078350bdbca8c4e5f/librt-0.16.0-cp314-cp314-manylinux2014_i686.manylinux_2_17_i686.manylinux_2_28_i686.whl", hash = "sha256:5981c011b306781ce561e18e14230a14524a3d8109b97553666c942c18f31a96", size = 491173, upload-time = "2026-09-29T00:53:36.124Z" }, + { url = "https://files.pythonhosted.org/packages/b1/09/9b3e869060dd33f9989b80ba4fea306f6db8cecefcdfe6d7346ef0603f65/librt-0.16.0-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:afced3dfc17cd805ecf7a3d77996a71cf5f2c75aa66eb0c21a9930f4fc992f86", size = 505547, upload-time = "2026-09-29T00:53:37.686Z" }, + { url = "https://files.pythonhosted.org/packages/50/07/79007d2165f649ea93e08c0962d1d62c70af9cde77965255095bf9d96f9a/librt-0.16.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ca8052401c55d7511dda6760719fda7618067e83535d7d0010096d216c34b667", size = 523057, upload-time = "2026-09-29T00:53:39.301Z" }, + { url = "https://files.pythonhosted.org/packages/61/0c/8fbaff66d0ba376d8864653f5acce1569bae27e89648671f26f7eca67ab8/librt-0.16.0-cp314-cp314-manylinux_2_34_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:1e511762a074005bb0aa569166779834e75e438370226930d0ce1866d4b6a33b", size = 515158, upload-time = "2026-09-29T00:53:41.012Z" }, + { url = "https://files.pythonhosted.org/packages/df/2e/23ff0dece76f07a4124413a57682efa0bbeb5765ac0122bc0955513f82ca/librt-0.16.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:f1e8591bd8a5a628cd7f07954c6a1592359a878bf032957a8e9057a41d644311", size = 534183, upload-time = "2026-09-29T00:53:42.451Z" }, + { url = "https://files.pythonhosted.org/packages/26/c4/e11dea21d9a29486eba78887380374189d472734fa32cc50cb37ca44d3d0/librt-0.16.0-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:a4aaefb4ba6c07e1aeebb2795c8958148f1d6f9af3b555b53d23d766edb6d67a", size = 540663, upload-time = "2026-09-29T00:53:44.272Z" }, + { url = "https://files.pythonhosted.org/packages/44/75/e873ae158a8b7f5359be33e7fd6c1fbe02d9a78a3e89a77de6b0e837f476/librt-0.16.0-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:d92db7a0f6aee44f1baee94750457e8d2d1c6ccea41842de6268d34e8dc7eddd", size = 545908, upload-time = "2026-09-29T00:53:45.812Z" }, + { url = "https://files.pythonhosted.org/packages/ba/36/8939d3f6a93e11bd9592e6fe28d2b44f1c2dc4bed6e22e72359a91e18ffb/librt-0.16.0-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:378dfaffb38e59c24a87cde5713cd865d51ff7383fa12947f3907f306ea1ca55", size = 523302, upload-time = "2026-09-29T00:53:47.596Z" }, + { url = "https://files.pythonhosted.org/packages/71/14/35309f44a077f0f42ade0e2e7cd88c0cea760c661af205c01ea90d3c0e1f/librt-0.16.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:3e0c39bdc85370422e8b637be76eb1fd07d30967551b03e62267dd156f553152", size = 565911, upload-time = "2026-09-29T00:53:49.278Z" }, + { url = "https://files.pythonhosted.org/packages/78/0c/df6255b94967f3159ebc46f08d8e783c12da6ee269ddb74b2efed63c640c/librt-0.16.0-cp314-cp314-pyemscripten_2026_0_wasm32.whl", hash = "sha256:1b384b90ab79a7bc30b566895809a636e0666f21f3cf12b54823d025b7e83839", size = 79119, upload-time = "2026-09-29T00:53:50.938Z" }, + { url = "https://files.pythonhosted.org/packages/6b/44/d30d5a5461378c9d33f36736c6791c3b4c4ba4b1ffe0da7350aedcb2c9a0/librt-0.16.0-cp314-cp314-win32.whl", hash = "sha256:52327da75a94012e7f932f913d20d3876bed3c102be00e6c3e8600ff7bdd58a7", size = 100140, upload-time = "2026-09-29T00:53:52.205Z" }, + { url = "https://files.pythonhosted.org/packages/c2/98/769712f356a1e897df3581bb0c3100375d054a000de26099360ea65b5111/librt-0.16.0-cp314-cp314-win_amd64.whl", hash = "sha256:3f0b8114c44b2ac06ff5dacd08e07e8e807ff4f46083f2a1602685122559be41", size = 120464, upload-time = "2026-09-29T00:53:53.495Z" }, + { url = "https://files.pythonhosted.org/packages/bf/d3/ae2abccc8bdc8b063c1613a77686e17b74e9d3d60cfe6f12c63fa2821b9f/librt-0.16.0-cp314-cp314-win_arm64.whl", hash = "sha256:8caf96a4ef8fb27d0ac0d1ad8337d26a240acd4a02fe4345d0a8f264753e8f99", size = 110889, upload-time = "2026-09-29T00:53:54.817Z" }, + { url = "https://files.pythonhosted.org/packages/e4/26/0737d4be058dd6376eade7dd8b380d4b869b6394cee929393a5a431c45bb/librt-0.16.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:953107e2f68d0f3512c48f898b0dbf0ce5cc52bba0f318d847c985dc555ee4cc", size = 159838, upload-time = "2026-09-29T00:53:56.22Z" }, + { url = "https://files.pythonhosted.org/packages/01/96/9bc96531d7c620e9949af904470f02e3fa8f35129ab8e8f281c51eaa3788/librt-0.16.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:ad37d5b9abd49c9a655dcda7ea52a8a752884062ef1ee71ae17c2f2a0f81fe6a", size = 162018, upload-time = "2026-09-29T00:53:57.532Z" }, + { url = "https://files.pythonhosted.org/packages/0e/fa/b0289dcb186eb3f97221ba00da5f4bd3ba7fa5e99752d48aa8d336615334/librt-0.16.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2c4aa329c17bd1aaea4f6e89335d8ccd494b3a5830b6654462273e50e11023f0", size = 703983, upload-time = "2026-09-29T00:53:59.024Z" }, + { url = "https://files.pythonhosted.org/packages/d9/ab/05ebbbde7530fc5eeb58fbd1581522a9f64f132fa703c4c595eed6e14760/librt-0.16.0-cp314-cp314t-manylinux2014_i686.manylinux_2_17_i686.manylinux_2_28_i686.whl", hash = "sha256:0ead24d2562a49473dddd9efef8581f020007eb0054389c3ee3ffad38b1ca4c9", size = 683847, upload-time = "2026-09-29T00:54:00.671Z" }, + { url = "https://files.pythonhosted.org/packages/a3/75/f52aeecd4dbadbddf80725ba7de126d8bd5d0eb66247eae17a81ed90dd4d/librt-0.16.0-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:02118f56a9c36ddd07dfd9b919d9ecc117ba20a90987d56aa4c429fa34509188", size = 698045, upload-time = "2026-09-29T00:54:02.247Z" }, + { url = "https://files.pythonhosted.org/packages/e6/55/fa277a835cd6eb42380591ceb85f48c5b4d2b2d7e2cb9869e1e17d24d237/librt-0.16.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4e29522c62e28595ff7e324c6834ade51127707f0e255b18d1c1cf03d39c1048", size = 724640, upload-time = "2026-09-29T00:54:04.078Z" }, + { url = "https://files.pythonhosted.org/packages/25/e4/2cf64354f3fde8ebd591b3b48f96510bee24ac5f7d1e567adbbe210abdbd/librt-0.16.0-cp314-cp314t-manylinux_2_34_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:3ff4b2367926b69c6215635902cccb04048e73094e9862900d27cb2c6bbff143", size = 731748, upload-time = "2026-09-29T00:54:05.741Z" }, + { url = "https://files.pythonhosted.org/packages/f8/c9/c180af3e94e01aa529fa93d7733fec2abc47f222345400cf21d5481d5f8a/librt-0.16.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:c6f1b27bf1632a7e016af9f145f82be95e1edd7721a646505c21059257cb5a04", size = 754960, upload-time = "2026-09-29T00:54:07.38Z" }, + { url = "https://files.pythonhosted.org/packages/95/d6/01073aa78c58f356b10d9c57b3fe9abb143df338142bcd316df417b89db0/librt-0.16.0-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:5696d7f52e7b37217cb3a8f92c744fe835942602fdd4c1a8bc4741d3bfdce15e", size = 747000, upload-time = "2026-09-29T00:54:09.06Z" }, + { url = "https://files.pythonhosted.org/packages/f7/d8/1de3783908658d697a8cfc00582f61299ffba7796d7260c112e4700b1109/librt-0.16.0-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:6072e92dd876ff6ceeb6cf371e35e51f479349837391341f479b08df4564242b", size = 749569, upload-time = "2026-09-29T00:54:10.702Z" }, + { url = "https://files.pythonhosted.org/packages/b7/32/e817f66c96d6caa8bb8435ff93c4c220624d59efc506be59ab98fcd01d0c/librt-0.16.0-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:39ca4f2f2fe05de8e63493da592d84311adabe5bef52b193851981da9816b302", size = 729483, upload-time = "2026-09-29T00:54:12.25Z" }, + { url = "https://files.pythonhosted.org/packages/7c/c9/23992ccd2b9d22798fdd0f61353183a47414e651da782ad83eb680f50833/librt-0.16.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:f9807485a908f00355820f18e91e045ffdcdc5adb68aaec40a1e2b88c5f7bba1", size = 776584, upload-time = "2026-09-29T00:54:13.837Z" }, + { url = "https://files.pythonhosted.org/packages/67/3b/e8af957f08e6e2e8e566b099e43d2748418aa565df6ee1d9d3331209fdfe/librt-0.16.0-cp314-cp314t-win32.whl", hash = "sha256:94be5cb7bca4df6201f4183e9e4fa2086c655283d20b38cd84500a69057575a7", size = 104402, upload-time = "2026-09-29T00:54:15.568Z" }, + { url = "https://files.pythonhosted.org/packages/ca/1c/946e6443d7cd32347a086043395e421e52fd603c9163d2ec970ceab8eed6/librt-0.16.0-cp314-cp314t-win_amd64.whl", hash = "sha256:d46ca272b251d033dd4527b0dec5f261a28a52bd5fa0f99c117b0a1f8588cc2d", size = 126227, upload-time = "2026-09-29T00:54:17.165Z" }, + { url = "https://files.pythonhosted.org/packages/c2/a3/bc4f9959d3c62bcbf9e5fd3470a8bbd8bf33224ed4c25d7fba173201b8ac/librt-0.16.0-cp314-cp314t-win_arm64.whl", hash = "sha256:b9d6d4b14e92d876f8026b54c20c445f36425214c1081dc76f74e40db386b82b", size = 116493, upload-time = "2026-09-29T00:54:18.567Z" }, + { url = "https://files.pythonhosted.org/packages/b6/4b/10fdb42dfab4c1533e1570e686b18e86ff4328b406361b39fb3016667638/librt-0.16.0-cp315-cp315-macosx_10_15_x86_64.whl", hash = "sha256:6fe436af2eaf630474f491af5d032cbe45f93fcff5c3b9fe4ab194a7255b20ff", size = 149829, upload-time = "2026-09-29T00:54:19.933Z" }, + { url = "https://files.pythonhosted.org/packages/8e/30/a90ca13f1d3d91af1680000a4038536907018fbd51764767287a05d28b8b/librt-0.16.0-cp315-cp315-macosx_11_0_arm64.whl", hash = "sha256:8ff5d26c529336be9bd7ae04483235d77778ee7d6444a95353102b542601ce81", size = 154522, upload-time = "2026-09-29T00:54:21.306Z" }, + { url = "https://files.pythonhosted.org/packages/5c/dd/bcf364eacfa070bb1fc88d503111ae7177914197ba1fa717c748926e7930/librt-0.16.0-cp315-cp315-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:909d8e3c1faee44cb762b1c519ff8613dcc5ceae5c99987a00917b5a31fd1d6a", size = 497593, upload-time = "2026-09-29T00:54:22.798Z" }, + { url = "https://files.pythonhosted.org/packages/18/c1/2c4e81e347bdabfe8346bfc6dc37ae5e154d61c88e30848ec0606025a5e0/librt-0.16.0-cp315-cp315-manylinux2014_i686.manylinux_2_17_i686.manylinux_2_28_i686.whl", hash = "sha256:6d4a64283ee61824b5790de882bc68e2d9d7a5143537cb7a966f7354f71646d4", size = 480459, upload-time = "2026-09-29T00:54:24.364Z" }, + { url = "https://files.pythonhosted.org/packages/ab/d7/fef2a3cb8400701be496f6e459876f650b3451f407e30cb243de571ae615/librt-0.16.0-cp315-cp315-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:5810ba811297fdf37a1531a57667cb8ace0842013ca8606bf9eb7c24cf4be154", size = 507814, upload-time = "2026-09-29T00:54:25.997Z" }, + { url = "https://files.pythonhosted.org/packages/e1/6f/53762927a32e9dc9eb1d1c1f3528da281290c86d96929a8af652f671266e/librt-0.16.0-cp315-cp315-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e56aaf8c167548dc8e5d6f3bd0f48dcdd299a23c73be3f744aab79d99e9c7f5d", size = 525114, upload-time = "2026-09-29T00:54:27.747Z" }, + { url = "https://files.pythonhosted.org/packages/6c/67/0b9d031f303c4e8c691a9a8ef9d272f13b530c11cc563b819df621b6a348/librt-0.16.0-cp315-cp315-manylinux_2_34_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:8f36c58e33b304b525c6c9c5076399c6ebf1109e17b9051a05a407b091b9215b", size = 520465, upload-time = "2026-09-29T00:54:29.331Z" }, + { url = "https://files.pythonhosted.org/packages/ae/d5/2056a3a85864e882eb17a203a10ddb26fa748bc9718ec67e79059ab46cae/librt-0.16.0-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:242e00b3d4fa37c3d3c1ca5f5c9adb7d909ddb1eac9c41f2787320d00caa0af2", size = 537257, upload-time = "2026-09-29T00:54:30.915Z" }, + { url = "https://files.pythonhosted.org/packages/54/57/e0d79790c163cbc0909e209a6f62e30bb713b647f905a176cdc64848fd4d/librt-0.16.0-cp315-cp315-musllinux_1_2_i686.whl", hash = "sha256:0253721561787b8df8443eb347b7a6461015354e5bdd37ee38a41fef220d2bb0", size = 527442, upload-time = "2026-09-29T00:54:32.478Z" }, + { url = "https://files.pythonhosted.org/packages/aa/50/1c0c95aba7af51f4752ea34fbf2eb79b36e7cae3a72536248e8c735de735/librt-0.16.0-cp315-cp315-musllinux_1_2_ppc64le.whl", hash = "sha256:3e483a8d69ede8067db70c0e83007423b6925de6fd53afed01d66160f2e9398c", size = 548139, upload-time = "2026-09-29T00:54:34.183Z" }, + { url = "https://files.pythonhosted.org/packages/98/91/a8a43dd5138d4f55f88846b8f0c85454a4fad69952cebfcff9948f831290/librt-0.16.0-cp315-cp315-musllinux_1_2_riscv64.whl", hash = "sha256:69ba927445cfaaffb4081003ef5224c55a5c2ab67ef956f416ef744916e44121", size = 529708, upload-time = "2026-09-29T00:54:35.761Z" }, + { url = "https://files.pythonhosted.org/packages/2d/41/d5226881ab2b7c20d9d587b37bdd4a0ec8775a96d00ca87ac9f385587db4/librt-0.16.0-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:d6a365f2ab45a984d0e00eee0dd17f599ceab8cadab6ea07b6111c8132fc0e42", size = 567781, upload-time = "2026-09-29T00:54:37.409Z" }, + { url = "https://files.pythonhosted.org/packages/bb/bf/2345ba57a626e8c78c4ddcc724636a8df5a593fe46c1ee76bbf477e32b0d/librt-0.16.0-cp315-cp315-pyemscripten_2026_5_wasm32.whl", hash = "sha256:f01f3805f2dae4781c0c34b440e31740d082950bdaf89a6f601ad589a28af57a", size = 79177, upload-time = "2026-09-29T00:54:38.792Z" }, + { url = "https://files.pythonhosted.org/packages/1e/40/99e77936cc9207f629b077bf7cbc5e2f0827cddd7c29792f04ef881bd2c3/librt-0.16.0-cp315-cp315-win32.whl", hash = "sha256:b0e3e721c75d2e79a76d4422c79d7ba705fe1bbafec907037fe7a657a480a0e3", size = 100127, upload-time = "2026-09-29T00:54:40.251Z" }, + { url = "https://files.pythonhosted.org/packages/56/1e/801fe26bc622061b9dfd010e166d94142cb774b733217e6d98d1c0cf2638/librt-0.16.0-cp315-cp315-win_amd64.whl", hash = "sha256:bc02954b1295de798bbdb0b4e2d8a28c2117de8b5c73dcbeb27dc32572dfb971", size = 120480, upload-time = "2026-09-29T00:54:41.722Z" }, + { url = "https://files.pythonhosted.org/packages/bb/a9/d533983055bd36e112627384c2c038845d1df882540b8bcefb566475640b/librt-0.16.0-cp315-cp315-win_arm64.whl", hash = "sha256:c5db585d43449a5f54303d4b2774e45e1babd975cfe1630a3d708c0b80c3e560", size = 110915, upload-time = "2026-09-29T00:54:43.052Z" }, + { url = "https://files.pythonhosted.org/packages/55/fe/d62238fa9c653b0e0613290349467cb65711b5800e8e474f45e942a0ad95/librt-0.16.0-cp315-cp315t-macosx_10_15_x86_64.whl", hash = "sha256:f06c689cb14afd9b612727553a5ec5a40febf113ca41c4413a2b0b334285884b", size = 159714, upload-time = "2026-09-29T00:54:44.497Z" }, + { url = "https://files.pythonhosted.org/packages/f3/ac/f31efe7818700be72ba4f9af8a80fa67c39808c8d26dacc55dc1f6f35172/librt-0.16.0-cp315-cp315t-macosx_11_0_arm64.whl", hash = "sha256:13b4e8aba90b0b1c82474e9844aa9ffe7ad3faa484350e1da64cb8188d903134", size = 162086, upload-time = "2026-09-29T00:54:45.968Z" }, + { url = "https://files.pythonhosted.org/packages/d9/16/4d7487bf86a9d7e8e18f37ba5538789233ea693637379b75701bd35ec9de/librt-0.16.0-cp315-cp315t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5a269c46ae327d8e6f8c1f85f7516cb52c0fa48127565a1105a4f4a05ff2a0b4", size = 712727, upload-time = "2026-09-29T00:54:47.486Z" }, + { url = "https://files.pythonhosted.org/packages/77/74/50cd550ccc1a517b9ed62347625c01ddf8c4afad66490312677c011458f6/librt-0.16.0-cp315-cp315t-manylinux2014_i686.manylinux_2_17_i686.manylinux_2_28_i686.whl", hash = "sha256:a33e0dae1f8592146a4764d54ce842b278732d21a84e17c3bbe6b1bc158a2248", size = 681106, upload-time = "2026-09-29T00:54:49.126Z" }, + { url = "https://files.pythonhosted.org/packages/df/5d/7293f712975ee6fdd2251411fd9ef1c62bc99c7b83ecbe62dbc999b1fab7/librt-0.16.0-cp315-cp315t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:47ada6ea32636492c61aa8ad27ae3b9404bfe7a97e3ba946d1984236cc741da0", size = 705921, upload-time = "2026-09-29T00:54:50.905Z" }, + { url = "https://files.pythonhosted.org/packages/67/f7/8aab946f11d59d1bece9ffc65d994b200c789a8ca5a95c17e17e609f912a/librt-0.16.0-cp315-cp315t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c43bd6e642d8a248c114327f98dd25ac5a7cb5aa168ef02f0559b91874df16b8", size = 731786, upload-time = "2026-09-29T00:54:52.584Z" }, + { url = "https://files.pythonhosted.org/packages/43/76/1c42ab31e7cb8384ebf6d3af607213c495222474f4940443ae7639ab7685/librt-0.16.0-cp315-cp315t-manylinux_2_34_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:c3d1bb7841a816ace6449bb26d3f9560dbfa20e71c568d23f0f62bf1e68f50b1", size = 744964, upload-time = "2026-09-29T00:54:54.217Z" }, + { url = "https://files.pythonhosted.org/packages/6f/2e/4b19982d933d2dfced671e840b219e4c1cd3f507df6e6dabb51bbd4e3850/librt-0.16.0-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:3931f7a3db322e7f44e02a280e3949326ce9579ad388ee8d691dc7c76da9fb70", size = 765305, upload-time = "2026-09-29T00:54:55.815Z" }, + { url = "https://files.pythonhosted.org/packages/b8/1b/e872583de2dcb3ac7746e7a2321aeeb168274f3952a87dc66e05ddb29faf/librt-0.16.0-cp315-cp315t-musllinux_1_2_i686.whl", hash = "sha256:f4462528b6000afe8f16907b5c7c2553abf1df005ba5140e6eb394541c3624c3", size = 744959, upload-time = "2026-09-29T00:54:57.532Z" }, + { url = "https://files.pythonhosted.org/packages/10/de/a18c6bcfb297af2674233e90b3c3661c3a0af0f1434a0c966d2ef708a835/librt-0.16.0-cp315-cp315t-musllinux_1_2_ppc64le.whl", hash = "sha256:80039ba9b6a7d5f1a0175a4cca6bbefead87bd854c80abad1cb30afe47a830db", size = 758138, upload-time = "2026-09-29T00:54:59.484Z" }, + { url = "https://files.pythonhosted.org/packages/22/1c/0df1d732539c297bb1a093e1fe3204d2faf76a9022cf4e1d1c2fce059790/librt-0.16.0-cp315-cp315t-musllinux_1_2_riscv64.whl", hash = "sha256:7a1d272724b581bb6bc769dfdafed6da2ecc9886ba2450311de55a4ac2e1e9cd", size = 744268, upload-time = "2026-09-29T00:55:01.179Z" }, + { url = "https://files.pythonhosted.org/packages/a2/f7/ccaf31331f20c91a5bd9bd48ffc3f743f9c81bb5720cc7b2a720ca204f0a/librt-0.16.0-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:fbe4fb8c5445f7496d7f7f6bb0807875d09d47e6771ffa175fb2df2895fb86ba", size = 785783, upload-time = "2026-09-29T00:55:02.938Z" }, + { url = "https://files.pythonhosted.org/packages/c1/ea/7421d9e6db894cd6cd788b604b3394a163ded6b942052b6f96c23ccf08e1/librt-0.16.0-cp315-cp315t-win32.whl", hash = "sha256:375bfe6b572a8f6cfc398709356046173bf27e64c4c5edaf5f7062f051fb4bf9", size = 104355, upload-time = "2026-09-29T00:55:04.533Z" }, + { url = "https://files.pythonhosted.org/packages/85/6d/7c31a506eb847bc58aeb2402d58e17605e821f68ab5df5e66fe274a6df41/librt-0.16.0-cp315-cp315t-win_amd64.whl", hash = "sha256:bd3150023d3dc2bc70f3784e59ffa1140d56ddba3d8125b3d6f9f85221279bfc", size = 126134, upload-time = "2026-09-29T00:55:06.017Z" }, + { url = "https://files.pythonhosted.org/packages/36/69/7a5d10ac409c4da0355e054a14371871da9b5557fcc42772cd00181c6cce/librt-0.16.0-cp315-cp315t-win_arm64.whl", hash = "sha256:8ceafb70f2a4f0826f11031942e59c0728fd98da112dc346d4352bde1e486866", size = 116391, upload-time = "2026-09-29T00:55:07.484Z" }, +] + +[[package]] +name = "markdown-it-py" +version = "4.2.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "mdurl" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/06/ff/7841249c247aa650a76b9ee4bbaeae59370dc8bfd2f6c01f3630c35eb134/markdown_it_py-4.2.0.tar.gz", hash = "sha256:04a21681d6fbb623de53f6f364d352309d4094dd4194040a10fd51833e418d49", size = 82454, upload-time = "2026-05-07T12:08:28.36Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b3/81/4da04ced5a082363ecfa159c010d200ecbd959ae410c10c0264a38cac0f5/markdown_it_py-4.2.0-py3-none-any.whl", hash = "sha256:9f7ebbcd14fe59494226453aed97c1070d83f8d24b6fc3a3bcf9a38092641c4a", size = 91687, upload-time = "2026-05-07T12:08:27.182Z" }, +] + +[[package]] +name = "mdurl" +version = "0.1.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/d6/54/cfe61301667036ec958cb99bd3efefba235e65cdeb9c84d24a8293ba1d90/mdurl-0.1.2.tar.gz", hash = "sha256:bb413d29f5eea38f31dd4754dd7377d4465116fb207585f97bf925588687c1ba", size = 8729, upload-time = "2022-08-14T12:40:10.846Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b3/38/89ba8ad64ae25be8de66a6d463314cf1eb366222074cfda9ee839c56a4b4/mdurl-0.1.2-py3-none-any.whl", hash = "sha256:84008a41e51615a49fc9966191ff91509e3c40b939176e643fd50a5c2196b8f8", size = 9979, upload-time = "2022-08-14T12:40:09.779Z" }, +] + +[[package]] +name = "more-itertools" +version = "11.2.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/52/b8/c63995bebbb9ac9c059350e0fb8c82c2420c85aeca7d34e40aecf3df9281/more_itertools-11.2.1.tar.gz", hash = "sha256:cbf08fd0af284dc69718b9b76a8e6203df624d70209ea511e4219d350c856f63", size = 154133, upload-time = "2026-10-14T18:50:30.407Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/5d/57/3c4b1c6f2e0cc29ba023802458ea3d2a996f87085559e4a5f2192d549532/more_itertools-11.2.1-py3-none-any.whl", hash = "sha256:35a7377edd1dd6608dcb2cdf534ded55ea32d49448875ad042cd3f879fb1ded0", size = 74405, upload-time = "2026-10-14T18:50:29.116Z" }, +] + +[[package]] +name = "msgpack" +version = "1.2.4" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/cc/52/1ec7ead2c7528bf3d1db73e886fa4df10f9e6f0eb7854a448b7090cfcef7/msgpack-1.2.4.tar.gz", hash = "sha256:475c44e12f2a5de766a8448783f149c9b33f3f49b88953c6cd739a77d93c732c", size = 197764, upload-time = "2026-10-26T17:55:48.593Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/64/cb/a3bd4d234c0f2f7e646b9be259b801c5d6a35c97f93dded4f722e6b80acd/msgpack-1.2.4-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:1095b1ebcc8c9d3e70c51240b7160d8e9da66044e0a45c3ef8403d3a9ef0c5ad", size = 90935, upload-time = "2026-10-26T17:53:46.588Z" }, + { url = "https://files.pythonhosted.org/packages/56/3c/fc87d06bdfc99b302f4379f0eb34bb8695b6ecd90b965652d0a3195d1acd/msgpack-1.2.4-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:a4b47ec7422bef149223786a87df80067ac65bfc7c0565e5cf1dfbdc40acee50", size = 90187, upload-time = "2026-10-26T17:53:48.151Z" }, + { url = "https://files.pythonhosted.org/packages/05/a3/abebe12c1b589b7eeab60cb87dd5eb398fcf549bdafca8c30d8d73e48493/msgpack-1.2.4-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0c75cfda0d3ccb1f6abc20e0608ad6b226e11f317b5ac297721504d2509e2bd9", size = 466911, upload-time = "2026-10-26T17:53:49.536Z" }, + { url = "https://files.pythonhosted.org/packages/03/41/ed5517a107628f6f7f3a1f46f19de3aca979bd1fc95861cb56ce0e4bcc02/msgpack-1.2.4-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a45ceb5f199d5e388f28b550ba881096a3740d4bda10e661d77f59d9a2e8187a", size = 480247, upload-time = "2026-10-26T17:53:51.211Z" }, + { url = "https://files.pythonhosted.org/packages/31/71/14c39858380e11408fcf75aeab1cda0afb253cd8f62a01fbe4ae1838b66f/msgpack-1.2.4-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:7ca62b31a873c70b73f367bb2c1efec1d143016642c5191405549578184ff6ff", size = 438298, upload-time = "2026-10-26T17:53:52.919Z" }, + { url = "https://files.pythonhosted.org/packages/3b/73/ba40b91632e011851e1a397d53e0bd031848751902424a5b37c33f7de412/msgpack-1.2.4-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:f641971d3eec89ffca57fa36d151ad1cf1b6a214b47faca16cb165c7d45ef8be", size = 461600, upload-time = "2026-10-26T17:53:54.8Z" }, + { url = "https://files.pythonhosted.org/packages/51/f0/c13ce7e7a7d8dabc1a48eecf61eb789084dbcc64374a7f19770eaf96f2c3/msgpack-1.2.4-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:b9eff629190a4b118549b654df32a56ed535351819f690d0c935d185500cc90b", size = 435020, upload-time = "2026-10-26T17:53:56.433Z" }, + { url = "https://files.pythonhosted.org/packages/b4/d2/2a4e254f8ee5d5dd5019bd9f99164d79704788dbe16d9d6de77fda4e6727/msgpack-1.2.4-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:4e22c6571ab6ac9036da87d8a6fddb4baf86981844b480c0c60a4a4be417ee48", size = 479138, upload-time = "2026-10-26T17:53:57.918Z" }, + { url = "https://files.pythonhosted.org/packages/70/b6/28f7eb3f38e3b6ea1f87f36c44cc25ab0eeb451147b5ff61637ce3d0b839/msgpack-1.2.4-cp311-cp311-win32.whl", hash = "sha256:5d7d4d2a5fc6a604f20c546ee1e8327bed1e9329be2417cef9af1f799f3e55e0", size = 67926, upload-time = "2026-10-26T17:53:59.172Z" }, + { url = "https://files.pythonhosted.org/packages/b9/9e/67a97d5caa41bcbdbb4fae7bf5009b60222c72d0748364ac9e32de334a4e/msgpack-1.2.4-cp311-cp311-win_amd64.whl", hash = "sha256:9db832747bd05834530189e564a3fe31e2617547dc1f3a005f835eafc2b8e048", size = 76117, upload-time = "2026-10-26T17:54:00.403Z" }, + { url = "https://files.pythonhosted.org/packages/32/43/890b028b2cdb6b75fd56bd9388466c9fea9f10a31ebb685c489c5cb32fa9/msgpack-1.2.4-cp311-cp311-win_arm64.whl", hash = "sha256:deb1730c4c0c1a8c975be2f43efea6ee4834d35031a39075f78917d0ba8b3c04", size = 72632, upload-time = "2026-10-26T17:54:01.798Z" }, + { url = "https://files.pythonhosted.org/packages/27/fd/45f6cd13cefbb659a8e0128ea64d51b349571163fec3c9c20f99792dc42a/msgpack-1.2.4-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:90cba4996b18ec1201fcaabd01ec48ff4b9755416bcd52105ded2f89fe145c49", size = 91903, upload-time = "2026-10-26T17:54:03.097Z" }, + { url = "https://files.pythonhosted.org/packages/7f/89/169c2a0b1ffeafe68a4f13d8d96b6ed1cd8d40d8262b3a6690851da7eda1/msgpack-1.2.4-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:112933726919f4239646cca9572e2c2fa5626358c670da8440aac09403100a48", size = 90573, upload-time = "2026-10-26T17:54:04.383Z" }, + { url = "https://files.pythonhosted.org/packages/cf/8e/272a384f2a001cfced1baab0a8abdd912d6281432670f4609d1aab718d7b/msgpack-1.2.4-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9ca1e78106675f2aed07dc37b842ce19be70010ab22c5c5c04688f0840d48539", size = 461057, upload-time = "2026-10-26T17:54:05.821Z" }, + { url = "https://files.pythonhosted.org/packages/1e/d9/f59bd841fc2fd2b74dc50ce85860a6a25f58e588dd48946aeaf2862cf990/msgpack-1.2.4-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c4d5bbdbea8f5669b3a734d6c226772804fb120848f99cbe63a0ddee63b049c9", size = 475652, upload-time = "2026-10-26T17:54:07.414Z" }, + { url = "https://files.pythonhosted.org/packages/00/03/afd000e1b1e28fd535dc8c7bc21ebb88923bc1964a2429fe660fb313ace3/msgpack-1.2.4-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:0d9ff7f3aaffd84010f1c501b05406a497584f5cab2f732eb9d89bf960e12f6f", size = 427082, upload-time = "2026-10-26T17:54:09.1Z" }, + { url = "https://files.pythonhosted.org/packages/f7/7a/e2890b272883c496faad777324ddb70e9cc4a6c63731962a4a39a6a40f44/msgpack-1.2.4-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:aa10dc04c03408f31948ac1896a942141fd8d7a954b3612edac79f19663e4076", size = 451956, upload-time = "2026-10-26T17:54:10.476Z" }, + { url = "https://files.pythonhosted.org/packages/c2/46/0c1b240b8a580af3e72139c33b018025440a1a42c2579e82e39b1195ee36/msgpack-1.2.4-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:472a25463678f2795143a7cb42e88a1b59cc2375e9881917e69a9323bde42114", size = 423833, upload-time = "2026-10-26T17:54:12.195Z" }, + { url = "https://files.pythonhosted.org/packages/80/8e/851415b1a9264e6abf64d8a9617d856769d59e247fb9470106f133aedbae/msgpack-1.2.4-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:cbb8a677da3e845713925e9a203b8a120b1e9da9989836890ba4a4a187902701", size = 470951, upload-time = "2026-10-26T17:54:13.764Z" }, + { url = "https://files.pythonhosted.org/packages/c9/74/d75bf61aab9cb88b84f7d3a8eca8dd92e19a742b77ded300a1177e88d031/msgpack-1.2.4-cp312-cp312-win32.whl", hash = "sha256:2b0b7dff5beddc10f16ecea6b28c6b98014d1135d7015bd83adff5037f35848d", size = 68786, upload-time = "2026-10-26T17:54:15.049Z" }, + { url = "https://files.pythonhosted.org/packages/81/c5/dd0e78eb04f9a0773a810d25ef2cd8f16bb941487567d0c63f814881133c/msgpack-1.2.4-cp312-cp312-win_amd64.whl", hash = "sha256:6e38b123681df22373d545520f54bbeddc4706d9235a1161061f12bd6648497d", size = 77272, upload-time = "2026-10-26T17:54:16.491Z" }, + { url = "https://files.pythonhosted.org/packages/65/e7/b38f63ae82777c0077daa56c4b09af39d29dcb8927ab2ff59268094069c5/msgpack-1.2.4-cp312-cp312-win_arm64.whl", hash = "sha256:6795c588b210b2f13d62c8fcc23bf779b509b839ec5c197a7ab4f5191459e126", size = 71884, upload-time = "2026-10-26T17:54:17.995Z" }, + { url = "https://files.pythonhosted.org/packages/2d/26/16eaad5fe6e199334fa5bd66070778665717c86e9a273525dc706ddb06a7/msgpack-1.2.4-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:fb811ac3d463a75013b234d2aae56b9f0bdb0105caf4dd2ee65305b6a8a6078d", size = 92057, upload-time = "2026-10-26T17:54:19.616Z" }, + { url = "https://files.pythonhosted.org/packages/9c/b8/9660be6d120820bc05106f291e824c73d35f4ab77d927788ae67ea80889c/msgpack-1.2.4-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:36258fd0909e1bf26e94604439108846432abe4ffa9a23c9dc2f6f1c60f94b60", size = 90542, upload-time = "2026-10-26T17:54:20.965Z" }, + { url = "https://files.pythonhosted.org/packages/6c/10/cd55a69fec29df26884b178dc4b1803442ec82abf929604aac619881917a/msgpack-1.2.4-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e9c5ba0f053a7e98f013f083c9d1b2dffb26cad8c897c533d8286e44ed24c669", size = 455798, upload-time = "2026-10-26T17:54:22.434Z" }, + { url = "https://files.pythonhosted.org/packages/c9/94/562e0733593a780c70b0b18994f30c205149f7f9f4efbe3e9b00b88612c5/msgpack-1.2.4-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7fabd415c41e62006c6641fcdf5b3e866f581c4e11c58328c0d0f69584b9577d", size = 469262, upload-time = "2026-10-26T17:54:24.043Z" }, + { url = "https://files.pythonhosted.org/packages/bb/92/76d1a5c597e04e1d360b05573d150bdb4502f5a014e6e9cf089c9537c156/msgpack-1.2.4-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:7433d340de45003db3ed909a642c9469b598d175530f7a707cbaba64287d27ce", size = 420789, upload-time = "2026-10-26T17:54:25.587Z" }, + { url = "https://files.pythonhosted.org/packages/8a/c6/b72b8d8022718380db459ced8ffbabc7570ad2d22c7f2fa659c872cb6734/msgpack-1.2.4-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:ccd6e4af5347eb9828147320449bcd30e3321f6397d4583ff16047485dd8be3d", size = 447068, upload-time = "2026-10-26T17:54:27.721Z" }, + { url = "https://files.pythonhosted.org/packages/cb/dc/f378ef1def4aa135e70325c09e22457f3203ae2a390a192e892267906f33/msgpack-1.2.4-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:23d1459a1d0b4c9f6629df072d592eb74424b3ed3656b69af507bc9023cc027f", size = 418896, upload-time = "2026-10-26T17:54:29.325Z" }, + { url = "https://files.pythonhosted.org/packages/62/93/a7e507378f43e91415cb6fda47e0ded0c9de1618a1f4ac4f2887912a92dd/msgpack-1.2.4-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:9e73761fe9fc55a4e9d2df8e8f59b0979231af4dbf80b8bf90cd64c74173d779", size = 465764, upload-time = "2026-10-26T17:54:30.719Z" }, + { url = "https://files.pythonhosted.org/packages/60/76/7f39f49cbcdaa4aafe64b4941b2640772dbdc1cac3a9332f4c9ba6994da9/msgpack-1.2.4-cp313-cp313-pyemscripten_2025_0_wasm32.whl", hash = "sha256:d088d1f552e129859db830692268747aba0a1ee3e6e0fe6344dbb3aab1df9f6c", size = 53615, upload-time = "2026-10-26T17:54:32.213Z" }, + { url = "https://files.pythonhosted.org/packages/67/9b/85b93350dbd7b52b358882f7f17a88a03664a7a59a359406e6315c162634/msgpack-1.2.4-cp313-cp313-win32.whl", hash = "sha256:892d4f17d7962bfd2c2928b0a47542bf2948f074a7c04721b73d4138b70481e4", size = 68724, upload-time = "2026-10-26T17:54:33.484Z" }, + { url = "https://files.pythonhosted.org/packages/02/4a/a7e2778ce09a943c17b6f91c7acb2f9488357657c01f2cccb278297621c4/msgpack-1.2.4-cp313-cp313-win_amd64.whl", hash = "sha256:318d4e634d2b320be10decd9968ad1ae0be1d80cba23b5528c37b429eeb0e3e0", size = 77039, upload-time = "2026-10-26T17:54:35.016Z" }, + { url = "https://files.pythonhosted.org/packages/64/16/9ff7495a9853e9d7de74965fdadce15017e7213ce564bb5dafc5403c9108/msgpack-1.2.4-cp313-cp313-win_arm64.whl", hash = "sha256:bec3e34749b90cfcf116149aad11295c720ff4a74a7d0a35abdb968a396c1524", size = 71873, upload-time = "2026-10-26T17:54:36.19Z" }, + { url = "https://files.pythonhosted.org/packages/86/34/747f9ea2b428088201c73fcb3a885cebcbedcd71def0f1f3c36896294b27/msgpack-1.2.4-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:895e9369185df4a874768849405c30cba7990caceb3fcb1692ebe62bb050f55e", size = 92449, upload-time = "2026-10-26T17:54:37.503Z" }, + { url = "https://files.pythonhosted.org/packages/83/7e/52d208cb1561f869762c17be0e2c004e4d34f2842d239a450492d6246d62/msgpack-1.2.4-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:c97f5f17407e1761f23f1944be33cbf1d5ce67017db32544dcd5e16e0b1b4a3b", size = 91202, upload-time = "2026-10-26T17:54:38.797Z" }, + { url = "https://files.pythonhosted.org/packages/2e/58/5516cabb60da83506024015c669622a0277979aef51eb611308cebaf4cc9/msgpack-1.2.4-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2444a4e04f924630d059ae6eae8f91fdfcd28ed9fd17b21bacf4e74550a091f7", size = 455185, upload-time = "2026-10-26T17:54:40.213Z" }, + { url = "https://files.pythonhosted.org/packages/39/8f/bf975b5d2111e4954a0f8567fc6b60bab22c8766dd4fa509af1334c91a4f/msgpack-1.2.4-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5d65b791ce4283e02b6267742ad540899155e1b32887b9cbdda47f38f5a076b5", size = 465078, upload-time = "2026-10-26T17:54:41.971Z" }, + { url = "https://files.pythonhosted.org/packages/32/2f/c74baeafc53d1c1fadfbeb774444d0e6354778d12b40b827e437a7a35856/msgpack-1.2.4-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:5e4c67dbac05dce90a3fa1d845137617383c415e6b319062baac9734540706ae", size = 420144, upload-time = "2026-10-26T17:54:44.994Z" }, + { url = "https://files.pythonhosted.org/packages/b0/f2/bdf2ce9e284821397dc5549101824c7607ee6ba6e0635390d168a77ac49c/msgpack-1.2.4-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:781e856db4f2cb398e4992e2a74305295d3ebf694eec26fa0f4bc766eb9fa0a0", size = 446479, upload-time = "2026-10-26T17:54:46.484Z" }, + { url = "https://files.pythonhosted.org/packages/76/8d/b4572d24bb75d98bcbbd031a934a3a1d03494ea88a100cd51ab16c4c7d57/msgpack-1.2.4-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:cfc1cc237792f9a5664002b66acb961027d4184528ec9d10e0e42330f7972383", size = 418780, upload-time = "2026-10-26T17:54:48.04Z" }, + { url = "https://files.pythonhosted.org/packages/55/8e/4493bef4422730cfd3420b84094652fabd27ef8aadc8b443a8995b524d08/msgpack-1.2.4-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:f60de6ae13d4d2a12a483f15c5e47cb6fa2731aa32d92fb31178e2017d6574a8", size = 462009, upload-time = "2026-10-26T17:54:49.433Z" }, + { url = "https://files.pythonhosted.org/packages/41/29/efdc3d1d09e4e0e45955b0aad559b4c1f5d908767c9fb1021990c52182a5/msgpack-1.2.4-cp314-cp314-pyemscripten_2026_0_wasm32.whl", hash = "sha256:06a0657a4110d563255006b7cb7147432f67827144e429c2cdb1c967548d1817", size = 53714, upload-time = "2026-10-26T17:54:50.753Z" }, + { url = "https://files.pythonhosted.org/packages/df/0b/08794c65e0a752acf20aa44e193e61dfb552b48fe6c27ba6023c146f9e77/msgpack-1.2.4-cp314-cp314-win32.whl", hash = "sha256:727a65b35db9f5ef516fc0229c4b05cab983092b1ae274a8a769b2d517fb0499", size = 70726, upload-time = "2026-10-26T17:54:52.397Z" }, + { url = "https://files.pythonhosted.org/packages/b5/da/e2cc63ec61e7ac05595b391cba01c10cb4657f4e517da1512e4a75d2d12e/msgpack-1.2.4-cp314-cp314-win_amd64.whl", hash = "sha256:80f5d4fda1ba373d95933f98e6c1d18247feffac839fda3930bdd85e6561bb5f", size = 78346, upload-time = "2026-10-26T17:54:54.662Z" }, + { url = "https://files.pythonhosted.org/packages/93/e4/1b0eb49887009dc2c530171d659cf2aa37202b5f79c0b784e63777554b37/msgpack-1.2.4-cp314-cp314-win_arm64.whl", hash = "sha256:e5f67f0286f2ba2c6dbb4998404ed880112ca204ceda729cf239879cd89d3acf", size = 74152, upload-time = "2026-10-26T17:54:55.915Z" }, + { url = "https://files.pythonhosted.org/packages/d0/4a/6defc8fd0270c4ba675e6625f4f76ce936fd0c48733395fd7ba912cd423e/msgpack-1.2.4-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:45506bfb902cde24a0d33fb0581f58497ddb2682686dd1f6aa07e7b769df7ca4", size = 94083, upload-time = "2026-10-26T17:54:57.108Z" }, + { url = "https://files.pythonhosted.org/packages/c8/e8/59f7e076739048864710a4de3403ae1c1b43ed5077b796cd9e8cbce9b3f6/msgpack-1.2.4-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:dc9dc681958e69f46b9f37def3e7fd6cc5dcfaa5943fb00bfe9c223a1a1052f6", size = 95037, upload-time = "2026-10-26T17:54:58.489Z" }, + { url = "https://files.pythonhosted.org/packages/2c/dd/dbae250b23b831cd0571eb664089f80de3249a39e98c6ef55f9a0efe928d/msgpack-1.2.4-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0bef691e2a95119cc6bf3ded29325dbd89c4b6f8ff233070431948ed70902421", size = 472722, upload-time = "2026-10-26T17:54:59.924Z" }, + { url = "https://files.pythonhosted.org/packages/a9/e2/383ece1c1b27c1ed322055fce8ab8972bc6d529ede881592065ce0c461bf/msgpack-1.2.4-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:55e6106d2d085af42b2de72efeb38ed255241a24b32295ca889707c1d679c442", size = 468726, upload-time = "2026-10-26T17:55:01.492Z" }, + { url = "https://files.pythonhosted.org/packages/37/2f/5410a8815ae74a824ac87543c612e40cb6674851b70a6ad858bb32813203/msgpack-1.2.4-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:996dfc4774c240c8e6adf1166ae102141cfbed33c8856fde821bd6c0bd35ee41", size = 420488, upload-time = "2026-10-26T17:55:02.848Z" }, + { url = "https://files.pythonhosted.org/packages/39/8e/16fdf02b4f91dff9c1480433c1bf80756c2fedc0b74fc6a231f02dfed007/msgpack-1.2.4-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:efa1357fb0c7201e833de28638be371ee127476f7ccff9e7a94211b0afc33ddf", size = 455541, upload-time = "2026-10-26T17:55:04.564Z" }, + { url = "https://files.pythonhosted.org/packages/c4/76/2454ef54d780a167667552d02e7bc977a3d419943bcbdf6a96a4da6786ad/msgpack-1.2.4-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:b9270b63409e70c8c6deb5faedc81fc27c6bd0196b38084a8773f68286abf034", size = 419514, upload-time = "2026-10-26T17:55:06.257Z" }, + { url = "https://files.pythonhosted.org/packages/ac/8b/2af9bf378def33c24875f250421b0d0b1b06f72a1c2c3f964749fc4cdee1/msgpack-1.2.4-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:2b597bb01aff61d65e305c2cf2589c93c86609929d42d575bfc359f3c54ea8e1", size = 461910, upload-time = "2026-10-26T17:55:08.05Z" }, + { url = "https://files.pythonhosted.org/packages/0e/46/a133ac6c4cef4d3939383c00cc19baa16ee85fd70af0c5990e7a9ca8767f/msgpack-1.2.4-cp314-cp314t-win32.whl", hash = "sha256:ad5bc540cbc34db236f8535721a9a872d12a9d88d1322470f1fc7c5e9dadfdb2", size = 76441, upload-time = "2026-10-26T17:55:09.711Z" }, + { url = "https://files.pythonhosted.org/packages/d4/f5/8d22ec454c188f1795107a3fd9f68ada485076ebf394a4aaaa5fbb6093e7/msgpack-1.2.4-cp314-cp314t-win_amd64.whl", hash = "sha256:287e52c2ebaa94f8eca045628374859f51584e77bc07086e6835a9bb2204c774", size = 84321, upload-time = "2026-10-26T17:55:10.947Z" }, + { url = "https://files.pythonhosted.org/packages/41/52/1390514aee47d14ca3fe6ea0cf236fddc55021867ace30daf8761deba36f/msgpack-1.2.4-cp314-cp314t-win_arm64.whl", hash = "sha256:f3f19fe5decd348b35b003ae5f32d3fa90877413a0183da676f748a3a7ab9270", size = 78589, upload-time = "2026-10-26T17:55:12.425Z" }, + { url = "https://files.pythonhosted.org/packages/d0/d8/0465d475c1a7063af1a1fb4f8c69e0dd661c4dd172055c9757a343a07d5d/msgpack-1.2.4-cp315-cp315-macosx_10_15_x86_64.whl", hash = "sha256:765584b93ed6f0b561f0c56e9735f24945c0682f857c9b3ee3b4caad9c32f66a", size = 92449, upload-time = "2026-10-26T17:55:13.665Z" }, + { url = "https://files.pythonhosted.org/packages/b2/d0/5220a8a53579dda39f3526394ba5b7eafc28736085f2626deda7fcd22cd1/msgpack-1.2.4-cp315-cp315-macosx_11_0_arm64.whl", hash = "sha256:0221748c30ace75fde0dec8c470abe65fb5374cd4f37adb9db6aca7a3c362c0a", size = 91209, upload-time = "2026-10-26T17:55:14.913Z" }, + { url = "https://files.pythonhosted.org/packages/b2/98/f151742eba413503074a10d8f636bf03dd4f3f7cba29689767a35d19bd1c/msgpack-1.2.4-cp315-cp315-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c5917972ce1bf5f85f761031e00dab6fe0ad9f880cb3d2d43ed74b330c850400", size = 455713, upload-time = "2026-10-26T17:55:16.406Z" }, + { url = "https://files.pythonhosted.org/packages/b0/54/890510a2c9841aff63258e085d15d4e140c7eef559d4da81ef2d2d867436/msgpack-1.2.4-cp315-cp315-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e7ae8cf6012372cecb43016132d1b87ccc2ebb8ae5ab5078687399e82423386a", size = 466177, upload-time = "2026-10-26T17:55:18.351Z" }, + { url = "https://files.pythonhosted.org/packages/3d/41/a6f20d7c2c380fb072b95ffc5b865a1d62eaf49d77fbee44466c45a1a8de/msgpack-1.2.4-cp315-cp315-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:e78c66cf97ac5675037f705ca433ad98ac9177f9523e7fdbb34e486ae29044c8", size = 424398, upload-time = "2026-10-26T17:55:19.979Z" }, + { url = "https://files.pythonhosted.org/packages/89/86/fa9559961f2b0d498e6cefa226298ddee2b896cb223449c211702bc34071/msgpack-1.2.4-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:59887281c3c163a7afff7dffaaad2f78cd2b513b7e1a7843f1ee8e7cd6a94231", size = 445686, upload-time = "2026-10-26T17:55:21.775Z" }, + { url = "https://files.pythonhosted.org/packages/39/23/5a9d94036cdd77d4310bbb7cfaf3ccd1f087c4a5d5a4befec4361c5fc0dc/msgpack-1.2.4-cp315-cp315-musllinux_1_2_riscv64.whl", hash = "sha256:9f46e70c8d22e96856967ab9d80c51dcf5bc63133e4da2d66fab64c0d4119b82", size = 422096, upload-time = "2026-10-26T17:55:24Z" }, + { url = "https://files.pythonhosted.org/packages/6e/4b/86a5384112509a94ff6e20028aba6845138743effb7c6617e959ad1256ab/msgpack-1.2.4-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:0a1fd6c31952155b7cd01061288c70303e6554ae855244dfb38a897fd94f8749", size = 463407, upload-time = "2026-10-26T17:55:26.146Z" }, + { url = "https://files.pythonhosted.org/packages/f4/cf/14db289e0ad531e22ce0f03284865f81d14fbc80bf3f79d3b1714bcf76cf/msgpack-1.2.4-cp315-cp315-pyemscripten_2026_5_wasm32.whl", hash = "sha256:b1f08ec826417e3c8dc3edadb50f38debba033af6cb849229f0eac72f80f2342", size = 53743, upload-time = "2026-10-26T17:55:27.497Z" }, + { url = "https://files.pythonhosted.org/packages/46/72/a76fc90b51503c0bdacbc7fc823aa6fa62d40596ac47f9ea8492d6f95a34/msgpack-1.2.4-cp315-cp315-win32.whl", hash = "sha256:e8ba23c838739fe929e868095171e71f2f38d6ce0fcf5840b576fb82648e58e6", size = 70780, upload-time = "2026-10-26T17:55:28.705Z" }, + { url = "https://files.pythonhosted.org/packages/58/a7/fa9d4a1b5dfead83ea6e03b4007041a5da988c25eb941d42612e0211d3c0/msgpack-1.2.4-cp315-cp315-win_amd64.whl", hash = "sha256:67310606cf2528a6dc3ece1298dcd5cc6c57add148b16d22c5111138aa84820c", size = 78288, upload-time = "2026-10-26T17:55:29.928Z" }, + { url = "https://files.pythonhosted.org/packages/b5/f3/8163d7938a8fe003952fe2719ddb31da71998559bbe290c55ffe622b886b/msgpack-1.2.4-cp315-cp315-win_arm64.whl", hash = "sha256:ce76e7a7c11459157887a8dadf07c107ff74eca98cf914f0de6ee7ab4b47104d", size = 74235, upload-time = "2026-10-26T17:55:31.112Z" }, + { url = "https://files.pythonhosted.org/packages/b4/fa/37c3219b250d81bee788c0dd78ae2fc673db2da1c21ae51f7982d85698f7/msgpack-1.2.4-cp315-cp315t-macosx_10_15_x86_64.whl", hash = "sha256:fb9ddbf23b8c6e89752af399fcf4daed60055e239cda44c6acfaa76d19331e8c", size = 93793, upload-time = "2026-10-26T17:55:32.304Z" }, + { url = "https://files.pythonhosted.org/packages/83/9f/b8afcd20d32cf4be1fa3c327e997656d6d446e667452b0fcc66b91710e82/msgpack-1.2.4-cp315-cp315t-macosx_11_0_arm64.whl", hash = "sha256:e283cf563166c21762131b88e3870ee2ec57757b08a8736929757b5a67541061", size = 94746, upload-time = "2026-10-26T17:55:33.624Z" }, + { url = "https://files.pythonhosted.org/packages/e6/4f/03348d381fcbbc2685356833408cc7e9d2af0fe0775926935a2889650f64/msgpack-1.2.4-cp315-cp315t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:40e91bf8325f492e8eb3c3aa6de06b20593c225336bb52b585c913d7c1da025b", size = 468480, upload-time = "2026-10-26T17:55:34.991Z" }, + { url = "https://files.pythonhosted.org/packages/16/46/e54af8d9a51fb562e068e69a0d75a51e9c2fedec49f911f888515f5477ab/msgpack-1.2.4-cp315-cp315t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:cfa86432bf329d6b976f5a00ad4c9064fd51736e4967a52526750236345cc2da", size = 470064, upload-time = "2026-10-26T17:55:36.615Z" }, + { url = "https://files.pythonhosted.org/packages/74/f5/8f9a6b3af1d803e832b11017c8dad44d761fefdb91dba04ee58cb51838da/msgpack-1.2.4-cp315-cp315t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:42e0a7dc26df739149478585d4264338b4d330f24b3e3b57d5aa89e48866e8ab", size = 421267, upload-time = "2026-10-26T17:55:38.076Z" }, + { url = "https://files.pythonhosted.org/packages/4b/8f/7302b0d18eadbbfef9be1dbbdc49905f7f3b847200c3e47068d093976be4/msgpack-1.2.4-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:8e680367090a58c966052d61418cc943111863538fd82471d61fca5271d911e1", size = 451244, upload-time = "2026-10-26T17:55:39.639Z" }, + { url = "https://files.pythonhosted.org/packages/36/c6/05717fb56b510b5e974446f2cb8e9b26fa4347fafc0c5927745b176939b3/msgpack-1.2.4-cp315-cp315t-musllinux_1_2_riscv64.whl", hash = "sha256:a6c9926f8871b261622fe6b599db72c69be5bca8fdc0976886f9a531a301dee9", size = 420273, upload-time = "2026-10-26T17:55:41.488Z" }, + { url = "https://files.pythonhosted.org/packages/05/d9/a19077d664c37319097e16ba8de14e6b3a2edcc8ee78a2069c0808e38960/msgpack-1.2.4-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:c50bac325dbf1a9c80e10da6dbd1100d7082f6b12e153084501e18e86cd3a037", size = 460421, upload-time = "2026-10-26T17:55:43.223Z" }, + { url = "https://files.pythonhosted.org/packages/a2/bd/0e2033a7435f8d2311be37363fedc88bdfa9fd95c364ee8ac3216eb63e36/msgpack-1.2.4-cp315-cp315t-win32.whl", hash = "sha256:34051de19ae532ba47fcab5b0abd08c25c7a64ff763ad819f18764d45f3c2c81", size = 76256, upload-time = "2026-10-26T17:55:44.588Z" }, + { url = "https://files.pythonhosted.org/packages/b3/3f/aa7265f25dafb6af7567a1a7d0a95c5566803db2226c5e084dc5850cfd96/msgpack-1.2.4-cp315-cp315t-win_amd64.whl", hash = "sha256:6ad2f0808099d4281208ff2c756efa958a55a7c8eb21fe1c7052b95c584f02f1", size = 83939, upload-time = "2026-10-26T17:55:45.773Z" }, + { url = "https://files.pythonhosted.org/packages/bf/f2/c53904c4bc3da828fb75678bf489ece808a277affa73f8a7a91dfb7c5851/msgpack-1.2.4-cp315-cp315t-win_arm64.whl", hash = "sha256:e38d854f1c60e94f46d998765201126338bde3fe1b029be0d849094bcbef72c2", size = 77995, upload-time = "2026-10-26T17:55:47.016Z" }, +] + +[[package]] +name = "mypy" +version = "2.4.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "ast-serialize" }, + { name = "librt", marker = "platform_python_implementation != 'PyPy'" }, + { name = "mypy-extensions" }, + { name = "pathspec" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/4a/3c/78ecece71ee4b5445389a4ccd11627cfb9c69e4de554d11060171f376305/mypy-2.4.1.tar.gz", hash = "sha256:63b590965691e540a335fa74dadf31a7069142f6b72e234689bbd244edf55623", size = 4066728, upload-time = "2026-10-28T19:23:13.286Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/4b/8b/2bc7f489528db504221ad7eff6b3f83979ee57d066103c72a85d09046a30/mypy-2.4.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:79a1e79199e980fb41f219cb3d4746d25c64b0b623840d3ed57df1cdc13a6502", size = 14321495, upload-time = "2026-10-28T19:21:16.612Z" }, + { url = "https://files.pythonhosted.org/packages/18/9a/b2f037b4982dce33645296e4394b031ade60f697f468761fa3ea8e2f8ece/mypy-2.4.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4e18d0da3898b3bcd16192f15a206e7b8b8dd0f4a0b3e51aa5bd5c2afe749e2c", size = 14467468, upload-time = "2026-10-28T19:22:10.629Z" }, + { url = "https://files.pythonhosted.org/packages/c4/5a/379f9bfa18bf3f8d43668fbd9ae4f2922dd027a559c461ca9d41cde1d32e/mypy-2.4.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b69a15fc2e75858d6b15e91ed3a0dcff1a533265183b64734138791fe0f49aa5", size = 15421496, upload-time = "2026-10-28T19:22:48.005Z" }, + { url = "https://files.pythonhosted.org/packages/83/50/3bde18a2824ec296432cebe01752ccd0ab8a2ad784abe4390040d019b3bf/mypy-2.4.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:70971cc0bcb1d3f03d2eb68fa430a6481ccc03558dc001d9534d7e5fa274c392", size = 15670425, upload-time = "2026-10-28T19:21:57.026Z" }, + { url = "https://files.pythonhosted.org/packages/6a/36/8b722b88c325d317354de7d10d8fb9d4dc0f958433e873a91fc4ed21a06e/mypy-2.4.1-cp311-cp311-win_amd64.whl", hash = "sha256:6f7225951a277dd0d6add900731d487174b7d24ac133c09d670ed63b4d8cb90d", size = 11300972, upload-time = "2026-10-28T19:21:48.724Z" }, + { url = "https://files.pythonhosted.org/packages/c2/d6/fb2bab1245658d68af8abfe776362a780c621fe0f364f2c7b53039a945ee/mypy-2.4.1-cp311-cp311-win_arm64.whl", hash = "sha256:be4c03f33c55500191df2ed4a9b5e7edbdd1fff067fe361a5a9b1b5d3262da6e", size = 10873349, upload-time = "2026-10-28T19:21:32.104Z" }, + { url = "https://files.pythonhosted.org/packages/c0/1a/0be9dc6af5e0e04128f18a5e36b4ca44bfb0085857d37aa6a7de1ac2b0cb/mypy-2.4.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:d63737426a048a27705a4eedb828669f4bc0873612a1b46b0b9fe892b2ebaaaf", size = 14381321, upload-time = "2026-10-28T19:21:54.223Z" }, + { url = "https://files.pythonhosted.org/packages/0d/a6/7907e36711a8a8c703f961f076fab61793383694140bd1fd87589f3f68d4/mypy-2.4.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7344869cad05f073b8cae2826774fa0161e3eb2f5c685b76813574008d77d750", size = 14466373, upload-time = "2026-10-28T19:22:25.211Z" }, + { url = "https://files.pythonhosted.org/packages/5d/b8/7313212b29de570c25c9859d7c8e4ef2251a6d34338a1e20031d94297721/mypy-2.4.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a20ff6cd2af7a670c64f089bfa5fbcebe8ff3bf896c5e6ac7c9862c7960e4494", size = 15553666, upload-time = "2026-10-28T19:22:36.511Z" }, + { url = "https://files.pythonhosted.org/packages/23/8f/92966b6082ff49da9142e1e527eb9af4359a9a61632a1cfc313da96b37fe/mypy-2.4.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:9ed1195502cca32be5ef756b1693477f4991db2f2e34eaa90cc4ad6bea4f9531", size = 15802641, upload-time = "2026-10-28T19:21:13.421Z" }, + { url = "https://files.pythonhosted.org/packages/b6/b4/874f6fd54b005020ad63e2cf7a59b178d16a771d478849b29b842cb0cf14/mypy-2.4.1-cp312-cp312-win_amd64.whl", hash = "sha256:4c194c5d878130fca1ae662dfb1feb6274afbab0b40032c80147377e0ea803d5", size = 11383067, upload-time = "2026-10-28T19:22:03.516Z" }, + { url = "https://files.pythonhosted.org/packages/b0/41/5ae8e6528c2faa96e4a921a999d2c7ac7c565bee184b4282bf62ffa76b5d/mypy-2.4.1-cp312-cp312-win_arm64.whl", hash = "sha256:71eda06e5bae51976ce869fda429159c9cec678bd02f25bb197f0265c8f991be", size = 10946882, upload-time = "2026-10-28T19:21:39.51Z" }, + { url = "https://files.pythonhosted.org/packages/6a/65/cd19bc06b67d2df4828220245fd98569ba40fac00c60ba48bef1817d8ac3/mypy-2.4.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:3f1613bfe6726169a5680ec3dad5fe1f6d96285c12aded51ad432eadedd39d45", size = 14214179, upload-time = "2026-10-28T19:22:27.49Z" }, + { url = "https://files.pythonhosted.org/packages/c9/db/4d54ca4f49a0113d0c956980272aefdc6eec5458f7a72b350785b9ef2249/mypy-2.4.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:680ba5d9f0e3fe0c746b3d14df15f2a718e4bc308a1145616a1ea691ce7c354b", size = 14376217, upload-time = "2026-10-28T19:21:08.019Z" }, + { url = "https://files.pythonhosted.org/packages/a2/45/089b4724b85f0f408941be5298f817ee89181c1ce031a73d60ebb150c2c7/mypy-2.4.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1fb70621535c22fd4b1a0450d37ed1d6c5eb39656a1cebfb189084c12de54ba7", size = 15467623, upload-time = "2026-10-28T19:21:21.555Z" }, + { url = "https://files.pythonhosted.org/packages/27/4c/15edbc64b0b1412bfe94c74192b3b56554ab642b85a31bb06cef6313101f/mypy-2.4.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:4af5ad558033bf71a44a1be149ed61633522824f84c1b6bc2445d3fe2d2a5296", size = 15729867, upload-time = "2026-10-28T19:21:37.557Z" }, + { url = "https://files.pythonhosted.org/packages/76/5b/7d160fb685994b65b0ca86d352f3afb5424f96a9e6914719f7b861fb6701/mypy-2.4.1-cp313-cp313-win_amd64.whl", hash = "sha256:acdd82cb3a2eb10720e87706a128d75785d005a8c47e36a4973221524f41fc56", size = 11390802, upload-time = "2026-10-28T19:22:18.081Z" }, + { url = "https://files.pythonhosted.org/packages/9a/ea/453d27f8d531f57c5f14aa73094eaa48e3fb77f680bdede2045cb64fa58b/mypy-2.4.1-cp313-cp313-win_arm64.whl", hash = "sha256:133886ef1a7a8cf673df55d865e41580c6c46aa9b8e31e1325dfe315c038f745", size = 10950427, upload-time = "2026-10-28T19:22:59.003Z" }, + { url = "https://files.pythonhosted.org/packages/7d/75/282d43d6fea7be984ac63e75ffd8eee146ba2f3b077bb1ca5bf3f973e0c4/mypy-2.4.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:c45485061ba08f700acc12cfc8b177e6997e6bc353605babfc0abb081e079456", size = 14233251, upload-time = "2026-10-28T19:22:44.977Z" }, + { url = "https://files.pythonhosted.org/packages/ac/a8/9021263cc7e761451c7d8131bdfab3c0a5c2d67aa2d694670019e1ab86a7/mypy-2.4.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:727890a32f1858c09549eb55a8b234fe990d460450b28f03e8213ef925f1247c", size = 14394953, upload-time = "2026-10-28T19:21:29.492Z" }, + { url = "https://files.pythonhosted.org/packages/16/10/4192a5cea09ebbc41c534f57bd0d8f0fb42a8e810632cda6e37f072c59fd/mypy-2.4.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:beb254fec368c4e7f7f82a5f310c6470b893ec88a90b66426da971c6826b0453", size = 15442824, upload-time = "2026-10-28T19:22:42.068Z" }, + { url = "https://files.pythonhosted.org/packages/99/e6/d3b0a7474aa4f696594a47a218b6796d9c4346fc81ed288904278cddd9bd/mypy-2.4.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:ec416d5d2ae689e681f5727e328723f18d8b5dc8c903a146b7851dc5727aad8a", size = 15717227, upload-time = "2026-10-28T19:22:54.026Z" }, + { url = "https://files.pythonhosted.org/packages/48/6a/2ec530dacd4f77ca50d0fa05b854098f2d75e5d18c587d2612b44f10d68c/mypy-2.4.1-cp314-cp314-pyemscripten_2026_0_wasm32.whl", hash = "sha256:0e95ad0bec03ced9a73b42514208abd24c789e67f0e1eba476e276dd7a2dea3a", size = 7898637, upload-time = "2026-10-28T19:21:41.709Z" }, + { url = "https://files.pythonhosted.org/packages/cc/56/de9d7bad12e3868d5f1f4279aed20b1b568b2c5e166f2d3a05b211dca0b1/mypy-2.4.1-cp314-cp314-win_amd64.whl", hash = "sha256:51f742d4154824837ca6e92aa81f00eec222700a3c337bd258e5562a3880d75a", size = 11576656, upload-time = "2026-10-28T19:22:13.232Z" }, + { url = "https://files.pythonhosted.org/packages/b8/12/4fa9883b9b59e5c96ff62845ad019dc47786031c45d67eaccf452cffffd8/mypy-2.4.1-cp314-cp314-win_arm64.whl", hash = "sha256:f44dd4c5ab22df21206dd926c98381ebdbf5bfd696df37dd38ded2d23143fcb6", size = 11174403, upload-time = "2026-10-28T19:23:01.346Z" }, + { url = "https://files.pythonhosted.org/packages/3f/f2/827e356fc4f74c60b8da42663336e035b49d948a3c11224b0fc7543086b1/mypy-2.4.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:2875280687e64740e6ddcef43bd4c5852ad45ff34549740f6aea3f0373870b93", size = 15713427, upload-time = "2026-10-28T19:21:26.757Z" }, + { url = "https://files.pythonhosted.org/packages/a2/fa/e58a4fcae1d238189eac758036c0921992a86e3e6209190efd96d61fc5d4/mypy-2.4.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ea0714d2bccaf6d010c970e1d3ba2c9c2add79d2030aad2ef03167d788948276", size = 15938481, upload-time = "2026-10-28T19:22:34.371Z" }, + { url = "https://files.pythonhosted.org/packages/a1/54/a20f881801b88900923f2be1541a4b438ad0f0883e03836641fdc3d7adf4/mypy-2.4.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:63c6ff0e7ea546943001a91639c9f0c64b60d239268fa5d29e4a6c87f82c2373", size = 17243006, upload-time = "2026-10-28T19:22:39.425Z" }, + { url = "https://files.pythonhosted.org/packages/de/1c/ff84a6133a6e89c390bff6b25d9bad6598e7891b205f4b30b496906d636d/mypy-2.4.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:a5b5da107dc2c93fb0a22f7a45dbaea5dc131afc7056b5468d78e819f9a138e6", size = 17557728, upload-time = "2026-10-28T19:21:43.607Z" }, + { url = "https://files.pythonhosted.org/packages/15/4a/effa47d39b8fadf679c08e7c78559e523f9769a42a75662d2d15b2b9cdd6/mypy-2.4.1-cp314-cp314t-win_amd64.whl", hash = "sha256:c3a4d0c47053cc90035dd3a2c321112b593ad42935d0cbfd747288e1564fa8ca", size = 12370826, upload-time = "2026-10-28T19:22:29.779Z" }, + { url = "https://files.pythonhosted.org/packages/46/9f/b214ececb1a97fbb61ab3dfd48ae3cffd92ae2c148af4c9dc94c6c56772b/mypy-2.4.1-cp314-cp314t-win_arm64.whl", hash = "sha256:0c5bf267645351887b72903fd2f5fbddcf85234e0e6c4ad94e2fcfb4f0c3f971", size = 11851083, upload-time = "2026-10-28T19:23:11.288Z" }, + { url = "https://files.pythonhosted.org/packages/57/5b/e44a2edb0b25a9f1429de770e1d0238af23302671dd40c77ac5efeb0c559/mypy-2.4.1-cp315-cp315-macosx_11_0_arm64.whl", hash = "sha256:db599d03e7d60d15f2e0a11665c18bc52a88699fcab990fdf8cecd5be8ac801c", size = 14243144, upload-time = "2026-10-28T19:21:10.975Z" }, + { url = "https://files.pythonhosted.org/packages/59/d4/5c99dc3a28e11d2f0fcbb02df63d2d3e574dedc0f9f69d50901df305a7a6/mypy-2.4.1-cp315-cp315-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c6c7210e40dd423af7d65cbe428b5906d11dc60659337bdae4e5fdf02ce32ed7", size = 14409316, upload-time = "2026-10-28T19:22:15.515Z" }, + { url = "https://files.pythonhosted.org/packages/c3/c9/3108b38f4c30eabd80194f5d9771a87e27196c5e0ddb5bf4b99c6ed1e97e/mypy-2.4.1-cp315-cp315-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a2d4a51db92059eecc2c33b2a5194b28585ebfd917292c015fe87a77dbff6cd2", size = 15445573, upload-time = "2026-10-28T19:22:05.635Z" }, + { url = "https://files.pythonhosted.org/packages/dd/12/84a53eceaf11c46dfd7931fb6b8902d01fb33787d3a991e81c461458150b/mypy-2.4.1-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:01b7718552d017f88d1151f3cc9d6556d778a90bd58060a2c3d87d070f9099fb", size = 15732989, upload-time = "2026-10-28T19:23:06.512Z" }, + { url = "https://files.pythonhosted.org/packages/65/ba/bf017dc2abdf83b2f74e29c43834b7af67dc1f1b20202f02dae60b4781a0/mypy-2.4.1-cp315-cp315-pyemscripten_2026_5_wasm32.whl", hash = "sha256:3467b1d13000812ab85dc2a3834b9379ec77798ca1bcabe434e23fb21fead692", size = 7898932, upload-time = "2026-10-28T19:21:59.366Z" }, + { url = "https://files.pythonhosted.org/packages/76/05/0c22b1f0390120a8592d31209cb6b9f932b6a0b426fe643e550de15139e3/mypy-2.4.1-cp315-cp315-win_amd64.whl", hash = "sha256:080cf64a60b90a73435542feecf4171904cc5710658165b40c6869115d4aa100", size = 11577577, upload-time = "2026-10-28T19:22:01.302Z" }, + { url = "https://files.pythonhosted.org/packages/73/fb/ac01e173629697ddac2f11e51efd10347d673f9a7311b03f4aba710ebccd/mypy-2.4.1-cp315-cp315-win_arm64.whl", hash = "sha256:f9118a3f50de264b614861bb11814833a742138ac3c8e2e49a860b6977fb2704", size = 11173540, upload-time = "2026-10-28T19:21:46.444Z" }, + { url = "https://files.pythonhosted.org/packages/5b/e4/b9b9c8eb09e70927ee65b1456cfed35710b6e4ff0b07f364ceaf2202307c/mypy-2.4.1-cp315-cp315t-macosx_11_0_arm64.whl", hash = "sha256:9d7dafd56179d296651df9e1844b91c9517c379398f017a2a435d077a28943c1", size = 15706623, upload-time = "2026-10-28T19:22:20.528Z" }, + { url = "https://files.pythonhosted.org/packages/26/74/1ceb1ca884add0565e618d013dd24333039100dc0fcc42661561f2e1cae5/mypy-2.4.1-cp315-cp315t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d923cec43316f0e6736b8298fd00abeaaf348a091c20e7296b3aebceecb63eca", size = 15944095, upload-time = "2026-10-28T19:21:04.779Z" }, + { url = "https://files.pythonhosted.org/packages/2b/68/27bcf9b4efa22733b6050485ae37845b94c9b8851abe4fc60632d905c32d/mypy-2.4.1-cp315-cp315t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d6e081b466e88d4343adffe11aff0f02df34b5b9070b4b700053a0b7294c0be1", size = 17223065, upload-time = "2026-10-28T19:23:03.724Z" }, + { url = "https://files.pythonhosted.org/packages/1a/a3/ed5724b317bf585c29f3c8be2792e97d45925d65a9c8af40ceeb267072e6/mypy-2.4.1-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:70196470ac300f444a302a738541101893c2c57804078b33690286a7899149e9", size = 17560589, upload-time = "2026-10-28T19:21:34.539Z" }, + { url = "https://files.pythonhosted.org/packages/42/2f/005185e6ab4752fd6cc2d1a6d1421fe21979770afe2490c00c555f34a913/mypy-2.4.1-cp315-cp315t-win_amd64.whl", hash = "sha256:de95648e0a6d46fa9929b956ed2c87c5dc9933d4d59945e6390e9d753c74e7c1", size = 12353324, upload-time = "2026-10-28T19:22:51.481Z" }, + { url = "https://files.pythonhosted.org/packages/a1/d6/20420cc9c780087139662534d128c2f3274361f8bb7e9cf0d5495a846ed5/mypy-2.4.1-cp315-cp315t-win_arm64.whl", hash = "sha256:ef8d5be90032261197ac388d945d8ff4f476c95880798a1911760af64ddfe71f", size = 11845599, upload-time = "2026-10-28T19:22:23.136Z" }, + { url = "https://files.pythonhosted.org/packages/21/5c/6e8010f8f2c4ad817364592d4b3883633417269b913fc9d5174fdeb7e565/mypy-2.4.1-py3-none-any.whl", hash = "sha256:1784648d6ec8c2b5465e3f26241b845a0b3cb4e56c993c64abe16989e7698999", size = 2801286, upload-time = "2026-10-28T19:21:19.516Z" }, +] + +[[package]] +name = "mypy-extensions" +version = "1.2.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/d0/6f/43edf3be2748d0e40974a5ee046a8bb4c9961a4bdd3e7d5c6dcbf32d1af6/mypy_extensions-1.2.0.tar.gz", hash = "sha256:c6e275a07f1c2fc096b62940452d0eaa3f3af7de45d704787866240a7c6d5a51", size = 6566, upload-time = "2026-11-03T16:26:33.692Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b5/99/7b1adac7e97ce7bbda34792dc6e9b2f5cc5cffd1875883f78a818b2a2687/mypy_extensions-1.2.0-py3-none-any.whl", hash = "sha256:993e7a20aa5671eb41a7132cf555af30062da99729601601b9a8382b11cae768", size = 5114, upload-time = "2026-11-03T16:26:32.731Z" }, +] + +[[package]] +name = "nh3" +version = "0.3.7" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/18/2f/022b27146d52d24b1b353b003359134788ecbcd6fcdf6283adbd57c0fbc8/nh3-0.3.7.tar.gz", hash = "sha256:71860d01c16f4d8c72e334e0674beb2b0899dbd0bf760de18932ef4390303848", size = 25662, upload-time = "2026-08-23T14:26:30.728Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ce/88/b594f0e86856b37e182fb663283da419eea6424972506e640e890885467f/nh3-0.3.7-cp314-cp314t-macosx_10_12_x86_64.macosx_11_0_arm64.macosx_10_12_universal2.whl", hash = "sha256:91a4dab4e94d9fc54b9f67b1adfb23e81fab7ab43f33c3b8c97be9aa38f789ba", size = 1471147, upload-time = "2026-08-23T14:25:55.259Z" }, + { url = "https://files.pythonhosted.org/packages/1e/60/847a21339f095c4d4c655af31fa2d18b174585bcc210709facacc7ce205c/nh3-0.3.7-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:eae64328e46a25785535afcb6885b6f182ecaf5ee8c88f8c075422db8aacc65b", size = 820463, upload-time = "2026-08-23T14:25:56.803Z" }, + { url = "https://files.pythonhosted.org/packages/7b/7f/1a103e00aaf5e59f2dee4c2709aac609bb2d4bb74fddaf0dcfade11ed87b/nh3-0.3.7-cp314-cp314t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:4968fe8d2db97c6f047659bf46a449fd8ec377f44ebf3e0a1b96c0d3a333ae32", size = 861456, upload-time = "2026-08-23T14:25:58.087Z" }, + { url = "https://files.pythonhosted.org/packages/d8/4a/e9c436089a0c80b928011ead0efd156aa7639a19b6064ef58dcedcab8369/nh3-0.3.7-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:be53a4825585f701955cb9baf49f478f56eb81e20294329fe4bc689dd5dd81fa", size = 1023930, upload-time = "2026-08-23T14:25:59.465Z" }, + { url = "https://files.pythonhosted.org/packages/04/5c/aa1468e3e281e78d2b3b7d762ccba59f681af355e971dbd255d5903f7b86/nh3-0.3.7-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:94fd6e59553fbb9ffd8ba71bbd5a54e3126ba01799a097ae30d5341d750bc6ac", size = 1102614, upload-time = "2026-08-23T14:26:00.869Z" }, + { url = "https://files.pythonhosted.org/packages/6a/9f/57d186d9d3dd38905dc12dddb3484406cdf6aa0b1ce33639a2d277d4ee1c/nh3-0.3.7-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:18f4278ecd157d43cb35acd5aae9f35cfa79f546b4922bd86536adc0f6312102", size = 1059915, upload-time = "2026-08-23T14:26:02.388Z" }, + { url = "https://files.pythonhosted.org/packages/6b/53/097a5ad0b34b15d67a472ef849165a54209fa5fbd3e639801c6fe439ba28/nh3-0.3.7-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:808def0c8c07843e6e50dc84f532457bfa2cfd17417b219a5d9e7c773709331a", size = 1047402, upload-time = "2026-08-23T14:26:03.897Z" }, + { url = "https://files.pythonhosted.org/packages/9a/a7/c57a2c70534418310889a65ccfac3525e62f0bc0a8613225903403755ce7/nh3-0.3.7-cp314-cp314t-win32.whl", hash = "sha256:874b7d67a067bd29a59223f6270fc30da4edd8e6d87fd219fc93bcbaa662c946", size = 619895, upload-time = "2026-08-23T14:26:05.105Z" }, + { url = "https://files.pythonhosted.org/packages/e6/b7/efda1d0a611d940bdfde6893bde1ea6b7b7d48c31273aea48e35b822fd58/nh3-0.3.7-cp314-cp314t-win_amd64.whl", hash = "sha256:614dac4a4c36ad084e78447d16fe898dedd762e354a7ab9cda2984e82f67883d", size = 633456, upload-time = "2026-08-23T14:26:06.661Z" }, + { url = "https://files.pythonhosted.org/packages/1d/18/3ab564595cb88196f50d26e163ed0fd2acc731ab26ac615df91981885887/nh3-0.3.7-cp314-cp314t-win_arm64.whl", hash = "sha256:157ec1eb7a62f3d9a7badb8d82d89aa810e3e24e097eedfa481a25d0c8a99877", size = 611003, upload-time = "2026-08-23T14:26:07.813Z" }, + { url = "https://files.pythonhosted.org/packages/94/0d/c257754bf57f829f307aa226bbe136d3a1356b5a0d08324c7b6bd2a8aacd/nh3-0.3.7-cp38-abi3-macosx_10_12_x86_64.macosx_11_0_arm64.macosx_10_12_universal2.whl", hash = "sha256:6c3aa50eb26e9228238271db9f983cbc3b006dfbfeca2d4dc34c33ddc6ac5ea5", size = 1493959, upload-time = "2026-08-23T14:26:09.025Z" }, + { url = "https://files.pythonhosted.org/packages/07/42/a687e7091928806e514f89fa2666f25ec9bfe0a902fc4402b25e51ce408b/nh3-0.3.7-cp38-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f266d3f1b3647449923a8e406524632220dd5d8b647078dfe45b885d33d10479", size = 859615, upload-time = "2026-08-23T14:26:10.606Z" }, + { url = "https://files.pythonhosted.org/packages/85/05/b0e6bef633549a23347d5462aa288fcc42381e7918482062ca3cb456242a/nh3-0.3.7-cp38-abi3-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:e8fd1ab205258b29254f72db377d99e2c96aa7653ef3b015ccab0420b094b506", size = 839872, upload-time = "2026-08-23T14:26:12.037Z" }, + { url = "https://files.pythonhosted.org/packages/17/40/2a0921d45b20828708bcb56887e47dcf8cae13818de5bf9a01308d348712/nh3-0.3.7-cp38-abi3-manylinux_2_17_ppc64.manylinux2014_ppc64.whl", hash = "sha256:19f288c938ec6eef1f5d2c6cab47838e71fef8097e1c1233802be5a6230ba086", size = 1091325, upload-time = "2026-08-23T14:26:13.34Z" }, + { url = "https://files.pythonhosted.org/packages/e4/d1/9d70e0e418a48280ec0ddc6c1b08b4b1136ebcc31a1625e57ff5c665fa51/nh3-0.3.7-cp38-abi3-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:de2b2aab32ea303405debefdcfc58043d3e635fa3f67b9eb140d2b0e0c0d2563", size = 1042482, upload-time = "2026-08-23T14:26:14.667Z" }, + { url = "https://files.pythonhosted.org/packages/93/a7/02dd159d4e71f98607d8d4249cddb7561e77be1a8e4dec77d76e1b68fc99/nh3-0.3.7-cp38-abi3-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:9b7279d43323a25225df23576af6594a16693f61431170848b8b2ac21ad4f174", size = 946868, upload-time = "2026-08-23T14:26:16.094Z" }, + { url = "https://files.pythonhosted.org/packages/a6/ed/c5510c615dce55b6fcc364aa1838142f938beed64f5e4927490dfcaf4405/nh3-0.3.7-cp38-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:70f5ac8626e899a4bab0ef74ca2f5bd602f49c7b739e6e5026b4afc6d63dac42", size = 832161, upload-time = "2026-08-23T14:26:17.272Z" }, + { url = "https://files.pythonhosted.org/packages/7b/e3/3212c1a5b5745245d7f18885207bbddb34c56075f34dd682bd539aad55cc/nh3-0.3.7-cp38-abi3-manylinux_2_31_riscv64.whl", hash = "sha256:5ffdfcb9a686ffb12765376bcfb6b5b55728516d3c0ee317d29982381ded3df8", size = 849791, upload-time = "2026-08-23T14:26:18.498Z" }, + { url = "https://files.pythonhosted.org/packages/20/64/9e36594efad6c290de4240d02cb2bd80c339a4ab1c4de66e599ffa6d9d81/nh3-0.3.7-cp38-abi3-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:bc42bb1193c1e28a1e74c2cabaca178e118a7103e8832699fef8a2b3e2496493", size = 875473, upload-time = "2026-08-23T14:26:19.908Z" }, + { url = "https://files.pythonhosted.org/packages/00/0c/1a8985fd43fea5530c0ac890b6f0b423770ee72f111b70b7a77f2dec243a/nh3-0.3.7-cp38-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:d56e76bd3cadb09b6b0cef364850811663734b348a25f5f587a2819c495367bd", size = 1036463, upload-time = "2026-08-23T14:26:21.536Z" }, + { url = "https://files.pythonhosted.org/packages/b2/5d/891e533b716cf00df76ad0ba6485dcfd14d59a6430a3cc99057c4c04004e/nh3-0.3.7-cp38-abi3-musllinux_1_2_armv7l.whl", hash = "sha256:fd4a70efb45d5372174f718878eb7a35c12677626a63b2f103b23b833457dcac", size = 1116029, upload-time = "2026-08-23T14:26:22.907Z" }, + { url = "https://files.pythonhosted.org/packages/42/e5/ae8c0782fce74fb6fcf7234bb3d4017f37ce181b4f9d29369eab21c50a04/nh3-0.3.7-cp38-abi3-musllinux_1_2_i686.whl", hash = "sha256:15f5fbf090f5c88d61c820e1fc1fceecb6520cca9fe85649c06b57ef9dc9ff62", size = 1076589, upload-time = "2026-08-23T14:26:24.302Z" }, + { url = "https://files.pythonhosted.org/packages/26/a4/c3423351e8d864ad756e85e15f0c01433361f14d34e4ed156482c0518f2a/nh3-0.3.7-cp38-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:6698a822132beedab80f131c08d8d0ac5a178ddeb488d02ca4b67716ecfac7af", size = 1058871, upload-time = "2026-08-23T14:26:25.674Z" }, + { url = "https://files.pythonhosted.org/packages/4b/6a/478f153f1d7c0baaa3d1e8bb5fdcee3a6235f90fe44ea969a9d4e2b8c47a/nh3-0.3.7-cp38-abi3-win32.whl", hash = "sha256:6e4280115d44c3b278eef712a86748c1a723105cd79feec46952383117ab4e59", size = 630729, upload-time = "2026-08-23T14:26:26.932Z" }, + { url = "https://files.pythonhosted.org/packages/b4/b9/34433ccb1f0fe6968dabbb7d4bf5721c6221878ef07832748c06655a6a80/nh3-0.3.7-cp38-abi3-win_amd64.whl", hash = "sha256:618e3059caf41ccdf5dcccb3fa9df4cf6e4efe23d1382a8bbfca272a8a4f8bfc", size = 644462, upload-time = "2026-08-23T14:26:28.294Z" }, + { url = "https://files.pythonhosted.org/packages/f9/70/e140dffff6e808dc6343598df76e7e2407fd0f581de3524c75fba2e0cf24/nh3-0.3.7-cp38-abi3-win_arm64.whl", hash = "sha256:f04b7d333b27f13ca439da3cf1c75c2fba34f104969f6ce4ac8e7079699c2f4a", size = 621867, upload-time = "2026-08-23T14:26:29.547Z" }, +] + +[[package]] +name = "nodeenv" +version = "1.12.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/e6/99/d27cfc9518f49e4cbc25c683ec7cf8704a9d31311341c291c0e78ddf791b/nodeenv-1.12.0.tar.gz", hash = "sha256:4ea7f88339310afebc3253f2c7a91b94bacf97d73a36a5c108962abdfaca501e", size = 131292, upload-time = "2026-10-31T19:03:18.847Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/2d/6a/8a9ac7d5e2f7cf53c459bfef90ebc17a2f8cd54b665af96799d4c534840e/nodeenv-1.12.0-py3-none-any.whl", hash = "sha256:80644d65c10cc2be12e3e4b54b3367ff288c7ad24ae75c2dcc65454fc7449d4d", size = 39442, upload-time = "2026-10-31T19:03:17.427Z" }, +] + +[[package]] +name = "packaging" +version = "26.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/7d/fa/3944b40b07da9ce895c0e6303a5ab7d53da063554f534556b134a54d6093/packaging-26.3.tar.gz", hash = "sha256:94edc256424af38762eb31306eed28beb9f0efc50a8837492c9d6fd6004aed79", size = 313412, upload-time = "2026-08-04T18:15:28.737Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/63/34/ba1c580383c9eada3711951fef0795c80b829a078d72188184bcab9dd527/packaging-26.3-py3-none-any.whl", hash = "sha256:d7193f7c8e4e93f444fde0262bf90af30e16fa0ad0ad44cb553c87339b23cd1c", size = 129956, upload-time = "2026-08-04T18:15:27.159Z" }, +] + +[[package]] +name = "pathspec" +version = "1.1.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/5a/82/42f767fc1c1143d6fd36efb827202a2d997a375e160a71eb2888a925aac1/pathspec-1.1.1.tar.gz", hash = "sha256:17db5ecd524104a120e173814c90367a96a98d07c45b2e10c2f3919fff91bf5a", size = 135180, upload-time = "2026-04-27T01:46:08.907Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f1/d9/7fb5aa316bc299258e68c73ba3bddbc499654a07f151cba08f6153988714/pathspec-1.1.1-py3-none-any.whl", hash = "sha256:a00ce642f577bf7f473932318056212bc4f8bfdf53128c78bbd5af0b9b20b189", size = 57328, upload-time = "2026-04-27T01:46:07.06Z" }, +] + +[[package]] +name = "platformdirs" +version = "4.14.4" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/a1/f1/602599e5879fce55f44b8021d28bd3817d87198a6be63e5c9d7e31891f0d/platformdirs-4.14.4.tar.gz", hash = "sha256:edb4a4aea570d69eb83e6b0973b588bbf868fb0dde2894106d6667739f017751", size = 71235, upload-time = "2026-11-04T07:38:46.024Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/01/7c/562ddff1940562f7701a7e8b0a90a900be606af334cc5f69543293e2293a/platformdirs-4.14.4-py3-none-any.whl", hash = "sha256:89c1bfa30434b2dcc08655bcfb1789e1a6f97602c11ff990615d09a4b823d6be", size = 35357, upload-time = "2026-11-04T07:38:44.794Z" }, +] + +[[package]] +name = "pluggy" +version = "1.7.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/bf/db/7fc19e6f2dc92a966727031389fc2e08b558f0f25eb7403c1119ad4713cd/pluggy-1.7.0.tar.gz", hash = "sha256:d1eaa46ebb595891b860ab086b4d09c8588af65ebd4361b8e8f4bb8920b90ba8", size = 123304, upload-time = "2026-10-15T09:50:58.343Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/40/9e/2b38731e0fc536806f16490e1a12d7f0dc2a1235aa8cc07bcc75416a7daa/pluggy-1.7.0-py3-none-any.whl", hash = "sha256:7dd7b0d8832ba3cb632c306926ded123429211b83641b35dc5c41ad2d34f9bec", size = 27082, upload-time = "2026-10-15T09:50:56.808Z" }, +] + +[[package]] +name = "pre-commit" +version = "4.7.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "cfgv" }, + { name = "identify" }, + { name = "nodeenv" }, + { name = "pyyaml" }, + { name = "virtualenv" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/3a/c3/6965c2690ddce885ec75121572d065a5b94c5a5d8d3e657927ecda9fd715/pre_commit-4.7.0.tar.gz", hash = "sha256:1f3deee12b914c8fa184bd2b5953391c2e4f36763e403d4a23dc9983fa7c6e86", size = 198120, upload-time = "2026-10-12T20:45:40.32Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/eb/83/ce0a196e4f7b20b11ce3aa1fc72fb973f64b7628d51c1b8aebad37fb7f81/pre_commit-4.7.0-py2.py3-none-any.whl", hash = "sha256:2e229038ad3656081b70c27913157e4b636ef306f643f024a8a8e3f0f7b2f877", size = 226261, upload-time = "2026-10-12T20:45:38.858Z" }, +] + +[[package]] +name = "pycparser" +version = "3.12" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/cb/27/eeb9f307bf07060f3d9f9aa0fb8c15b01bdfded0a941e4b2719c7f94cacd/pycparser-3.12.tar.gz", hash = "sha256:f03387877eab82ce01bbdfd0ba7252ee55a90b1c708d5129e2ce915475cf1db6", size = 158785, upload-time = "2026-10-22T13:40:03.56Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b6/ae/315bbeee126a769cbde43cf4908acb4b40408d8bf8bbf334dd7368d8dadf/pycparser-3.12-py3-none-any.whl", hash = "sha256:a076f3f489b39b43ed13563a1dafe42447445bec2e294154ec5c57fcdda4c85e", size = 62600, upload-time = "2026-10-22T13:40:02.021Z" }, +] + +[[package]] +name = "pygments" +version = "2.21.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/49/2e/ced460408999b33da6b31b0021b0f37d329e202d4169aeb164493778f25b/pygments-2.21.0.tar.gz", hash = "sha256:610ca751c9bc2492b38eb9a38a7fbc93edbbb2d7182edaf34e66ae493dee5c8c", size = 5005329, upload-time = "2026-08-17T08:02:48.824Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/71/46/17f022dd3e953bf20a04a028a21ec746d942f8d2af30fa0f124fa0e6a684/pygments-2.21.0-py3-none-any.whl", hash = "sha256:2363c69b61c4a97c838da3b130dcd6468f4848992b21a82f2a63ec34377137d9", size = 1250147, upload-time = "2026-08-17T08:02:44.912Z" }, +] + +[[package]] +name = "pyproject-hooks" +version = "1.3.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/6d/5d/f2ddeef4a855a102aaae5e97826a0260007522ab504421b75addfdb1517c/pyproject_hooks-1.3.3.tar.gz", hash = "sha256:defda19b854fa0d3bd4f76ea4ddcba8abd7dcfcdd585a6690ade050744fc5f43", size = 21013, upload-time = "2026-09-16T08:58:03.999Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/85/11/044d1ae1b4ec0d7af88ee5bc91e081be1022533032b906a7bdabdbb60977/pyproject_hooks-1.3.3-py3-none-any.whl", hash = "sha256:5fc53fdac9f7bd63fbcdc868fb5f90b4784d78a53a3d3388cd738b807441a20b", size = 10724, upload-time = "2026-09-16T08:58:02.96Z" }, +] + +[[package]] +name = "pytest" +version = "9.2.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "colorama", marker = "sys_platform == 'win32'" }, + { name = "iniconfig" }, + { name = "packaging" }, + { name = "pluggy" }, + { name = "pygments" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/79/42/bb4641652e58dedeac2ec51abc1f8cae4fee4ec63899a0999016229a0f2a/pytest-9.2.0.tar.gz", hash = "sha256:97c4f3b1f3c7414aa36465e09b8220f1d03627993bd51b1282e193753c80557b", size = 1797555, upload-time = "2026-10-27T21:30:20.728Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/51/39/1f5d8c8877a0fa327db959c19341d4be61660de1ab6b7391f9eb805bcd67/pytest-9.2.0-py3-none-any.whl", hash = "sha256:07acdcf88ec174f907dc01af70bf52d49b014bbab03faeeade31c96b18c2e588", size = 411776, upload-time = "2026-10-27T21:30:19.131Z" }, +] + +[[package]] +name = "pytest-cov" +version = "7.1.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "coverage" }, + { name = "pluggy" }, + { name = "pytest" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/b1/51/a849f96e117386044471c8ec2bd6cfebacda285da9525c9106aeb28da671/pytest_cov-7.1.0.tar.gz", hash = "sha256:30674f2b5f6351aa09702a9c8c364f6a01c27aae0c1366ae8016160d1efc56b2", size = 55592, upload-time = "2026-03-21T20:11:16.284Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9d/7a/d968e294073affff457b041c2be9868a40c1c71f4a35fcc1e45e5493067b/pytest_cov-7.1.0-py3-none-any.whl", hash = "sha256:a0461110b7865f9a271aa1b51e516c9a95de9d696734a2f71e3e78f46e1d4678", size = 22876, upload-time = "2026-03-21T20:11:14.438Z" }, +] + +[[package]] +name = "python-box" +source = { editable = "." } + +[package.optional-dependencies] +all = [ + { name = "msgpack" }, + { name = "ruamel-yaml" }, + { name = "toml" }, +] +msgpack = [ + { name = "msgpack" }, +] +pyyaml = [ + { name = "pyyaml" }, +] +ruamel-yaml = [ + { name = "ruamel-yaml" }, +] +toml = [ + { name = "toml" }, +] +tomli = [ + { name = "tomli-w" }, +] +yaml = [ + { name = "ruamel-yaml" }, +] + +[package.dev-dependencies] +dev = [ + { name = "build" }, + { name = "coverage" }, + { name = "cython" }, + { name = "msgpack" }, + { name = "mypy" }, + { name = "pre-commit" }, + { name = "pytest" }, + { name = "pytest-cov" }, + { name = "ruamel-yaml" }, + { name = "ruff" }, + { name = "setuptools" }, + { name = "tomli-w" }, + { name = "toon-format" }, + { name = "twine" }, + { name = "types-pyyaml" }, + { name = "wheel" }, +] +test = [ + { name = "coverage" }, + { name = "msgpack" }, + { name = "pytest" }, + { name = "pytest-cov" }, + { name = "ruamel-yaml" }, + { name = "tomli-w" }, + { name = "toon-format" }, + { name = "types-pyyaml" }, +] + +[package.metadata] +requires-dist = [ + { name = "msgpack", marker = "extra == 'all'" }, + { name = "msgpack", marker = "extra == 'msgpack'" }, + { name = "pyyaml", marker = "extra == 'pyyaml'" }, + { name = "ruamel-yaml", marker = "extra == 'all'", specifier = ">=0.19.1" }, + { name = "ruamel-yaml", marker = "extra == 'ruamel-yaml'", specifier = ">=0.19.1" }, + { name = "ruamel-yaml", marker = "extra == 'yaml'", specifier = ">=0.19.1" }, + { name = "toml", marker = "extra == 'all'" }, + { name = "toml", marker = "extra == 'toml'" }, + { name = "tomli-w", marker = "extra == 'tomli'" }, +] +provides-extras = ["all", "yaml", "ruamel-yaml", "pyyaml", "tomli", "toml", "msgpack"] + +[package.metadata.requires-dev] +dev = [ + { name = "build", specifier = ">=1.6.1" }, + { name = "coverage", specifier = ">=7.17.1" }, + { name = "cython", specifier = ">=3.3.1" }, + { name = "msgpack", specifier = ">=1.2.4" }, + { name = "mypy", specifier = ">=2.4.1" }, + { name = "pre-commit", specifier = ">=4.7.0" }, + { name = "pytest", specifier = ">=9.2.0" }, + { name = "pytest-cov", specifier = ">=7.1.0" }, + { name = "ruamel-yaml", specifier = ">=0.19.1" }, + { name = "ruff", specifier = ">=0.17.3" }, + { name = "setuptools", specifier = ">=84.2.1" }, + { name = "tomli-w", specifier = ">=1.2.0" }, + { name = "toon-format", specifier = ">=1.2.0" }, + { name = "twine", specifier = ">=7.0.0" }, + { name = "types-pyyaml", specifier = ">=6.0.12.20261103" }, + { name = "wheel", specifier = ">=0.48.0" }, +] +test = [ + { name = "coverage", specifier = ">=7.17.1" }, + { name = "msgpack", specifier = ">=1.2.4" }, + { name = "pytest", specifier = ">=9.2.0" }, + { name = "pytest-cov", specifier = ">=7.1.0" }, + { name = "ruamel-yaml", specifier = ">=0.19.1" }, + { name = "tomli-w", specifier = ">=1.2.0" }, + { name = "toon-format", specifier = ">=1.2.0" }, + { name = "types-pyyaml", specifier = ">=6.0.12.20261103" }, +] + +[[package]] +name = "python-discovery" +version = "1.9.4" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "filelock" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/0f/d7/1e94df7d1636bf00b9f261bf88a4adc0414f14931ff60511eb0f34c250d1/python_discovery-1.9.4.tar.gz", hash = "sha256:c01b45fe515c1d268b57c57d554bb0e1d320b8e9eb5490bb2f4f577be26e4380", size = 140385, upload-time = "2026-11-04T05:25:52.097Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c5/44/b248f3b1a23f44d8de172e2767748082c41cbd9353009af72f4b11b00afa/python_discovery-1.9.4-py3-none-any.whl", hash = "sha256:b468f365040b40f4cb39918b0766d3e5a2f340968e07df752fbc96f1bb4641ab", size = 44220, upload-time = "2026-11-04T05:25:50.514Z" }, +] + +[[package]] +name = "pywin32-ctypes" +version = "0.2.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/85/9f/01a1a99704853cb63f253eea009390c88e7131c67e66a0a02099a8c917cb/pywin32-ctypes-0.2.3.tar.gz", hash = "sha256:d162dc04946d704503b2edc4d55f3dba5c1d539ead017afa00142c38b9885755", size = 29471, upload-time = "2024-08-14T10:15:34.626Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/de/3d/8161f7711c017e01ac9f008dfddd9410dff3674334c233bde66e7ba65bbf/pywin32_ctypes-0.2.3-py3-none-any.whl", hash = "sha256:8a1513379d709975552d202d942d9837758905c8d01eb82b8bcc30918929e7b8", size = 30756, upload-time = "2024-08-14T10:15:33.187Z" }, +] + +[[package]] +name = "pyyaml" +version = "6.0.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/05/8e/961c0007c59b8dd7729d542c61a4d537767a59645b82a0b521206e1e25c2/pyyaml-6.0.3.tar.gz", hash = "sha256:d76623373421df22fb4cf8817020cbb7ef15c725b9d5e45f17e189bfc384190f", size = 130960, upload-time = "2025-09-25T21:33:16.546Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/6d/16/a95b6757765b7b031c9374925bb718d55e0a9ba8a1b6a12d25962ea44347/pyyaml-6.0.3-cp311-cp311-macosx_10_13_x86_64.whl", hash = "sha256:44edc647873928551a01e7a563d7452ccdebee747728c1080d881d68af7b997e", size = 185826, upload-time = "2025-09-25T21:31:58.655Z" }, + { url = "https://files.pythonhosted.org/packages/16/19/13de8e4377ed53079ee996e1ab0a9c33ec2faf808a4647b7b4c0d46dd239/pyyaml-6.0.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:652cb6edd41e718550aad172851962662ff2681490a8a711af6a4d288dd96824", size = 175577, upload-time = "2025-09-25T21:32:00.088Z" }, + { url = "https://files.pythonhosted.org/packages/0c/62/d2eb46264d4b157dae1275b573017abec435397aa59cbcdab6fc978a8af4/pyyaml-6.0.3-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:10892704fc220243f5305762e276552a0395f7beb4dbf9b14ec8fd43b57f126c", size = 775556, upload-time = "2025-09-25T21:32:01.31Z" }, + { url = "https://files.pythonhosted.org/packages/10/cb/16c3f2cf3266edd25aaa00d6c4350381c8b012ed6f5276675b9eba8d9ff4/pyyaml-6.0.3-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:850774a7879607d3a6f50d36d04f00ee69e7fc816450e5f7e58d7f17f1ae5c00", size = 882114, upload-time = "2025-09-25T21:32:03.376Z" }, + { url = "https://files.pythonhosted.org/packages/71/60/917329f640924b18ff085ab889a11c763e0b573da888e8404ff486657602/pyyaml-6.0.3-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b8bb0864c5a28024fac8a632c443c87c5aa6f215c0b126c449ae1a150412f31d", size = 806638, upload-time = "2025-09-25T21:32:04.553Z" }, + { url = "https://files.pythonhosted.org/packages/dd/6f/529b0f316a9fd167281a6c3826b5583e6192dba792dd55e3203d3f8e655a/pyyaml-6.0.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:1d37d57ad971609cf3c53ba6a7e365e40660e3be0e5175fa9f2365a379d6095a", size = 767463, upload-time = "2025-09-25T21:32:06.152Z" }, + { url = "https://files.pythonhosted.org/packages/f2/6a/b627b4e0c1dd03718543519ffb2f1deea4a1e6d42fbab8021936a4d22589/pyyaml-6.0.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:37503bfbfc9d2c40b344d06b2199cf0e96e97957ab1c1b546fd4f87e53e5d3e4", size = 794986, upload-time = "2025-09-25T21:32:07.367Z" }, + { url = "https://files.pythonhosted.org/packages/45/91/47a6e1c42d9ee337c4839208f30d9f09caa9f720ec7582917b264defc875/pyyaml-6.0.3-cp311-cp311-win32.whl", hash = "sha256:8098f252adfa6c80ab48096053f512f2321f0b998f98150cea9bd23d83e1467b", size = 142543, upload-time = "2025-09-25T21:32:08.95Z" }, + { url = "https://files.pythonhosted.org/packages/da/e3/ea007450a105ae919a72393cb06f122f288ef60bba2dc64b26e2646fa315/pyyaml-6.0.3-cp311-cp311-win_amd64.whl", hash = "sha256:9f3bfb4965eb874431221a3ff3fdcddc7e74e3b07799e0e84ca4a0f867d449bf", size = 158763, upload-time = "2025-09-25T21:32:09.96Z" }, + { url = "https://files.pythonhosted.org/packages/d1/33/422b98d2195232ca1826284a76852ad5a86fe23e31b009c9886b2d0fb8b2/pyyaml-6.0.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:7f047e29dcae44602496db43be01ad42fc6f1cc0d8cd6c83d342306c32270196", size = 182063, upload-time = "2025-09-25T21:32:11.445Z" }, + { url = "https://files.pythonhosted.org/packages/89/a0/6cf41a19a1f2f3feab0e9c0b74134aa2ce6849093d5517a0c550fe37a648/pyyaml-6.0.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:fc09d0aa354569bc501d4e787133afc08552722d3ab34836a80547331bb5d4a0", size = 173973, upload-time = "2025-09-25T21:32:12.492Z" }, + { url = "https://files.pythonhosted.org/packages/ed/23/7a778b6bd0b9a8039df8b1b1d80e2e2ad78aa04171592c8a5c43a56a6af4/pyyaml-6.0.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9149cad251584d5fb4981be1ecde53a1ca46c891a79788c0df828d2f166bda28", size = 775116, upload-time = "2025-09-25T21:32:13.652Z" }, + { url = "https://files.pythonhosted.org/packages/65/30/d7353c338e12baef4ecc1b09e877c1970bd3382789c159b4f89d6a70dc09/pyyaml-6.0.3-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5fdec68f91a0c6739b380c83b951e2c72ac0197ace422360e6d5a959d8d97b2c", size = 844011, upload-time = "2025-09-25T21:32:15.21Z" }, + { url = "https://files.pythonhosted.org/packages/8b/9d/b3589d3877982d4f2329302ef98a8026e7f4443c765c46cfecc8858c6b4b/pyyaml-6.0.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ba1cc08a7ccde2d2ec775841541641e4548226580ab850948cbfda66a1befcdc", size = 807870, upload-time = "2025-09-25T21:32:16.431Z" }, + { url = "https://files.pythonhosted.org/packages/05/c0/b3be26a015601b822b97d9149ff8cb5ead58c66f981e04fedf4e762f4bd4/pyyaml-6.0.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:8dc52c23056b9ddd46818a57b78404882310fb473d63f17b07d5c40421e47f8e", size = 761089, upload-time = "2025-09-25T21:32:17.56Z" }, + { url = "https://files.pythonhosted.org/packages/be/8e/98435a21d1d4b46590d5459a22d88128103f8da4c2d4cb8f14f2a96504e1/pyyaml-6.0.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:41715c910c881bc081f1e8872880d3c650acf13dfa8214bad49ed4cede7c34ea", size = 790181, upload-time = "2025-09-25T21:32:18.834Z" }, + { url = "https://files.pythonhosted.org/packages/74/93/7baea19427dcfbe1e5a372d81473250b379f04b1bd3c4c5ff825e2327202/pyyaml-6.0.3-cp312-cp312-win32.whl", hash = "sha256:96b533f0e99f6579b3d4d4995707cf36df9100d67e0c8303a0c55b27b5f99bc5", size = 137658, upload-time = "2025-09-25T21:32:20.209Z" }, + { url = "https://files.pythonhosted.org/packages/86/bf/899e81e4cce32febab4fb42bb97dcdf66bc135272882d1987881a4b519e9/pyyaml-6.0.3-cp312-cp312-win_amd64.whl", hash = "sha256:5fcd34e47f6e0b794d17de1b4ff496c00986e1c83f7ab2fb8fcfe9616ff7477b", size = 154003, upload-time = "2025-09-25T21:32:21.167Z" }, + { url = "https://files.pythonhosted.org/packages/1a/08/67bd04656199bbb51dbed1439b7f27601dfb576fb864099c7ef0c3e55531/pyyaml-6.0.3-cp312-cp312-win_arm64.whl", hash = "sha256:64386e5e707d03a7e172c0701abfb7e10f0fb753ee1d773128192742712a98fd", size = 140344, upload-time = "2025-09-25T21:32:22.617Z" }, + { url = "https://files.pythonhosted.org/packages/d1/11/0fd08f8192109f7169db964b5707a2f1e8b745d4e239b784a5a1dd80d1db/pyyaml-6.0.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:8da9669d359f02c0b91ccc01cac4a67f16afec0dac22c2ad09f46bee0697eba8", size = 181669, upload-time = "2025-09-25T21:32:23.673Z" }, + { url = "https://files.pythonhosted.org/packages/b1/16/95309993f1d3748cd644e02e38b75d50cbc0d9561d21f390a76242ce073f/pyyaml-6.0.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:2283a07e2c21a2aa78d9c4442724ec1eb15f5e42a723b99cb3d822d48f5f7ad1", size = 173252, upload-time = "2025-09-25T21:32:25.149Z" }, + { url = "https://files.pythonhosted.org/packages/50/31/b20f376d3f810b9b2371e72ef5adb33879b25edb7a6d072cb7ca0c486398/pyyaml-6.0.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ee2922902c45ae8ccada2c5b501ab86c36525b883eff4255313a253a3160861c", size = 767081, upload-time = "2025-09-25T21:32:26.575Z" }, + { url = "https://files.pythonhosted.org/packages/49/1e/a55ca81e949270d5d4432fbbd19dfea5321eda7c41a849d443dc92fd1ff7/pyyaml-6.0.3-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a33284e20b78bd4a18c8c2282d549d10bc8408a2a7ff57653c0cf0b9be0afce5", size = 841159, upload-time = "2025-09-25T21:32:27.727Z" }, + { url = "https://files.pythonhosted.org/packages/74/27/e5b8f34d02d9995b80abcef563ea1f8b56d20134d8f4e5e81733b1feceb2/pyyaml-6.0.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0f29edc409a6392443abf94b9cf89ce99889a1dd5376d94316ae5145dfedd5d6", size = 801626, upload-time = "2025-09-25T21:32:28.878Z" }, + { url = "https://files.pythonhosted.org/packages/f9/11/ba845c23988798f40e52ba45f34849aa8a1f2d4af4b798588010792ebad6/pyyaml-6.0.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:f7057c9a337546edc7973c0d3ba84ddcdf0daa14533c2065749c9075001090e6", size = 753613, upload-time = "2025-09-25T21:32:30.178Z" }, + { url = "https://files.pythonhosted.org/packages/3d/e0/7966e1a7bfc0a45bf0a7fb6b98ea03fc9b8d84fa7f2229e9659680b69ee3/pyyaml-6.0.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:eda16858a3cab07b80edaf74336ece1f986ba330fdb8ee0d6c0d68fe82bc96be", size = 794115, upload-time = "2025-09-25T21:32:31.353Z" }, + { url = "https://files.pythonhosted.org/packages/de/94/980b50a6531b3019e45ddeada0626d45fa85cbe22300844a7983285bed3b/pyyaml-6.0.3-cp313-cp313-win32.whl", hash = "sha256:d0eae10f8159e8fdad514efdc92d74fd8d682c933a6dd088030f3834bc8e6b26", size = 137427, upload-time = "2025-09-25T21:32:32.58Z" }, + { url = "https://files.pythonhosted.org/packages/97/c9/39d5b874e8b28845e4ec2202b5da735d0199dbe5b8fb85f91398814a9a46/pyyaml-6.0.3-cp313-cp313-win_amd64.whl", hash = "sha256:79005a0d97d5ddabfeeea4cf676af11e647e41d81c9a7722a193022accdb6b7c", size = 154090, upload-time = "2025-09-25T21:32:33.659Z" }, + { url = "https://files.pythonhosted.org/packages/73/e8/2bdf3ca2090f68bb3d75b44da7bbc71843b19c9f2b9cb9b0f4ab7a5a4329/pyyaml-6.0.3-cp313-cp313-win_arm64.whl", hash = "sha256:5498cd1645aa724a7c71c8f378eb29ebe23da2fc0d7a08071d89469bf1d2defb", size = 140246, upload-time = "2025-09-25T21:32:34.663Z" }, + { url = "https://files.pythonhosted.org/packages/9d/8c/f4bd7f6465179953d3ac9bc44ac1a8a3e6122cf8ada906b4f96c60172d43/pyyaml-6.0.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:8d1fab6bb153a416f9aeb4b8763bc0f22a5586065f86f7664fc23339fc1c1fac", size = 181814, upload-time = "2025-09-25T21:32:35.712Z" }, + { url = "https://files.pythonhosted.org/packages/bd/9c/4d95bb87eb2063d20db7b60faa3840c1b18025517ae857371c4dd55a6b3a/pyyaml-6.0.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:34d5fcd24b8445fadc33f9cf348c1047101756fd760b4dacb5c3e99755703310", size = 173809, upload-time = "2025-09-25T21:32:36.789Z" }, + { url = "https://files.pythonhosted.org/packages/92/b5/47e807c2623074914e29dabd16cbbdd4bf5e9b2db9f8090fa64411fc5382/pyyaml-6.0.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:501a031947e3a9025ed4405a168e6ef5ae3126c59f90ce0cd6f2bfc477be31b7", size = 766454, upload-time = "2025-09-25T21:32:37.966Z" }, + { url = "https://files.pythonhosted.org/packages/02/9e/e5e9b168be58564121efb3de6859c452fccde0ab093d8438905899a3a483/pyyaml-6.0.3-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:b3bc83488de33889877a0f2543ade9f70c67d66d9ebb4ac959502e12de895788", size = 836355, upload-time = "2025-09-25T21:32:39.178Z" }, + { url = "https://files.pythonhosted.org/packages/88/f9/16491d7ed2a919954993e48aa941b200f38040928474c9e85ea9e64222c3/pyyaml-6.0.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c458b6d084f9b935061bc36216e8a69a7e293a2f1e68bf956dcd9e6cbcd143f5", size = 794175, upload-time = "2025-09-25T21:32:40.865Z" }, + { url = "https://files.pythonhosted.org/packages/dd/3f/5989debef34dc6397317802b527dbbafb2b4760878a53d4166579111411e/pyyaml-6.0.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:7c6610def4f163542a622a73fb39f534f8c101d690126992300bf3207eab9764", size = 755228, upload-time = "2025-09-25T21:32:42.084Z" }, + { url = "https://files.pythonhosted.org/packages/d7/ce/af88a49043cd2e265be63d083fc75b27b6ed062f5f9fd6cdc223ad62f03e/pyyaml-6.0.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:5190d403f121660ce8d1d2c1bb2ef1bd05b5f68533fc5c2ea899bd15f4399b35", size = 789194, upload-time = "2025-09-25T21:32:43.362Z" }, + { url = "https://files.pythonhosted.org/packages/23/20/bb6982b26a40bb43951265ba29d4c246ef0ff59c9fdcdf0ed04e0687de4d/pyyaml-6.0.3-cp314-cp314-win_amd64.whl", hash = "sha256:4a2e8cebe2ff6ab7d1050ecd59c25d4c8bd7e6f400f5f82b96557ac0abafd0ac", size = 156429, upload-time = "2025-09-25T21:32:57.844Z" }, + { url = "https://files.pythonhosted.org/packages/f4/f4/a4541072bb9422c8a883ab55255f918fa378ecf083f5b85e87fc2b4eda1b/pyyaml-6.0.3-cp314-cp314-win_arm64.whl", hash = "sha256:93dda82c9c22deb0a405ea4dc5f2d0cda384168e466364dec6255b293923b2f3", size = 143912, upload-time = "2025-09-25T21:32:59.247Z" }, + { url = "https://files.pythonhosted.org/packages/7c/f9/07dd09ae774e4616edf6cda684ee78f97777bdd15847253637a6f052a62f/pyyaml-6.0.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:02893d100e99e03eda1c8fd5c441d8c60103fd175728e23e431db1b589cf5ab3", size = 189108, upload-time = "2025-09-25T21:32:44.377Z" }, + { url = "https://files.pythonhosted.org/packages/4e/78/8d08c9fb7ce09ad8c38ad533c1191cf27f7ae1effe5bb9400a46d9437fcf/pyyaml-6.0.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:c1ff362665ae507275af2853520967820d9124984e0f7466736aea23d8611fba", size = 183641, upload-time = "2025-09-25T21:32:45.407Z" }, + { url = "https://files.pythonhosted.org/packages/7b/5b/3babb19104a46945cf816d047db2788bcaf8c94527a805610b0289a01c6b/pyyaml-6.0.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6adc77889b628398debc7b65c073bcb99c4a0237b248cacaf3fe8a557563ef6c", size = 831901, upload-time = "2025-09-25T21:32:48.83Z" }, + { url = "https://files.pythonhosted.org/packages/8b/cc/dff0684d8dc44da4d22a13f35f073d558c268780ce3c6ba1b87055bb0b87/pyyaml-6.0.3-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a80cb027f6b349846a3bf6d73b5e95e782175e52f22108cfa17876aaeff93702", size = 861132, upload-time = "2025-09-25T21:32:50.149Z" }, + { url = "https://files.pythonhosted.org/packages/b1/5e/f77dc6b9036943e285ba76b49e118d9ea929885becb0a29ba8a7c75e29fe/pyyaml-6.0.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:00c4bdeba853cc34e7dd471f16b4114f4162dc03e6b7afcc2128711f0eca823c", size = 839261, upload-time = "2025-09-25T21:32:51.808Z" }, + { url = "https://files.pythonhosted.org/packages/ce/88/a9db1376aa2a228197c58b37302f284b5617f56a5d959fd1763fb1675ce6/pyyaml-6.0.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:66e1674c3ef6f541c35191caae2d429b967b99e02040f5ba928632d9a7f0f065", size = 805272, upload-time = "2025-09-25T21:32:52.941Z" }, + { url = "https://files.pythonhosted.org/packages/da/92/1446574745d74df0c92e6aa4a7b0b3130706a4142b2d1a5869f2eaa423c6/pyyaml-6.0.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:16249ee61e95f858e83976573de0f5b2893b3677ba71c9dd36b9cf8be9ac6d65", size = 829923, upload-time = "2025-09-25T21:32:54.537Z" }, + { url = "https://files.pythonhosted.org/packages/f0/7a/1c7270340330e575b92f397352af856a8c06f230aa3e76f86b39d01b416a/pyyaml-6.0.3-cp314-cp314t-win_amd64.whl", hash = "sha256:4ad1906908f2f5ae4e5a8ddfce73c320c2a1429ec52eafd27138b7f1cbe341c9", size = 174062, upload-time = "2025-09-25T21:32:55.767Z" }, + { url = "https://files.pythonhosted.org/packages/f1/12/de94a39c2ef588c7e6455cfbe7343d3b2dc9d6b6b2f40c4c6565744c873d/pyyaml-6.0.3-cp314-cp314t-win_arm64.whl", hash = "sha256:ebc55a14a21cb14062aa4162f906cd962b28e2e9ea38f9b4391244cd8de4ae0b", size = 149341, upload-time = "2025-09-25T21:32:56.828Z" }, +] + +[[package]] +name = "readme-renderer" +version = "46.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "docutils" }, + { name = "nh3" }, + { name = "pygments" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/25/d7/9309494fad74ee831d4546f69325b5519f37c6dfb2d9ba495db8c6d4f4ca/readme_renderer-46.0.tar.gz", hash = "sha256:af3e964914f6310a33ff67b72a4bdd940bed8d7c3bdecd2d14f40edf284bfe90", size = 38382, upload-time = "2026-08-28T15:18:32.49Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/4b/72/ac5ca81fe9121fcaa9d828d21017cba00a16a98e4ea5fb60c878f93dda4f/readme_renderer-46.0-py3-none-any.whl", hash = "sha256:d0dae1f74bb273b534770cb4cccb6bb78735540afdb03c2146f4e19dcd412560", size = 14239, upload-time = "2026-08-28T15:18:31.132Z" }, +] + +[[package]] +name = "requests" +version = "2.34.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "certifi" }, + { name = "charset-normalizer" }, + { name = "idna" }, + { name = "urllib3" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/ac/c3/e2a2b89f2d3e2179abd6d00ebd70bff6273f37fb3e0cc209f48b39d00cbf/requests-2.34.2.tar.gz", hash = "sha256:f288924cae4e29463698d6d60bc6a4da69c89185ad1e0bcc4104f584e960b9ed", size = 142856, upload-time = "2026-05-14T19:25:27.735Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a0/f4/c67b0b3f1b9245e8d266f0f112c500d50e5b4e83cb6f3b71b6528104182a/requests-2.34.2-py3-none-any.whl", hash = "sha256:2a0d60c172f83ac6ab31e4554906c0f3b3588d37b5cb939b1c061f4907e278e0", size = 73075, upload-time = "2026-05-14T19:25:26.443Z" }, +] + +[[package]] +name = "requests-toolbelt" +version = "1.0.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "requests" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/f3/61/d7545dafb7ac2230c70d38d31cbfe4cc64f7144dc41f6e4e4b78ecd9f5bb/requests-toolbelt-1.0.0.tar.gz", hash = "sha256:7681a0a3d047012b5bdc0ee37d7f8f07ebe76ab08caeccfc3921ce23c88d5bc6", size = 206888, upload-time = "2023-05-01T04:11:33.229Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/3f/51/d4db610ef29373b879047326cbf6fa98b6c1969d6f6dc423279de2b1be2c/requests_toolbelt-1.0.0-py2.py3-none-any.whl", hash = "sha256:cccfdd665f0a24fcf4726e690f65639d272bb0637b9b92dfd91a5568ccf6bd06", size = 54481, upload-time = "2023-05-01T04:11:28.427Z" }, +] + +[[package]] +name = "rfc3986" +version = "2.0.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/85/40/1520d68bfa07ab5a6f065a186815fb6610c86fe957bc065754e47f7b0840/rfc3986-2.0.0.tar.gz", hash = "sha256:97aacf9dbd4bfd829baad6e6309fa6573aaf1be3f6fa735c8ab05e46cecb261c", size = 49026, upload-time = "2022-01-10T00:52:30.832Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ff/9a/9afaade874b2fa6c752c36f1548f718b5b83af81ed9b76628329dab81c1b/rfc3986-2.0.0-py2.py3-none-any.whl", hash = "sha256:50b1502b60e289cb37883f3dfd34532b8873c7de9f49bb546641ce9cbd256ebd", size = 31326, upload-time = "2022-01-10T00:52:29.594Z" }, +] + +[[package]] +name = "rich" +version = "15.0.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "markdown-it-py" }, + { name = "pygments" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/c0/8f/0722ca900cc807c13a6a0c696dacf35430f72e0ec571c4275d2371fca3e9/rich-15.0.0.tar.gz", hash = "sha256:edd07a4824c6b40189fb7ac9bc4c52536e9780fbbfbddf6f1e2502c31b068c36", size = 230680, upload-time = "2026-04-12T08:24:00.75Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/82/3b/64d4899d73f91ba49a8c18a8ff3f0ea8f1c1d75481760df8c68ef5235bf5/rich-15.0.0-py3-none-any.whl", hash = "sha256:33bd4ef74232fb73fe9279a257718407f169c09b78a87ad3d296f548e27de0bb", size = 310654, upload-time = "2026-04-12T08:24:02.83Z" }, +] + +[[package]] +name = "ruamel-yaml" +version = "0.19.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/c7/3b/ebda527b56beb90cb7652cb1c7e4f91f48649fbcd8d2eb2fb6e77cd3329b/ruamel_yaml-0.19.1.tar.gz", hash = "sha256:53eb66cd27849eff968ebf8f0bf61f46cdac2da1d1f3576dd4ccee9b25c31993", size = 142709, upload-time = "2026-01-02T16:50:31.84Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b8/0c/51f6841f1d84f404f92463fc2b1ba0da357ca1e3db6b7fbda26956c3b82a/ruamel_yaml-0.19.1-py3-none-any.whl", hash = "sha256:27592957fedf6e0b62f281e96effd28043345e0e66001f97683aa9a40c667c93", size = 118102, upload-time = "2026-01-02T16:50:29.201Z" }, +] + +[[package]] +name = "ruff" +version = "0.17.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/59/73/81f140c4edd9cc323de5478e6bbd3bbcfae9a82692df1a258de8cec6a6d2/ruff-0.17.3.tar.gz", hash = "sha256:a57049c8addb3662073859bb55a7ad35aa54f8a7c9ed268911d1333c5aadaaa9", size = 5339444, upload-time = "2026-10-27T00:34:05.914Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9e/8c/083365310c4e79c842f25bf5a842facbd9b0c0ec336f96dffa5074fe723d/ruff-0.17.3-py3-none-linux_armv6l.whl", hash = "sha256:ab86b84cd9d05e56d329742c0cabdcbe2d1d56c98f4a04aab9b5b66196febfb4", size = 10216522, upload-time = "2026-10-27T00:33:29.822Z" }, + { url = "https://files.pythonhosted.org/packages/72/26/4b2edf31cfebe9605d8f6ed8f1d6f376d3a53d4c9a123e62661c64c440f0/ruff-0.17.3-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:e407b4a6852853a9a2cdce96963e94ad9775578bb44e7561a0f2829f3cc04b11", size = 10217786, upload-time = "2026-10-27T00:33:33.949Z" }, + { url = "https://files.pythonhosted.org/packages/a2/7e/537aba4b7f54397a374d2f6a6fc93e9c8015e18553f31a4a7b7dbced48b5/ruff-0.17.3-py3-none-macosx_11_0_arm64.whl", hash = "sha256:b75cc113b3aca388933d8296b667b1ac401a80317ea3074c9b0a66541199da29", size = 9440362, upload-time = "2026-10-27T00:33:35.784Z" }, + { url = "https://files.pythonhosted.org/packages/3d/66/283e39734f66c8a5ebaa93c22eb7b7515779a0b1d5a5c0ad20e05c0edb41/ruff-0.17.3-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ab5fa7ed5ce18554ea69d850ad162cbaa0c85fc47c08d83a569f806681c9a6ad", size = 10094281, upload-time = "2026-10-27T00:33:38.216Z" }, + { url = "https://files.pythonhosted.org/packages/21/4c/1ffc768497bd025a32c72152771e40c0b99bddc5cc6e4f50c7949a395346/ruff-0.17.3-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:c673c170e27834d1262e3a9c1e97bdc9b9c3b180c63d89173ce69747232474c1", size = 10022543, upload-time = "2026-10-27T00:33:40.181Z" }, + { url = "https://files.pythonhosted.org/packages/73/c3/f90db547301080fcb82c92abf914c8bd57b89911d9b65a6c4cc6b52d0635/ruff-0.17.3-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:6a754c0341bc9ca151b7b335988b3263921c08859f84ca219b70cee825571b6f", size = 10683921, upload-time = "2026-10-27T00:33:42.182Z" }, + { url = "https://files.pythonhosted.org/packages/e5/98/92d4a8a26c6c96cf1a5b34dd59036d8a71e52d650aab065c58867e964e63/ruff-0.17.3-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4590b9d86c0b1543ebb09094254e191cd43fe8edaf330baa035aab03da251532", size = 11373408, upload-time = "2026-10-27T00:33:44.19Z" }, + { url = "https://files.pythonhosted.org/packages/43/02/1f24d2e3064c9753926deeb901afa57777b37ee46799b09ddd7aee6e5145/ruff-0.17.3-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:bbde18beccd98c29a227c63c99022e3443b99258e08326df6425dfe0443705ef", size = 10977469, upload-time = "2026-10-27T00:33:46.179Z" }, + { url = "https://files.pythonhosted.org/packages/f0/20/fecedea2209f574ab92033b344e01a7f0c2dc76c6d6d19a14c9f8141173f/ruff-0.17.3-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7fa4b0f931cdbcb8a52044f370a3eb429fb42eb88807b0e800fcaa98dd42b24e", size = 10577491, upload-time = "2026-10-27T00:33:48.233Z" }, + { url = "https://files.pythonhosted.org/packages/33/36/b93fdf0bc6f84f0cd487aadfb0354deb40013669ea35ac3d26855de1e959/ruff-0.17.3-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:39405f341deec934b4289634324ad695f72df2970f9121582872eaf5b722f0f5", size = 10608748, upload-time = "2026-10-27T00:33:50.284Z" }, + { url = "https://files.pythonhosted.org/packages/5d/b7/7d3f5f14145daead1efb0b9a8289ed1daa100f419d60774375951723ce00/ruff-0.17.3-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:68074094f55ca3d29ab19491f640282f7a84061c4c7977aa5094b968ca457e9a", size = 10075057, upload-time = "2026-10-27T00:33:52.074Z" }, + { url = "https://files.pythonhosted.org/packages/b0/ed/93ff7a5909ee56e2bd4b982deae9e0efb2724417874a90c9e41ad66c6dd7/ruff-0.17.3-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:27bb571ac78fef178fe5118d2827df95c2aae74a48fff2b15f6acd03af5ff5bb", size = 10022431, upload-time = "2026-10-27T00:33:54.061Z" }, + { url = "https://files.pythonhosted.org/packages/9b/07/a83b9eeec8c1c3c0e4eda15f06c3a91001bfd2687ea2f07b750719bf9712/ruff-0.17.3-py3-none-musllinux_1_2_i686.whl", hash = "sha256:029c37cbd3de48ca37aa12117bead2d065f15da17d66bf84e0d4274013705db2", size = 10394903, upload-time = "2026-10-27T00:33:56.158Z" }, + { url = "https://files.pythonhosted.org/packages/af/b2/05c39857c2526fcbebe46ad93a8dc97424656dfef14d3ef933abe1ffd331/ruff-0.17.3-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:692fdb46d0fd9c71e380947dc5fc72f2c3f881073bc1f739e4579376231affbe", size = 10799780, upload-time = "2026-10-27T00:33:58.204Z" }, + { url = "https://files.pythonhosted.org/packages/ec/d9/47171a16739eb7a353936b31c20cf54340531e68c9af7d72fd7a784e235d/ruff-0.17.3-py3-none-win32.whl", hash = "sha256:46539cb031b01fd29ae0a02142483c46640b233ee12bb1c1b690bffa1555d5ca", size = 9908481, upload-time = "2026-10-27T00:34:00.087Z" }, + { url = "https://files.pythonhosted.org/packages/d0/a0/f08c1631bfd81faa6a90eaf70c37c786c11bed2046302b56bb506c25e1a0/ruff-0.17.3-py3-none-win_amd64.whl", hash = "sha256:56b8ffb3f3b3cbccb8b76b71b38261b7ed982ef5d20f5b447b1b61a7f4949b24", size = 10341333, upload-time = "2026-10-27T00:34:02.099Z" }, + { url = "https://files.pythonhosted.org/packages/99/d5/4ad4ed31413c301430918e70d3d38ae6f097af0766cb9ab8c9d502b2a4d6/ruff-0.17.3-py3-none-win_arm64.whl", hash = "sha256:81fce74bcd6be0e9da7c67c7553fd0f1f12964a2052cd728ef917b937a5ca1d9", size = 9854332, upload-time = "2026-10-27T00:34:03.847Z" }, +] + +[[package]] +name = "secretstorage" +version = "3.5.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "cryptography" }, + { name = "jeepney" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/1c/03/e834bcd866f2f8a49a85eaff47340affa3bfa391ee9912a952a1faa68c7b/secretstorage-3.5.0.tar.gz", hash = "sha256:f04b8e4689cbce351744d5537bf6b1329c6fc68f91fa666f60a380edddcd11be", size = 19884, upload-time = "2025-11-23T19:02:53.191Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b7/46/f5af3402b579fd5e11573ce652019a67074317e18c1935cc0b4ba9b35552/secretstorage-3.5.0-py3-none-any.whl", hash = "sha256:0ce65888c0725fcb2c5bc0fdb8e5438eece02c523557ea40ce0703c266248137", size = 15554, upload-time = "2025-11-23T19:02:51.545Z" }, +] + +[[package]] +name = "setuptools" +version = "84.2.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/70/b3/c19426f783614d625699a4b247faf628ea9ab1db228674491767b417f9e1/setuptools-84.2.1.tar.gz", hash = "sha256:3ff8b3b5492a0aa66960f4419365a86b84e013070d4313e4d4a6894f5d64d6bc", size = 1230289, upload-time = "2026-10-20T19:01:37.742Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ef/55/6dc6d6bb953bdfc52519a0059592c52b6e3b8ad51cf8256dffceb55b0610/setuptools-84.2.1-py3-none-any.whl", hash = "sha256:ca140b45d5325a9478f880e351484f62fef15f336462e449ca0c03c873d589c2", size = 876263, upload-time = "2026-10-20T19:01:35.678Z" }, +] + +[[package]] +name = "toml" +version = "0.10.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/be/ba/1f744cdc819428fc6b5084ec34d9b30660f6f9daaf70eead706e3203ec3c/toml-0.10.2.tar.gz", hash = "sha256:b3bda1d108d5dd99f4a20d24d9c348e91c4db7ab1b749200bded2f839ccbe68f", size = 22253, upload-time = "2020-11-01T01:40:22.204Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/44/6f/7120676b6d73228c96e17f1f794d8ab046fc910d781c8d151120c3f1569e/toml-0.10.2-py2.py3-none-any.whl", hash = "sha256:806143ae5bfb6a3c6e736a764057db0e6a0e05e338b5630894a5f779cabb4f9b", size = 16588, upload-time = "2020-11-01T01:40:20.672Z" }, +] + +[[package]] +name = "tomli-w" +version = "1.2.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/19/75/241269d1da26b624c0d5e110e8149093c759b7a286138f4efd61a60e75fe/tomli_w-1.2.0.tar.gz", hash = "sha256:2dd14fac5a47c27be9cd4c976af5a12d87fb1f0b4512f81d69cce3b35ae25021", size = 7184, upload-time = "2025-01-15T12:07:24.262Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c7/18/c86eb8e0202e32dd3df50d43d7ff9854f8e0603945ff398974c1d91ac1ef/tomli_w-1.2.0-py3-none-any.whl", hash = "sha256:188306098d013b691fcadc011abd66727d3c414c571bb01b1a174ba8c983cf90", size = 6675, upload-time = "2025-01-15T12:07:22.074Z" }, +] + +[[package]] +name = "toon-format" +version = "1.2.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/06/9e/88b94e00ae3589130bb2bde233c60b55776deb670cc3d077657d6a8b9a2e/toon_format-1.2.0.tar.gz", hash = "sha256:ed09c0cb8ba58f17372f876df1e43400d2d916aef67c641f152d8a28c5898669", size = 20775, upload-time = "2026-10-18T13:23:36.594Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f3/9e/69331571d5b91b3f34f0dcd7c8135bb3241e41c3c3effb4af8f57772a9ca/toon_format-1.2.0-py3-none-any.whl", hash = "sha256:d94db4b088a281a7bbc85e75d7fbd24e6a0ec7bc110edb129285259eca6522c0", size = 22863, upload-time = "2026-10-18T13:23:35.557Z" }, +] + +[[package]] +name = "twine" +version = "7.0.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "id" }, + { name = "keyring", marker = "platform_machine != 'ppc64le' and platform_machine != 's390x'" }, + { name = "packaging" }, + { name = "readme-renderer" }, + { name = "requests" }, + { name = "requests-toolbelt" }, + { name = "rfc3986" }, + { name = "rich" }, + { name = "urllib3" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/92/3c/58f808a359700f39a967dffede33efeac809262c03303fa3eec6afff8f49/twine-7.0.0.tar.gz", hash = "sha256:85cdb29c518efef867360ae4acd4b0dfd61c8654a22fca08e6f8539f05022177", size = 215032, upload-time = "2026-07-27T15:59:00.825Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/96/08/ddcdc06225eaad6de0e48e1002b06d919dbde20582d0662c7af51308e5d6/twine-7.0.0-py3-none-any.whl", hash = "sha256:b854164df26db268af05f49aa5c0344b10e27a494343ff05b1e0bad3b135f5a7", size = 43204, upload-time = "2026-07-27T15:58:59.26Z" }, +] + +[[package]] +name = "types-pyyaml" +version = "6.0.12.20261103" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/d9/82/2ed4d215a2840b467a9a864f03b0d21904250e28f5e1f006ad36fba0311a/types_pyyaml-6.0.12.20261103.tar.gz", hash = "sha256:7a1b5f837881dd35d5448b5f18275164f89f206185e31e8eae6e0b42607bc001", size = 18911, upload-time = "2026-11-03T08:45:23.714Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e8/10/4353eb86278f6a59aeb9fe2be4d979c20b110b4009fa455a3ea6467cf5cb/types_pyyaml-6.0.12.20261103-py3-none-any.whl", hash = "sha256:444654c61f635dab82c092a511aa96a0ce31164810784b9a37314e3e56532ac8", size = 21299, upload-time = "2026-11-03T08:45:22.749Z" }, +] + +[[package]] +name = "typing-extensions" +version = "4.16.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f6/cc/6253133b5bb138fc3306cebfbda2c520f545d36b5be2c7255cc528bb45d6/typing_extensions-4.16.0.tar.gz", hash = "sha256:dc983d19a509c94dba722ee6abd33940f7c05a89e243c47e907eb4db6f1a43e5", size = 113555, upload-time = "2026-07-02T08:40:05.92Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/49/d3/b8441a820a491ddfc024b0b0cf0393375b75ea13866d9c66727e54c2fc80/typing_extensions-4.16.0-py3-none-any.whl", hash = "sha256:481caa481374e813c1b176ada14e97f1f67a4539ce9cfeb3f350d78d6370c2e8", size = 45571, upload-time = "2026-07-02T08:40:04.659Z" }, +] + +[[package]] +name = "urllib3" +version = "2.8.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/e3/05/b17359e1cefb4f909b5e40b1b90a496d987258916dbbf88e842c729f510e/urllib3-2.8.0.tar.gz", hash = "sha256:63bf2ead4c879426ebf22ef2a781eeb4aa3b4ae798a0435506f8687fd5bb9b63", size = 458972, upload-time = "2026-09-15T19:29:36.253Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/92/9d/c4e665119135114480843e7ab388fa94d8480650450e6f8e26b70d323a4c/urllib3-2.8.0-py3-none-any.whl", hash = "sha256:0cf3cae568d36aa9576b28dfb35f11328f1cb974ca7647d9475ebb86c75ac6e3", size = 135717, upload-time = "2026-09-15T19:29:34.577Z" }, +] + +[[package]] +name = "virtualenv" +version = "21.15.5" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "distlib" }, + { name = "filelock" }, + { name = "packaging" }, + { name = "platformdirs" }, + { name = "python-discovery" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/69/74/745e612b69ad14a534b7bc233c4574b968eb2c21a276ea172e8f0fc13f51/virtualenv-21.15.5.tar.gz", hash = "sha256:fb869ea32930530ccc87549877b53268c2a4d4a7d7f2c384042eca05170350e6", size = 5639868, upload-time = "2026-11-04T05:13:20.929Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9d/d6/f9ac78f115e32e0d76adda9db72b74425b86495ae274cd7b58c660f5d1c1/virtualenv-21.15.5-py3-none-any.whl", hash = "sha256:bcf98c32139cf3df7f0cc2c8c48ca150645c20e66f8c4fe6c1e5e40bcae73947", size = 5680750, upload-time = "2026-11-04T05:13:19.057Z" }, +] + +[[package]] +name = "wheel" +version = "0.48.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "packaging" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/d0/20/50ed6bdf27dec98b568a8ae25dc599f35baa3d9709f9e83fd1edb56b9a90/wheel-0.48.0.tar.gz", hash = "sha256:94800765601e9171bf5d58d066e640662842bcedcbab982b2c90787a2c987322", size = 66471, upload-time = "2026-08-11T22:02:27.327Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/2e/29/69cfbb602cd91690c55d38ba9fe53e6a7e76a6fa647bf38f19c138d25449/wheel-0.48.0-py3-none-any.whl", hash = "sha256:3217dcc807155e45db462d7ef2431f5ddda0d7273b700d05a67b271ceb1287ab", size = 33320, upload-time = "2026-08-11T22:02:26.1Z" }, +] + +[[package]] +name = "zipp" +version = "4.1.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/18/05/ba1458dee0ac485b2a01071c1b88f5199fe878a485df482e10e1ef2205cc/zipp-4.1.2.tar.gz", hash = "sha256:cf474b90b07ea932637e17c6b9479de2b2882900b0d311bdaf4f5c000a15a97f", size = 27864, upload-time = "2026-10-21T18:57:04.743Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b8/44/7bd2007260da11cccca29ba2d4c345f1287aa663db38ee7cefeabf6386a5/zipp-4.1.2-py3-none-any.whl", hash = "sha256:b30cb6cd253122169c47de245ca24a86bac2a5d3802ba15bf7ba6414eb9e144d", size = 10581, upload-time = "2026-10-21T18:57:03.79Z" }, +]