pax_global_header 0000666 0000000 0000000 00000000064 15023134314 0014506 g ustar 00root root 0000000 0000000 52 comment=be359f3d9d46c816f28933e63b9c5e07c70580ef
aiorussound-4.6.0/ 0000775 0000000 0000000 00000000000 15023134314 0014070 5 ustar 00root root 0000000 0000000 aiorussound-4.6.0/.github/ 0000775 0000000 0000000 00000000000 15023134314 0015430 5 ustar 00root root 0000000 0000000 aiorussound-4.6.0/.github/CODEOWNERS 0000664 0000000 0000000 00000000015 15023134314 0017017 0 ustar 00root root 0000000 0000000 * @noahhusby
aiorussound-4.6.0/.github/CODE_OF_CONDUCT.md 0000664 0000000 0000000 00000012152 15023134314 0020230 0 ustar 00root root 0000000 0000000 # Contributor Covenant Code of Conduct
## Our Pledge
We as members, contributors, and leaders pledge to make participation in our
community a harassment-free experience for everyone, regardless of age, body
size, visible or invisible disability, ethnicity, sex characteristics, gender
identity and expression, level of experience, education, socio-economic status,
nationality, personal appearance, race, religion, or sexual identity
and orientation.
We pledge to act and interact in ways that contribute to an open, welcoming,
diverse, inclusive, and healthy community.
## Our Standards
Examples of behavior that contributes to a positive environment for our
community include:
* Demonstrating empathy and kindness toward other people
* Being respectful of differing opinions, viewpoints, and experiences
* Giving and gracefully accepting constructive feedback
* Accepting responsibility and apologizing to those affected by our mistakes,
and learning from the experience
* Focusing on what is best not just for us as individuals, but for the
overall community
Examples of unacceptable behavior include:
* The use of sexualized language or imagery, and sexual attention or
advances of any kind
* Trolling, insulting or derogatory comments, and personal or political attacks
* Public or private harassment
* Publishing others' private information, such as a physical or email
address, without their explicit permission
* Other conduct which could reasonably be considered inappropriate in a
professional setting
## Enforcement Responsibilities
Community leaders are responsible for clarifying and enforcing our standards of
acceptable behavior and will take appropriate and fair corrective action in
response to any behavior that they deem inappropriate, threatening, offensive,
or harmful.
Community leaders have the right and responsibility to remove, edit, or reject
comments, commits, code, wiki edits, issues, and other contributions that are
not aligned to this Code of Conduct, and will communicate reasons for moderation
decisions when appropriate.
## Scope
This Code of Conduct applies within all community spaces, and also applies when
an individual is officially representing the community in public spaces.
Examples of representing our community include using an official e-mail address,
posting via an official social media account, or acting as an appointed
representative at an online or offline event.
## Enforcement
Instances of abusive, harassing, or otherwise unacceptable behavior may be
reported to the community leaders responsible for enforcement at
opensource@husbylabs.com.
All complaints will be reviewed and investigated promptly and fairly.
All community leaders are obligated to respect the privacy and security of the
reporter of any incident.
## Enforcement Guidelines
Community leaders will follow these Community Impact Guidelines in determining
the consequences for any action they deem in violation of this Code of Conduct:
### 1. Correction
**Community Impact**: Use of inappropriate language or other behavior deemed
unprofessional or unwelcome in the community.
**Consequence**: A private, written warning from community leaders, providing
clarity around the nature of the violation and an explanation of why the
behavior was inappropriate. A public apology may be requested.
### 2. Warning
**Community Impact**: A violation through a single incident or series
of actions.
**Consequence**: A warning with consequences for continued behavior. No
interaction with the people involved, including unsolicited interaction with
those enforcing the Code of Conduct, for a specified period of time. This
includes avoiding interactions in community spaces as well as external channels
like social media. Violating these terms may lead to a temporary or
permanent ban.
### 3. Temporary Ban
**Community Impact**: A serious violation of community standards, including
sustained inappropriate behavior.
**Consequence**: A temporary ban from any sort of interaction or public
communication with the community for a specified period of time. No public or
private interaction with the people involved, including unsolicited interaction
with those enforcing the Code of Conduct, is allowed during this period.
Violating these terms may lead to a permanent ban.
### 4. Permanent Ban
**Community Impact**: Demonstrating a pattern of violation of community
standards, including sustained inappropriate behavior, harassment of an
individual, or aggression toward or disparagement of classes of individuals.
**Consequence**: A permanent ban from any sort of public interaction within
the community.
## Attribution
This Code of Conduct is adapted from the [Contributor Covenant][homepage],
version 2.0, available at
https://www.contributor-covenant.org/version/2/0/code_of_conduct.html.
Community Impact Guidelines were inspired by [Mozilla's code of conduct
enforcement ladder](https://github.com/mozilla/diversity).
[homepage]: https://www.contributor-covenant.org
For answers to common questions about this code of conduct, see the FAQ at
https://www.contributor-covenant.org/faq. Translations are available at
https://www.contributor-covenant.org/translations.
aiorussound-4.6.0/.github/dependabot.yml 0000664 0000000 0000000 00000001015 15023134314 0020255 0 ustar 00root root 0000000 0000000 # To get started with Dependabot version updates, you'll need to specify which
# package ecosystems to update and where the package manifests are located.
# Please see the documentation for all configuration options:
# https://docs.github.com/code-security/dependabot/dependabot-version-updates/configuration-options-for-the-dependabot.yml-file
version: 2
updates:
- package-ecosystem: "pip" # See documentation for possible values
directory: "/" # Location of package manifests
schedule:
interval: "weekly"
aiorussound-4.6.0/.github/workflows/ 0000775 0000000 0000000 00000000000 15023134314 0017465 5 ustar 00root root 0000000 0000000 aiorussound-4.6.0/.github/workflows/build.yml 0000664 0000000 0000000 00000001406 15023134314 0021310 0 ustar 00root root 0000000 0000000 name: Build
on:
push:
branches:
- master
jobs:
build:
name: Build
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v2
with:
fetch-depth: 0
- name: Setup Python
uses: actions/setup-python@v2
with:
python-version: ${{ matrix.python }}
- name: Install tox and any other packages
run: pip install tox
- name: Run tox
run: tox -e py
- uses: sonarsource/sonarqube-scan-action@master
env:
SONAR_TOKEN: ${{ secrets.SONAR_TOKEN }}
SONAR_HOST_URL: ${{ secrets.SONAR_HOST_URL }}
- uses: sonarsource/sonarqube-quality-gate-action@master
timeout-minutes: 5
env:
SONAR_TOKEN: ${{ secrets.SONAR_TOKEN }}
aiorussound-4.6.0/.github/workflows/pages.yml 0000664 0000000 0000000 00000002251 15023134314 0021307 0 ustar 00root root 0000000 0000000 ---
name: Deploy pdocs to Pages
on:
push:
branches:
- master
permissions:
contents: read
pages: write
id-token: write
actions: read
env:
PYTHON_VERSION: 3.11
jobs:
deploy:
environment:
name: github-pages
url: ${{ steps.deployment.outputs.page_url }}
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- name: ๐ Set up Poetry
run: pipx install poetry
- name: Set up Python
uses: actions/setup-python@v5
with:
python-version: ${{ env.PYTHON_VERSION }}
cache: "poetry"
- name: ๐ Install workflow dependencies
run: |
poetry config virtualenvs.create true
poetry config virtualenvs.in-project true
- name: ๐ Install dependencies
run: poetry install --no-interaction --with docs
- run: poetry run python -m pdoc ./aiorussound -o docs/
- name: Setup Pages
uses: actions/configure-pages@v5
- name: Upload artifact
uses: actions/upload-pages-artifact@v3
with:
path: 'docs/'
- name: Deploy to GitHub Pages
id: deployment
uses: actions/deploy-pages@v4
aiorussound-4.6.0/.github/workflows/release.yml 0000664 0000000 0000000 00000002576 15023134314 0021642 0 ustar 00root root 0000000 0000000 name: release
on:
release:
types:
- published
env:
DEFAULT_PYTHON: "3.11"
jobs:
release:
name: Build and publish Python package to PyPI and TestPyPI
runs-on: ubuntu-latest
permissions:
contents: write
id-token: write
steps:
- uses: actions/checkout@master
- name: ๐ Set up Poetry
run: pipx install poetry
- name: Set up Python ${{ env.DEFAULT_PYTHON }}
uses: actions/setup-python@v5
with:
python-version: ${{ env.DEFAULT_PYTHON }}
cache: "poetry"
- name: ๐ Install workflow dependencies
run: |
poetry config virtualenvs.create true
poetry config virtualenvs.in-project true
- name: ๐ Install dependencies
run: poetry install --no-interaction
- name: ๐ Set package version
run: |
version="${{ github.event.release.tag_name }}"
version="${version,,}"
version="${version#v}"
poetry version --no-interaction "${version}"
- name: ๐ Build package
run: poetry build --no-interaction
- name: ๐ Publish to PyPi
uses: pypa/gh-action-pypi-publish@v1.9.0
with:
verbose: true
print-hash: true
- name: โ๏ธ Sign published artifacts
uses: sigstore/gh-action-sigstore-python@v3.0.0
with:
inputs: ./dist/*.tar.gz ./dist/*.whl
release-signing-artifacts: true
aiorussound-4.6.0/.gitignore 0000664 0000000 0000000 00000002255 15023134314 0016064 0 ustar 00root root 0000000 0000000 # Byte-compiled / optimized / DLL files
__pycache__/
*.py[cod]
*$py.class
# C extensions
*.so
# Distribution / packaging
.Python
env/
build/
develop-eggs/
dist/
downloads/
eggs/
.eggs/
lib/
lib64/
parts/
sdist/
var/
wheels/
*.egg-info/
.installed.cfg
*.egg
MANIFEST
# PyInstaller
# Usually these files are written by a python script from a template
# before PyInstaller builds the exe, so as to inject date/other infos into it.
*.manifest
*.spec
# Installer logs
pip-log.txt
pip-delete-this-directory.txt
# Unit test / coverage reports
htmlcov/
.tox/
.coverage
.coverage.*
.cache
nosetests.xml
coverage.xml
*.cover
.hypothesis/
# Translations
*.mo
*.pot
# Django stuff:
*.log
local_settings.py
# Flask stuff:
instance/
.webassets-cache
# Scrapy stuff:
.scrapy
# Sphinx documentation
docs/_build/
# PyBuilder
target/
# Jupyter Notebook
.ipynb_checkpoints
# pyenv
.python-version
# celery beat schedule file
celerybeat-schedule
# SageMath parsed files
*.sage.py
# dotenv
.env
# virtualenv
.venv
venv/
ENV/
# Spyder project settings
.spyderproject
.spyproject
# Rope project settings
.ropeproject
# mkdocs documentation
/site
# mypy
.mypy_cache/
# Jetbrains
.idea/
.DS_Store
aiorussound-4.6.0/.pre-commit-config.yaml 0000664 0000000 0000000 00000001242 15023134314 0020350 0 ustar 00root root 0000000 0000000 ---
repos:
- repo: local
hooks:
- id: ruff-check
name: ๐ถ Ruff Linter
language: system
types: [python]
entry: poetry run ruff check --fix
require_serial: true
stages: [pre-commit, pre-push, manual]
- id: ruff-format
name: ๐ถ Ruff Formatter
language: system
types: [python]
entry: poetry run ruff format
require_serial: true
stages: [pre-commit, pre-push, manual]
- id: pytest
name: ๐งช Running tests and test coverage with pytest
language: system
types: [python]
entry: poetry run pytest
pass_filenames: false aiorussound-4.6.0/LICENSE 0000664 0000000 0000000 00000002053 15023134314 0015075 0 ustar 00root root 0000000 0000000 MIT License
Copyright (c) 2024 Noah Husby
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
aiorussound-4.6.0/MANIFEST.in 0000664 0000000 0000000 00000000022 15023134314 0015620 0 ustar 00root root 0000000 0000000 include README.md
aiorussound-4.6.0/README.md 0000664 0000000 0000000 00000004260 15023134314 0015351 0 ustar 00root root 0000000 0000000
# aiorussound
#### An async python package for interfacing with Russound RIO hardware
[**๐ Read the docs ยป**][docs]
[](https://github.com/noahhusby/aiorussound/actions/workflows/build.yml)
[](https://github.com/noahhusby/aiorussound/blob/main/LICENSE)
[](https://pypi.org/project/aiorussound/)
[](https://pypi.org/project/aiorussound/)
[](https://pypi.org/project/aiorussound/)
This module implements a Python client for the Russound I/O (RIO) protocol used to control Russound audio controllers. RIO supports a superset of the RNET feature set, allows for push notifications of system changes and supports TCP/IP and RS232 communication.
## Supported Devices
- Russound MBX-PRE
- Russound MBX-AMP
- Russound MCA-C3
- Russound MCA-C5
- Russound MCA-66
- Russound MCA-88
- Russound MCA-88x
- Russound XSource (untested)
- Russound XZone4 (untested)
- Russound XZone70V (untested)
- Russound XStream-X5 (untested)
- Russound ACA-E5 (untested)
If your model is not on the list of supported devices, and everything works correctly then add it to the list by opening a pull request.
## Communication
The library supports the RIO protocol communication over TCP/IP or RS232 (Serial).
### TCP/IP
The built-in ethernet port on the Russound device natively support the RIO protocol. **Note:** It is strongly recommended that the controller has a static IP address configured.
### RS232 (Serial)
The RS232 port must be configured to use the RIO protocol instead of the RNET protocol for the library to function properly. This can be configured using the SCS-C5 configuration tool or the controller's Web GUI.
## Acknowledgements
This is the continuation of the `russound_rio` package. This wouldn't be possible without the excellent work from [@wickerwaka](https://github.com/wickerwaka) and [@chphilli](https://github.com/chphilli).
[docs]: https://noahhusby.github.io/aiorussound/
aiorussound-4.6.0/aiorussound/ 0000775 0000000 0000000 00000000000 15023134314 0016443 5 ustar 00root root 0000000 0000000 aiorussound-4.6.0/aiorussound/__init__.py 0000664 0000000 0000000 00000001154 15023134314 0020555 0 ustar 00root root 0000000 0000000 """
.. include:: ../README.md
"""
from .exceptions import (
RussoundError,
CommandError,
UncachedVariableError,
UnsupportedFeatureError,
UnsupportedRussoundVersionError,
)
from .connection import RussoundTcpConnectionHandler
from .models import Source, RussoundMessage, Zone
from .rio import Controller, RussoundClient
__all__ = [
"RussoundError",
"CommandError",
"UnsupportedFeatureError",
"UnsupportedRussoundVersionError",
"UncachedVariableError",
"RussoundClient",
"Controller",
"Zone",
"RussoundTcpConnectionHandler",
"Source",
"RussoundMessage",
]
aiorussound-4.6.0/aiorussound/connection.py 0000664 0000000 0000000 00000002736 15023134314 0021164 0 ustar 00root root 0000000 0000000 import asyncio
import logging
from abc import abstractmethod
from asyncio import StreamReader
from typing import Optional
from aiorussound.const import (
DEFAULT_PORT,
TIMEOUT,
)
_LOGGER = logging.getLogger(__package__)
class RussoundConnectionHandler:
def __init__(self) -> None:
self.reader: Optional[StreamReader] = None
async def send(self, cmd: str) -> None:
"""Send a command to the Russound client."""
pass
# if not self.connected:
# raise CommandError("Not connected to device.")
@abstractmethod
async def connect(self) -> None:
raise NotImplementedError
class RussoundTcpConnectionHandler(RussoundConnectionHandler):
def __init__(self, host: str, port: int = DEFAULT_PORT) -> None:
"""Initialize the Russound object using the event loop, host and port
provided.
"""
super().__init__()
self.host = host
self.port = port
self.writer = None
async def connect(self) -> None:
_LOGGER.debug("Connecting to %s:%s", self.host, self.port)
async with asyncio.timeout(TIMEOUT):
reader, writer = await asyncio.open_connection(self.host, self.port)
self.reader = reader
self.writer = writer
async def send(self, cmd: str) -> None:
"""Send a command to the Russound client."""
await super().send(cmd)
self.writer.write(bytearray(f"{cmd}\r", "utf-8"))
await self.writer.drain()
aiorussound-4.6.0/aiorussound/const.py 0000664 0000000 0000000 00000010760 15023134314 0020147 0 ustar 00root root 0000000 0000000 """Asynchronous Python client for Russound RIO."""
from __future__ import annotations
from collections import defaultdict
from enum import Enum
import re
MINIMUM_API_SUPPORT = "1.05.00"
DEFAULT_PORT = 9621
RECONNECT_DELAY = 5.0
TIMEOUT = 5.0
KEEP_ALIVE_INTERVAL = 60
MAX_SOURCE = 17
MAX_RNET_CONTROLLERS = 6
RESPONSE_REGEX = re.compile(
r'(?:(\w+(?:\[\d+])?(?:\.\w+(?:\[\d+])?)*)\.)?(\w+)="([^"]*)"'
)
class FeatureFlag(Enum):
"""A list of Russound RIO API features."""
SUPPORT_POWER_MGMT = 1
SUPPORT_ZONE_PARAMETERS = 2
SUPPORT_SOURCE_PARAMETERS = 3
SUPPORT_CONTROLLER_PARAMETERS = 4
SUPPORT_SYSTEM_PARAMETERS = 5
SUPPORT_DMS_3_1_MM = 6
EVENT_KEY_CODE = 7
PROPERTY_IP_ADDRESS = 8
SUPPORT_SHUFFLE = 9
COMMAND_MM_CLOSE = 10
SUPPORT_PAGE_ZONE = 11
SUPPORT_REPEAT = 12
PROPERTY_CTRL_TYPE = 13
PROPERTY_SYS_LANG = 14
NOTIFICATION_SYS_LANG = 15
SUPPORT_MM_LONG_LIST = 16
TEMPLATES_MM_SCREEN = 17
PROPERTY_SLEEP_TIME_REMAINING = 18
SUPPORT_PRESETS_BANKS = 19
SUPPORT_FAVORITES = 20
SUPPORT_ZONE_SOURCE_EXCLUSION = 21
SUPPORT_FORMS = 22
SUPPORT_MEDIA_RATING = 23
SUPPORT_HIDDEN_ATTRIBUTE = 24
SUPPORT_SYSTEM_FAVORITE_RENAME = 25
COMMANDS_ZONE_MUTE_OFF_ON = 26
SUPPORT_WATCH_FAVORITES = 27
SUPPORT_SYSTEM = 28
SUPPORT_DEVICE_GROUPING = 29
SUPPORT_ALARM = 30
NOTIFICATION_ALARM_ZONE_WATCH = 31
PROPERTY_FIRMWARE_VERSION = 32
SUPPORT_MBX_DISPLAY_ITEMS = 33
PROPERTY_PLAY_STATUS = 34
PROPERTY_AVAILABLE_CONTROLS = 35
PROPERTY_SAMPLE_RATE = 36
PROPERTY_BIT_RATE = 37
PROPERTY_BIT_DEPTH = 38
PROPERTY_PLAY_TIME = 39
PROPERTY_TRACK_TIME = 40
PROPERTY_SET_SEEK_TIME = 41
SUPPORT_MM_CONTEXT_MENU = 42
PROPERTY_SLEEP_TIME_DEFAULT = 43
PROPERTY_SUPPORT_SLEEP_TIME = 44
EVENT_REBOOT = 45
SUPPORT_SYSTEM_FAVORITE_SOURCE = 46
ATTRIBUTE_USER_LOGIN = 47
FLAGS_BY_VERSION = {
"1.01.00": [
FeatureFlag.SUPPORT_POWER_MGMT,
],
"1.02.00": [
FeatureFlag.SUPPORT_ZONE_PARAMETERS,
FeatureFlag.SUPPORT_SOURCE_PARAMETERS,
FeatureFlag.SUPPORT_CONTROLLER_PARAMETERS,
FeatureFlag.SUPPORT_SYSTEM_PARAMETERS,
],
"1.03.00": [
FeatureFlag.SUPPORT_DMS_3_1_MM,
FeatureFlag.EVENT_KEY_CODE,
FeatureFlag.PROPERTY_IP_ADDRESS,
],
"1.04.00": [
FeatureFlag.SUPPORT_SHUFFLE,
FeatureFlag.COMMAND_MM_CLOSE,
FeatureFlag.SUPPORT_PAGE_ZONE,
],
"1.05.00": [
FeatureFlag.SUPPORT_REPEAT,
FeatureFlag.PROPERTY_CTRL_TYPE,
FeatureFlag.PROPERTY_SYS_LANG,
],
"1.06.00": [
FeatureFlag.NOTIFICATION_SYS_LANG,
FeatureFlag.SUPPORT_MM_LONG_LIST,
FeatureFlag.TEMPLATES_MM_SCREEN,
],
"1.07.00": [
FeatureFlag.PROPERTY_SLEEP_TIME_REMAINING,
FeatureFlag.SUPPORT_PRESETS_BANKS,
FeatureFlag.SUPPORT_FAVORITES,
FeatureFlag.SUPPORT_ZONE_SOURCE_EXCLUSION,
FeatureFlag.SUPPORT_FORMS,
FeatureFlag.SUPPORT_MEDIA_RATING,
FeatureFlag.SUPPORT_HIDDEN_ATTRIBUTE,
],
"1.08.00": [FeatureFlag.SUPPORT_SYSTEM_FAVORITE_RENAME],
"1.09.00": [
FeatureFlag.COMMANDS_ZONE_MUTE_OFF_ON,
],
"1.11.00": [
FeatureFlag.SUPPORT_WATCH_FAVORITES,
],
"1.12.00": [
FeatureFlag.SUPPORT_SYSTEM,
FeatureFlag.SUPPORT_DEVICE_GROUPING,
FeatureFlag.SUPPORT_ALARM,
],
"1.12.01": [
FeatureFlag.NOTIFICATION_ALARM_ZONE_WATCH,
],
"1.12.02": [
FeatureFlag.PROPERTY_FIRMWARE_VERSION,
],
"1.14.00": [
FeatureFlag.SUPPORT_MBX_DISPLAY_ITEMS,
FeatureFlag.PROPERTY_PLAY_STATUS,
FeatureFlag.PROPERTY_AVAILABLE_CONTROLS,
FeatureFlag.PROPERTY_SAMPLE_RATE,
FeatureFlag.PROPERTY_BIT_RATE,
FeatureFlag.PROPERTY_BIT_DEPTH,
FeatureFlag.PROPERTY_PLAY_TIME,
FeatureFlag.PROPERTY_TRACK_TIME,
FeatureFlag.PROPERTY_SET_SEEK_TIME,
FeatureFlag.SUPPORT_MM_CONTEXT_MENU,
],
"1.14.01": [
FeatureFlag.PROPERTY_SLEEP_TIME_DEFAULT,
FeatureFlag.PROPERTY_SUPPORT_SLEEP_TIME,
],
"1.15.00": [FeatureFlag.EVENT_REBOOT, FeatureFlag.SUPPORT_SYSTEM_FAVORITE_SOURCE],
"1.15.02": [
FeatureFlag.ATTRIBUTE_USER_LOGIN,
],
}
VERSIONS_BY_FLAGS = defaultdict(list)
for version, flags in FLAGS_BY_VERSION.items():
for flag in flags:
VERSIONS_BY_FLAGS[flag] = version
CONTROLLER_TYPE_FIX_MAP = {
"MCA-C6": "MCA-C5",
"XStream-X5": "XSource",
} aiorussound-4.6.0/aiorussound/exceptions.py 0000664 0000000 0000000 00000001033 15023134314 0021173 0 ustar 00root root 0000000 0000000 """Asynchronous Python client for Russound RIO."""
class RussoundError(Exception):
"""A generic error."""
class CommandError(Exception):
"""A command sent to the controller caused an error."""
class UncachedVariableError(Exception):
"""A variable was not found in the cache."""
class UnsupportedFeatureError(Exception):
"""A requested command is not supported on this controller."""
class UnsupportedRussoundVersionError(Exception):
"""The client implements an unsupported version of the Russound RIO API."""
aiorussound-4.6.0/aiorussound/models.py 0000664 0000000 0000000 00000017031 15023134314 0020302 0 ustar 00root root 0000000 0000000 """Models for aiorussound."""
from dataclasses import dataclass, field
from enum import StrEnum
from typing import Optional
from mashumaro import field_options
from mashumaro.mixins.orjson import DataClassORJSONMixin
from mashumaro.types import SerializationStrategy
from datetime import datetime, UTC
class RussoundBool(SerializationStrategy):
def deserialize(self, value: str) -> bool:
if value and (value == "ON" or value == "TRUE"):
return True
return False
class RussoundInt(SerializationStrategy):
def deserialize(self, value: str) -> int:
return int(value)
@dataclass
class Zone(DataClassORJSONMixin):
"""Data class representing Russound state."""
name: str = field(default=None)
volume: int = field(
metadata=field_options(serialization_strategy=RussoundInt()), default=0
)
bass: int = field(
metadata=field_options(serialization_strategy=RussoundInt()), default=0
)
treble: int = field(
metadata=field_options(serialization_strategy=RussoundInt()), default=0
)
balance: int = field(
metadata=field_options(serialization_strategy=RussoundInt()), default=0
)
loudness: bool = field(
metadata=field_options(serialization_strategy=RussoundBool()), default=False
)
turn_on_volume: int = field(
metadata=field_options(
alias="turnOnVolume", serialization_strategy=RussoundInt()
),
default=20,
)
do_not_disturb: bool = field(
metadata=field_options(
alias="doNotDisturb", serialization_strategy=RussoundBool()
),
default=False,
)
party_mode: bool = field(
metadata=field_options(
alias="partyMode", serialization_strategy=RussoundBool()
),
default=False,
)
status: bool = field(
metadata=field_options(serialization_strategy=RussoundBool()), default=False
)
is_mute: bool = field(
metadata=field_options(alias="mute", serialization_strategy=RussoundBool()),
default=False,
)
shared_source: bool = field(
metadata=field_options(
alias="sharedSource", serialization_strategy=RussoundBool()
),
default=False,
)
last_error: Optional[str] = field(
metadata=field_options(alias="lastError"), default=None
)
page: Optional[str] = field(metadata=field_options(alias="page"), default=None)
sleep_time_default: Optional[int] = field(
metadata=field_options(
alias="sleepTimeDefault", serialization_strategy=RussoundInt()
),
default=None,
)
sleep_time_remaining: Optional[int] = field(
metadata=field_options(
alias="sleepTimeRemaining", serialization_strategy=RussoundInt()
),
default=None,
)
enabled: bool = field(
metadata=field_options(serialization_strategy=RussoundBool()), default=False
)
current_source: int = field(
metadata=field_options(
alias="currentSource", serialization_strategy=RussoundInt()
),
default=1,
)
enabled_sources: list[int] = field(
metadata=field_options(alias="enabled_sources"), default_factory=list
)
class SourceType(StrEnum):
"""Russound source types."""
AMPLIFIER = "Amplifier"
TELEVISION = "Television"
CABLE = "Cable"
VIDEO_ACCESSORY = "Video Accessory"
SATELLITE = "Satellite"
VCR = "VCR"
BLURAY_DVD = "Blu-ray / DVD"
RECEIVER = "Receiver"
MISC_AUDIO = "Misc Audio"
CD = "CD"
HOME_CONTROL = "Home Control"
RUSSOUND_MEDIA_STREAMER = "Russound Media Streamer"
RUSSOUND_DMS_3_1_AM_FM_TUNER = "Russound DMS 3.1 AM/FM Tuner"
RUSSOUND_ST_1_AM_FM_TUNER = "Russound ST.1 AM/FM Tuner"
RUSSOUND_BLUETOOTH_MODULE = "Russound Bluetooth Module"
class SourceMode(StrEnum):
"""Russound source modes."""
UNKNOWN = "Unknown"
AIRPLAY = "AirPlay"
SPOTIFY = "Spotify"
PANDORA = "Pandora"
SIRIUS_XM = "SiriusXM"
TUNE_IN = "TuneIn"
INTERNET_RADIO = "Internet Radio"
MEDIA_SERVER = "Media Server"
USB = "USB"
AIRABLE_RADIO = "Airable Radio"
DEEZER = "Deezer"
TIDAL = "Tidal"
NAPSTER = "Napster"
CHROMECAST = "Chromecast"
BLUETOOTH = "Bluetooth"
class RepeatMode(StrEnum):
"""Repeat mode."""
OFF = "OFF"
ALL = "ALL"
SINGLE = "SINGLE"
class PlayStatus(StrEnum):
"""Play status"""
PLAYING = "playing"
PAUSED = "paused"
STOPPED = "stopped"
TRANSITIONING = "transitioning"
@dataclass
class Source(DataClassORJSONMixin):
"""Data class representing Russound source."""
name: str = field(default=None)
type: SourceType = field(
metadata={"deserialize": lambda v: SourceType.MISC_AUDIO if not v else v},
default=SourceType.MISC_AUDIO,
)
channel: Optional[str] = field(default=None)
cover_art_url: Optional[str] = field(
metadata=field_options(alias="coverArtURL"), default=None
)
channel_name: Optional[str] = field(
metadata=field_options(alias="channelName"), default=None
)
genre: Optional[str] = field(default=None)
artist_name: Optional[str] = field(
metadata=field_options(alias="artistName"), default=None
)
album_name: Optional[str] = field(
metadata=field_options(alias="albumName"), default=None
)
playlist_name: Optional[str] = field(
metadata=field_options(alias="playlistName"), default=None
)
song_name: Optional[str] = field(
metadata=field_options(alias="songName"), default=None
)
program_service_name: Optional[str] = field(
metadata=field_options(alias="programServiceName"), default=None
)
radio_text: Optional[str] = field(
metadata=field_options(alias="radioText"), default=None
)
shuffle_mode: bool = field(
metadata=field_options(
alias="shuffleMode", serialization_strategy=RussoundBool()
),
default=False,
)
repeat_mode: Optional[RepeatMode] = field(
metadata=field_options(alias="repeatMode"), default=None
)
mode: SourceMode = field(
metadata={"deserialize": lambda v: SourceMode.UNKNOWN if not v else v},
default=SourceMode.UNKNOWN,
)
play_status: Optional[PlayStatus] = field(
metadata=field_options(alias="playStatus"), default=None
)
sample_rate: Optional[int] = field(
metadata=field_options(
alias="sampleRate", serialization_strategy=RussoundInt()
),
default=None,
)
bit_rate: Optional[int] = field(
metadata=field_options(alias="bitRate", serialization_strategy=RussoundInt()),
default=None,
)
bit_depth: Optional[int] = field(
metadata=field_options(alias="bitDepth", serialization_strategy=RussoundInt()),
default=None,
)
play_time: Optional[int] = field(
metadata=field_options(alias="playTime", serialization_strategy=RussoundInt()),
default=None,
)
track_time: Optional[int] = field(
metadata=field_options(alias="trackTime", serialization_strategy=RussoundInt()),
default=None,
)
position_last_updated: datetime = datetime.now(UTC)
class CallbackType(StrEnum):
"""Callback type."""
STATE = "state"
CONNECTION = "connection"
class MessageType(StrEnum):
"""Message type."""
STATE = "S"
NOTIFICATION = "N"
ERROR = "E"
@dataclass
class RussoundMessage:
"""Incoming russound message."""
type: str
branch: Optional[str] = None
leaf: Optional[str] = None
value: Optional[str] = None
aiorussound-4.6.0/aiorussound/py.typed 0000664 0000000 0000000 00000000000 15023134314 0020130 0 ustar 00root root 0000000 0000000 aiorussound-4.6.0/aiorussound/rio.py 0000664 0000000 0000000 00000053027 15023134314 0017615 0 ustar 00root root 0000000 0000000 """Asynchronous Python client for Russound RIO."""
from __future__ import annotations
import asyncio
import logging
from asyncio import Future, Task, AbstractEventLoop, Queue
from dataclasses import field, dataclass
from typing import Any, Coroutine, Optional
from aiorussound.connection import RussoundConnectionHandler
from aiorussound.const import (
FLAGS_BY_VERSION,
MAX_SOURCE,
MINIMUM_API_SUPPORT,
FeatureFlag,
MAX_RNET_CONTROLLERS,
RESPONSE_REGEX,
KEEP_ALIVE_INTERVAL,
TIMEOUT,
CONTROLLER_TYPE_FIX_MAP,
)
from aiorussound.exceptions import (
CommandError,
UnsupportedFeatureError,
RussoundError,
)
from aiorussound.models import (
RussoundMessage,
CallbackType,
Source,
Zone,
MessageType,
)
from aiorussound.util import (
controller_device_str,
is_feature_supported,
is_fw_version_higher,
source_device_str,
zone_device_str,
is_rnet_capable,
get_max_zones,
map_rio_to_dict,
)
_LOGGER = logging.getLogger(__package__)
class RussoundClient:
"""Manages the RIO connection to a Russound device."""
def __init__(self, connection_handler: RussoundConnectionHandler) -> None:
"""Initialize the Russound object using the event loop, host and port
provided.
"""
self.connection_handler = connection_handler
self._loop: AbstractEventLoop = asyncio.get_running_loop()
self._subscriptions: dict[str, Any] = {}
self.connect_result: Future | None = None
self.connect_task: Task | None = None
self._reconnect_task: Optional[Task] = None
self._state_update_callbacks: list[Any] = []
self.controllers: dict[int, Controller] = {}
self.sources: dict[int, Source] = {}
self.rio_version: str | None = None
self.state = {}
self._futures: Queue = Queue()
self._attempt_reconnection = False
self._do_state_update = False
async def register_state_update_callbacks(self, callback: Any):
"""Register state update callback."""
self._state_update_callbacks.append(callback)
if self._do_state_update:
await callback(self, CallbackType.STATE)
def unregister_state_update_callbacks(self, callback: Any):
"""Unregister state update callback."""
if callback in self._state_update_callbacks:
self._state_update_callbacks.remove(callback)
def clear_state_update_callbacks(self):
"""Clear state update callbacks."""
self._state_update_callbacks.clear()
async def do_state_update_callbacks(
self, callback_type: CallbackType = CallbackType.STATE
):
"""Call state update callbacks."""
if not self._state_update_callbacks:
return
callbacks = set()
for callback in self._state_update_callbacks:
callbacks.add(callback(self, callback_type))
if callbacks:
await asyncio.gather(*callbacks)
async def request(self, cmd: str):
_LOGGER.debug("Sending command '%s' to Russound client", cmd)
future: Future = Future()
await self._futures.put(future)
try:
await self.connection_handler.send(cmd)
except Exception as ex:
_ = await self._futures.get()
future.set_exception(ex)
return await future
async def connect(self) -> None:
"""Connect to the controller and start processing responses."""
if not self.is_connected():
self.connect_result = self._loop.create_future()
self._reconnect_task = asyncio.create_task(
self._reconnect_handler(self.connect_result)
)
return await self.connect_result
async def disconnect(self) -> None:
"""Disconnect from the Russound controller."""
if self.is_connected():
self._attempt_reconnection = False
self.connect_task.cancel()
try:
await self.connect_task
except asyncio.CancelledError:
pass
def is_connected(self) -> bool:
"""Return True if device is connected."""
return self.connect_task is not None and not self.connect_task.done()
async def _reconnect_handler(self, res):
reconnect_delay = 0.5
while True:
try:
self.connect_task = asyncio.create_task(self._connect_handler(res))
await self.connect_task
except Exception as ex:
_LOGGER.error(ex)
pass
await self.do_state_update_callbacks(CallbackType.CONNECTION)
if not self._attempt_reconnection:
_LOGGER.debug(
"Failed to connect to device on initial pass, skipping reconnect."
)
break
reconnect_delay = min(reconnect_delay * 2, 30)
_LOGGER.debug(
f"Attempting reconnection to Russound device in {reconnect_delay} seconds..."
)
await asyncio.sleep(reconnect_delay)
async def _connect_handler(self, res):
handler_tasks = set()
try:
self._do_state_update = False
async with asyncio.timeout(TIMEOUT):
await self.connection_handler.connect()
handler_tasks.add(
asyncio.create_task(self.consumer_handler(self.connection_handler))
)
self.rio_version = await self.request("VERSION")
if not is_fw_version_higher(self.rio_version, MINIMUM_API_SUPPORT):
raise UnsupportedFeatureError(
f"Russound RIO API v{self.rio_version} is not supported. The minimum "
f"supported version is v{MINIMUM_API_SUPPORT}"
)
_LOGGER.info("Connected (Russound RIO v%s})", self.rio_version)
# Fetch parent controller
parent_controller = await self._load_controller(1)
if not parent_controller:
raise RussoundError("No primary controller found.")
self.controllers[1] = parent_controller
# Only search for daisy-chained controllers if the parent supports RNET
if is_rnet_capable(parent_controller.controller_type):
for controller_id in range(2, MAX_RNET_CONTROLLERS + 1):
controller = await self._load_controller(controller_id)
if controller:
self.controllers[controller_id] = controller
self._do_state_update = True
self._attempt_reconnection = True
if not res.done():
res.set_result(True)
handler_tasks.add(asyncio.create_task(self._keep_alive()))
await asyncio.wait(handler_tasks, return_when=asyncio.FIRST_COMPLETED)
except Exception as ex:
if not res.done():
res.set_exception(ex)
_LOGGER.error(ex, exc_info=True)
finally:
for task in handler_tasks:
if not task.done():
task.cancel()
while not self._futures.empty():
future = await self._futures.get()
future.cancel()
self._do_state_update = False
closeout = set()
closeout.update(handler_tasks)
if closeout:
closeout_task = asyncio.create_task(asyncio.wait(closeout))
while not closeout_task.done():
try:
await asyncio.shield(closeout_task)
except asyncio.CancelledError:
pass
async def load_zone_source_metadata(self) -> None:
"""Fetches and subscribes to all the zone and source metadata"""
subscribe_state_updates = {self.subscribe(self._async_handle_system, "System")}
# Load source structure
for source_id in range(1, MAX_SOURCE):
try:
device_str = source_device_str(source_id)
name = await self.get_variable(device_str, "name")
if name:
subscribe_state_updates.add(
self.subscribe(self._async_handle_source, device_str)
)
except CommandError:
break
for controller_id, controller in self.controllers.items():
for zone_id in range(1, get_max_zones(controller.controller_type) + 1):
try:
device_str = zone_device_str(controller_id, zone_id)
name = await self.get_variable(device_str, "name")
if name:
subscribe_state_updates.add(
self.subscribe(self._async_handle_zone, device_str)
)
except CommandError:
break
subscribe_tasks = set()
for state_update in subscribe_state_updates:
subscribe_tasks.add(asyncio.create_task(state_update))
await asyncio.wait(subscribe_tasks)
if is_feature_supported(
self.rio_version, FeatureFlag.SUPPORT_ZONE_SOURCE_EXCLUSION
):
_LOGGER.debug(
"Zone source exclusion is supported. Fetching excluded sources."
)
await self._load_zone_source_exclusion()
# Reload zones from state
await self._async_handle_zone()
await self.do_state_update_callbacks(CallbackType.STATE)
# Delay to ensure async TTL
await asyncio.sleep(0.5)
@staticmethod
def process_response(res: bytes) -> Optional[RussoundMessage]:
"""Process an incoming string of bytes into a RussoundMessage"""
try:
# Attempt to decode in Latin and re-encode in UTF-8 to support international characters
str_res = (
res.decode(encoding="iso-8859-1")
.encode(encoding="utf-8")
.decode(encoding="utf-8")
.strip()
)
except UnicodeDecodeError as e:
_LOGGER.warning("Failed to decode Russound response %s", res, e)
return None
if not str_res:
return None
if len(str_res) == 1 and str_res[0] == "S":
return RussoundMessage(MessageType.STATE, None, None, None)
tag, payload = str_res[0], str_res[2:]
if tag == "E":
_LOGGER.debug("Device responded with error: %s", payload)
return RussoundMessage(tag, None, None, payload)
m = RESPONSE_REGEX.match(payload.strip())
if not m:
return RussoundMessage(tag, None, None, None)
value = m.group(3)
value = None if not value or value == "------" else value
return RussoundMessage(tag, m.group(1) or None, m.group(2), value)
async def consumer_handler(self, handler: RussoundConnectionHandler):
"""Callback consumer handler."""
try:
async for raw_msg in handler.reader:
msg = self.process_response(raw_msg)
if msg:
_LOGGER.debug(f"recv ({msg})")
if msg.type == "S" and not self._futures.empty():
future: Future = await self._futures.get()
if not future.done():
future.set_result(msg.value)
elif msg.type == "E" and not self._futures.empty():
future: Future = await self._futures.get()
if not future.done():
future.set_exception(CommandError)
if msg.branch and msg.leaf and msg.type == "N":
map_rio_to_dict(self.state, msg.branch, msg.leaf, msg.value)
subscription = self._subscriptions.get(msg.branch)
if subscription:
await subscription()
except (asyncio.CancelledError, OSError):
pass
async def _keep_alive(self) -> None:
while True:
await asyncio.sleep(KEEP_ALIVE_INTERVAL)
_LOGGER.debug("Sending keep alive to device")
try:
async with asyncio.timeout(TIMEOUT):
await self.request("VERSION")
except asyncio.TimeoutError:
_LOGGER.warning("Keep alive request to the Russound device timed out")
break
_LOGGER.debug("Ending keep alive task to attempt reconnection")
async def subscribe(self, callback: Any, branch: str) -> None:
self._subscriptions[branch] = callback
try:
await self.request(f"WATCH {branch} ON")
except (asyncio.CancelledError, asyncio.TimeoutError, CommandError):
del self._subscriptions[branch]
raise
async def _async_handle_system(self) -> None:
"""Handle async info update."""
if self._do_state_update:
await self.do_state_update_callbacks()
async def _async_handle_source(self) -> None:
"""Handle async info update."""
for source_id, source_data in self.state["S"].items():
source = Source.from_dict(source_data)
source.client = self
self.sources[source_id] = source
if self._do_state_update:
await self.do_state_update_callbacks()
async def _async_handle_zone(self) -> None:
"""Handle async info update."""
for controller_id, controller_data in self.state["C"].items():
for zone_id, zone_data in controller_data["Z"].items():
zone = ZoneControlSurface.from_dict(zone_data)
zone.client = self
zone.device_str = zone_device_str(controller_id, zone_id)
self.controllers[controller_id].zones[zone_id] = zone
if self._do_state_update:
await self.do_state_update_callbacks()
async def set_variable(
self, device_str: str, key: str, value: str
) -> Coroutine[Any, Any, str]:
"""Set a zone variable to a new value."""
return await self.request(f'SET {device_str}.{key}="{value}"')
async def get_variable(self, device_str: str, key: str) -> str:
"""Retrieve the current value of a zone variable. If the variable is
not found in the local cache then the value is requested from the
controller.
"""
return await self.request(f"GET {device_str}.{key}")
async def _load_controller(self, controller_id: int) -> Optional[Controller]:
device_str = controller_device_str(controller_id)
try:
controller_type = await self.get_variable(device_str, "type")
if not controller_type:
return None
if controller_type in CONTROLLER_TYPE_FIX_MAP:
controller_type = CONTROLLER_TYPE_FIX_MAP[controller_type]
mac_address = None
try:
mac_address = await self.get_variable(device_str, "macAddress")
except CommandError:
pass
firmware_version = None
if is_feature_supported(
self.rio_version, FeatureFlag.PROPERTY_FIRMWARE_VERSION
):
firmware_version = await self.get_variable(
device_str, "firmwareVersion"
)
controller = Controller(
controller_id,
controller_type,
self,
controller_device_str(controller_id),
mac_address,
firmware_version,
{},
)
return controller
except CommandError:
return None
# ----------------------
# Manual state fixes
# ----------------------
async def _load_zone_source_exclusion(self) -> None:
"""Loads whether a source is available to a specific zone."""
for controller_id, controller in self.controllers.items():
for zone_id in controller.zones.keys():
for source_id in self.sources.keys():
try:
enabled = await self.get_variable(
f"C[{controller_id}].Z[{zone_id}].S[{source_id}]", "enabled"
)
except CommandError:
continue
if enabled == "TRUE":
if (
"enabled_sources"
not in self.state["C"][controller_id]["Z"][zone_id]
):
self.state["C"][controller_id]["Z"][zone_id][
"enabled_sources"
] = []
self.state["C"][controller_id]["Z"][zone_id][
"enabled_sources"
].append(source_id)
@property
def supported_features(self) -> list[FeatureFlag]:
"""Gets a list of features supported by the controller."""
flags: list[FeatureFlag] = []
for key, value in FLAGS_BY_VERSION.items():
if is_fw_version_higher(self.rio_version, key):
for flag in value:
flags.append(flag)
return flags
class AbstractControlSurface:
def __init__(self):
self.client: Optional[RussoundClient] = None
self.device_str: Optional[str] = None
class ZoneControlSurface(Zone, AbstractControlSurface):
async def send_event(self, event_name, *args) -> str:
"""Send an event to a zone."""
args = " ".join(str(x) for x in args)
cmd = f"EVENT {self.device_str}!{event_name} {args}"
return await self.client.request(cmd)
def fetch_current_source(self) -> Source:
"""Return the current source as a source object."""
return self.client.sources[self.current_source]
async def mute(self) -> str:
"""Mute the zone."""
return await self.send_event("ZoneMuteOn")
async def unmute(self) -> str:
"""Unmute the zone."""
return await self.send_event("ZoneMuteOff")
async def toggle_mute(self) -> str:
"""Toggle the mute state of the zone."""
return await self.send_event("KeyRelease", "Mute")
async def set_volume(self, volume: str) -> str:
"""Set the volume."""
return await self.send_event("KeyPress", "Volume", volume)
async def volume_up(self) -> str:
"""Volume up the zone."""
return await self.send_event("KeyPress", "VolumeUp")
async def volume_down(self) -> str:
"""Volume down the zone."""
return await self.send_event("KeyPress", "VolumeDown")
async def previous(self) -> str:
"""Go to the previous song."""
return await self.send_event("KeyPress", "Previous")
async def next(self) -> str:
"""Go to the next song."""
return await self.send_event("KeyPress", "Next")
async def stop(self) -> str:
"""Stop the current song."""
return await self.send_event("KeyPress", "Stop")
async def pause(self) -> str:
"""Pause the current song."""
return await self.send_event("KeyPress", "Pause")
async def play(self) -> str:
"""Play the queued song."""
return await self.send_event("KeyPress", "Play")
async def zone_on(self) -> str:
"""Turn on the zone."""
return await self.send_event("ZoneOn")
async def zone_off(self) -> str:
"""Turn off the zone."""
return await self.send_event("ZoneOff")
async def select_source(self, source: int) -> str:
"""Select a source."""
return await self.send_event("SelectSource", source)
async def set_seek_time(self, time: int) -> None:
"""Seek to the specified time."""
if time < 0:
raise RussoundError("Seek time cannot be negative")
elif time > self.fetch_current_source().track_time:
raise RussoundError("Seek time cannot be greater than current track time")
await self.send_event("SetSeekTime", time)
async def set_loudness(self, loudness: bool) -> None:
"""Set the loudness of the zone."""
await self.client.set_variable(
self.device_str, "loudness", "ON" if loudness else "OFF"
)
async def set_bass(self, bass: int) -> None:
"""Set the bass of the zone."""
if bass < -10 or bass > 10:
raise RussoundError("Bass must be between -10 and 10")
await self.client.set_variable(self.device_str, "bass", str(bass))
async def set_treble(self, treble: int) -> None:
"""Set the treble of the zone."""
if treble < -10 or treble > 10:
raise RussoundError("Treble must be between -10 and 10")
await self.client.set_variable(self.device_str, "treble", str(treble))
async def set_balance(self, balance: int) -> None:
"""Set the treble of the zone."""
if balance < -10 or balance > 10:
raise RussoundError("Balance must be between -10 and 10")
await self.client.set_variable(self.device_str, "balance", str(balance))
async def set_turn_on_volume(self, turn_on_volume: int) -> None:
"""Set the turn on volume of the zone."""
if turn_on_volume < 0 or turn_on_volume > 50:
raise RussoundError("Turn on volume must be between 0 and 50")
await self.client.set_variable(
self.device_str, "turn_on_volume", str(turn_on_volume)
)
@dataclass
class Controller:
"""Data class representing a Russound controller."""
controller_id: int
controller_type: str
client: RussoundClient
device_str: str
mac_address: Optional[str]
firmware_version: Optional[str]
zones: dict[int, ZoneControlSurface] = field(default_factory=dict)
aiorussound-4.6.0/aiorussound/util.py 0000664 0000000 0000000 00000006250 15023134314 0017775 0 ustar 00root root 0000000 0000000 """Asynchronous Python client for Russound RIO."""
import re
from aiorussound.const import VERSIONS_BY_FLAGS, FeatureFlag
from aiorussound.exceptions import UnsupportedFeatureError
_fw_pattern = re.compile(r"^(?P\d{1,2})\.(?P\d{2})\.(?P\d{2})$")
def raise_unsupported_feature(api_ver: str, flag: FeatureFlag) -> None:
"""Raise an UnsupportedFeature exception if the specified feature is not supported
in the provided version.
"""
if not is_feature_supported(api_ver, flag):
err = f"Russound feature {flag} not supported in api v{api_ver}"
raise UnsupportedFeatureError(err)
def is_feature_supported(api_ver: str, flag: FeatureFlag) -> bool:
"""Return true if the feature is supported in the provided version,
false otherwise.
"""
return is_fw_version_higher(api_ver, VERSIONS_BY_FLAGS[flag])
def is_fw_version_higher(fw_a: str, fw_b: str) -> bool:
"""Return true if fw_a is greater than or equal to fw_b."""
a_match = _fw_pattern.match(fw_a)
b_match = _fw_pattern.match(fw_b)
if not (a_match and b_match):
return False
a_major = int(a_match.group("major"))
a_minor = int(a_match.group("minor"))
a_patch = int(a_match.group("patch"))
b_major = int(b_match.group("major"))
b_minor = int(b_match.group("minor"))
b_patch = int(b_match.group("patch"))
return (
(a_major > b_major)
or (a_major == b_major and a_minor > b_minor)
or (a_major == b_major and a_minor == b_minor and a_patch >= b_patch)
)
def controller_device_str(controller_id: int) -> str:
"""Return a string representation of the specified controller device."""
return f"C[{controller_id}]"
def zone_device_str(controller_id: int, zone_id: int) -> str:
"""Return a string representation of the specified zone device."""
return f"C[{controller_id}].Z[{zone_id}]"
def source_device_str(source_id: int) -> str:
"""Return a string representation of the specified source device."""
return f"S[{source_id}]"
def get_max_zones(model: str) -> int:
"""Return a maximum number of zones supported by a specific controller."""
if model in ("MCA-88", "MCA-88X", "MCA-C5"):
return 8
if model in ("MCA-66", "MCA-C3"):
return 6
return 1
def is_rnet_capable(model: str) -> bool:
"""Return whether a controller is rnet capable."""
return model in ("MCA-88X", "MCA-88", "MCA-66", "MCA-C5", "MCA-C3")
def map_rio_to_dict(state: dict, branch: str, leaf: str, value: str) -> None:
"""Maps a RIO variable to a python dictionary."""
path = re.findall(r"\w+\[?\d*]?", branch)
current = state
for part in path:
match = re.match(r"(\w+)\[(\d+)]", part)
if match:
key, index = match.groups()
index = int(index)
if key not in current:
current[key] = {}
if index not in current[key]:
current[key][index] = {}
current = current[key][index]
else:
if part not in current:
current[part] = {}
current = current[part]
# Set the leaf and value in the final dictionary location
current[leaf] = value
aiorussound-4.6.0/examples/ 0000775 0000000 0000000 00000000000 15023134314 0015706 5 ustar 00root root 0000000 0000000 aiorussound-4.6.0/examples/subscribe.py 0000664 0000000 0000000 00000002600 15023134314 0020237 0 ustar 00root root 0000000 0000000 import asyncio
import logging
# Uncomment lines below to use library from local dev
import sys
import os
sys.path.insert(1, os.path.join(os.path.dirname(__file__), ".."))
from aiorussound import RussoundTcpConnectionHandler, RussoundClient
from aiorussound.models import CallbackType
HOST = "192.168.20.17"
PORT = 4999
async def on_state_change(client: RussoundClient, callback_type: CallbackType):
"""Called when new information is received."""
print(f"Callback Type: {callback_type} {client.is_connected()}")
print(client.controllers[1].zones[1].status)
async def main():
"""Subscribe demo entrypoint."""
conn_handler = RussoundTcpConnectionHandler(HOST, PORT)
client = RussoundClient(conn_handler)
await client.register_state_update_callbacks(on_state_change)
await client.connect()
for s_id, source in client.sources.items():
print(f"Found source {s_id} - {source.name}")
for c_id, controller in client.controllers.items():
print(f"Found controller {c_id} - {controller.mac_address}")
for z_id, zone in controller.zones.items():
print(f"Found zone {z_id} - {zone.name}")
print(client.state)
# Play media using the unit's front controls or Russound app
await asyncio.sleep(30)
await client.disconnect()
if __name__ == "__main__":
logging.basicConfig(level=logging.DEBUG)
asyncio.run(main())
aiorussound-4.6.0/poetry.lock 0000664 0000000 0000000 00000220566 15023134314 0016277 0 ustar 00root root 0000000 0000000 # This file is automatically @generated by Poetry 2.1.1 and should not be changed by hand.
[[package]]
name = "astroid"
version = "3.3.8"
description = "An abstract syntax tree for Python with inference support."
optional = false
python-versions = ">=3.9.0"
groups = ["dev"]
files = [
{file = "astroid-3.3.8-py3-none-any.whl", hash = "sha256:187ccc0c248bfbba564826c26f070494f7bc964fd286b6d9fff4420e55de828c"},
{file = "astroid-3.3.8.tar.gz", hash = "sha256:a88c7994f914a4ea8572fac479459f4955eeccc877be3f2d959a33273b0cf40b"},
]
[[package]]
name = "cfgv"
version = "3.4.0"
description = "Validate configuration and produce human readable error messages."
optional = false
python-versions = ">=3.8"
groups = ["dev"]
files = [
{file = "cfgv-3.4.0-py2.py3-none-any.whl", hash = "sha256:b7265b1f29fd3316bfcd2b330d63d024f2bfd8bcb8b0272f8e19a504856c48f9"},
{file = "cfgv-3.4.0.tar.gz", hash = "sha256:e52591d4c5f5dead8e0f673fb16db7949d2cfb3f7da4582893288f0ded8fe560"},
]
[[package]]
name = "colorama"
version = "0.4.6"
description = "Cross-platform colored terminal text."
optional = false
python-versions = "!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,!=3.6.*,>=2.7"
groups = ["dev"]
markers = "sys_platform == \"win32\""
files = [
{file = "colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6"},
{file = "colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44"},
]
[[package]]
name = "coverage"
version = "7.8.2"
description = "Code coverage measurement for Python"
optional = false
python-versions = ">=3.9"
groups = ["dev"]
files = [
{file = "coverage-7.8.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:bd8ec21e1443fd7a447881332f7ce9d35b8fbd2849e761bb290b584535636b0a"},
{file = "coverage-7.8.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:4c26c2396674816deaeae7ded0e2b42c26537280f8fe313335858ffff35019be"},
{file = "coverage-7.8.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1aec326ed237e5880bfe69ad41616d333712c7937bcefc1343145e972938f9b3"},
{file = "coverage-7.8.2-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:5e818796f71702d7a13e50c70de2a1924f729228580bcba1607cccf32eea46e6"},
{file = "coverage-7.8.2-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:546e537d9e24efc765c9c891328f30f826e3e4808e31f5d0f87c4ba12bbd1622"},
{file = "coverage-7.8.2-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:ab9b09a2349f58e73f8ebc06fac546dd623e23b063e5398343c5270072e3201c"},
{file = "coverage-7.8.2-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:fd51355ab8a372d89fb0e6a31719e825cf8df8b6724bee942fb5b92c3f016ba3"},
{file = "coverage-7.8.2-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:0774df1e093acb6c9e4d58bce7f86656aeed6c132a16e2337692c12786b32404"},
{file = "coverage-7.8.2-cp310-cp310-win32.whl", hash = "sha256:00f2e2f2e37f47e5f54423aeefd6c32a7dbcedc033fcd3928a4f4948e8b96af7"},
{file = "coverage-7.8.2-cp310-cp310-win_amd64.whl", hash = "sha256:145b07bea229821d51811bf15eeab346c236d523838eda395ea969d120d13347"},
{file = "coverage-7.8.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:b99058eef42e6a8dcd135afb068b3d53aff3921ce699e127602efff9956457a9"},
{file = "coverage-7.8.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:5feb7f2c3e6ea94d3b877def0270dff0947b8d8c04cfa34a17be0a4dc1836879"},
{file = "coverage-7.8.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:670a13249b957bb9050fab12d86acef7bf8f6a879b9d1a883799276e0d4c674a"},
{file = "coverage-7.8.2-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:0bdc8bf760459a4a4187b452213e04d039990211f98644c7292adf1e471162b5"},
{file = "coverage-7.8.2-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:07a989c867986c2a75f158f03fdb413128aad29aca9d4dbce5fc755672d96f11"},
{file = "coverage-7.8.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:2db10dedeb619a771ef0e2949ccba7b75e33905de959c2643a4607bef2f3fb3a"},
{file = "coverage-7.8.2-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:e6ea7dba4e92926b7b5f0990634b78ea02f208d04af520c73a7c876d5a8d36cb"},
{file = "coverage-7.8.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:ef2f22795a7aca99fc3c84393a55a53dd18ab8c93fb431004e4d8f0774150f54"},
{file = "coverage-7.8.2-cp311-cp311-win32.whl", hash = "sha256:641988828bc18a6368fe72355df5f1703e44411adbe49bba5644b941ce6f2e3a"},
{file = "coverage-7.8.2-cp311-cp311-win_amd64.whl", hash = "sha256:8ab4a51cb39dc1933ba627e0875046d150e88478dbe22ce145a68393e9652975"},
{file = "coverage-7.8.2-cp311-cp311-win_arm64.whl", hash = "sha256:8966a821e2083c74d88cca5b7dcccc0a3a888a596a04c0b9668a891de3a0cc53"},
{file = "coverage-7.8.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:e2f6fe3654468d061942591aef56686131335b7a8325684eda85dacdf311356c"},
{file = "coverage-7.8.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:76090fab50610798cc05241bf83b603477c40ee87acd358b66196ab0ca44ffa1"},
{file = "coverage-7.8.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2bd0a0a5054be160777a7920b731a0570284db5142abaaf81bcbb282b8d99279"},
{file = "coverage-7.8.2-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:da23ce9a3d356d0affe9c7036030b5c8f14556bd970c9b224f9c8205505e3b99"},
{file = "coverage-7.8.2-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c9392773cffeb8d7e042a7b15b82a414011e9d2b5fdbbd3f7e6a6b17d5e21b20"},
{file = "coverage-7.8.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:876cbfd0b09ce09d81585d266c07a32657beb3eaec896f39484b631555be0fe2"},
{file = "coverage-7.8.2-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:3da9b771c98977a13fbc3830f6caa85cae6c9c83911d24cb2d218e9394259c57"},
{file = "coverage-7.8.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:9a990f6510b3292686713bfef26d0049cd63b9c7bb17e0864f133cbfd2e6167f"},
{file = "coverage-7.8.2-cp312-cp312-win32.whl", hash = "sha256:bf8111cddd0f2b54d34e96613e7fbdd59a673f0cf5574b61134ae75b6f5a33b8"},
{file = "coverage-7.8.2-cp312-cp312-win_amd64.whl", hash = "sha256:86a323a275e9e44cdf228af9b71c5030861d4d2610886ab920d9945672a81223"},
{file = "coverage-7.8.2-cp312-cp312-win_arm64.whl", hash = "sha256:820157de3a589e992689ffcda8639fbabb313b323d26388d02e154164c57b07f"},
{file = "coverage-7.8.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:ea561010914ec1c26ab4188aef8b1567272ef6de096312716f90e5baa79ef8ca"},
{file = "coverage-7.8.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:cb86337a4fcdd0e598ff2caeb513ac604d2f3da6d53df2c8e368e07ee38e277d"},
{file = "coverage-7.8.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:26a4636ddb666971345541b59899e969f3b301143dd86b0ddbb570bd591f1e85"},
{file = "coverage-7.8.2-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:5040536cf9b13fb033f76bcb5e1e5cb3b57c4807fef37db9e0ed129c6a094257"},
{file = "coverage-7.8.2-cp313-cp313-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:dc67994df9bcd7e0150a47ef41278b9e0a0ea187caba72414b71dc590b99a108"},
{file = "coverage-7.8.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:6e6c86888fd076d9e0fe848af0a2142bf606044dc5ceee0aa9eddb56e26895a0"},
{file = "coverage-7.8.2-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:684ca9f58119b8e26bef860db33524ae0365601492e86ba0b71d513f525e7050"},
{file = "coverage-7.8.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:8165584ddedb49204c4e18da083913bdf6a982bfb558632a79bdaadcdafd0d48"},
{file = "coverage-7.8.2-cp313-cp313-win32.whl", hash = "sha256:34759ee2c65362163699cc917bdb2a54114dd06d19bab860725f94ef45a3d9b7"},
{file = "coverage-7.8.2-cp313-cp313-win_amd64.whl", hash = "sha256:2f9bc608fbafaee40eb60a9a53dbfb90f53cc66d3d32c2849dc27cf5638a21e3"},
{file = "coverage-7.8.2-cp313-cp313-win_arm64.whl", hash = "sha256:9fe449ee461a3b0c7105690419d0b0aba1232f4ff6d120a9e241e58a556733f7"},
{file = "coverage-7.8.2-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:8369a7c8ef66bded2b6484053749ff220dbf83cba84f3398c84c51a6f748a008"},
{file = "coverage-7.8.2-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:159b81df53a5fcbc7d45dae3adad554fdbde9829a994e15227b3f9d816d00b36"},
{file = "coverage-7.8.2-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e6fcbbd35a96192d042c691c9e0c49ef54bd7ed865846a3c9d624c30bb67ce46"},
{file = "coverage-7.8.2-cp313-cp313t-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:05364b9cc82f138cc86128dc4e2e1251c2981a2218bfcd556fe6b0fbaa3501be"},
{file = "coverage-7.8.2-cp313-cp313t-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:46d532db4e5ff3979ce47d18e2fe8ecad283eeb7367726da0e5ef88e4fe64740"},
{file = "coverage-7.8.2-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:4000a31c34932e7e4fa0381a3d6deb43dc0c8f458e3e7ea6502e6238e10be625"},
{file = "coverage-7.8.2-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:43ff5033d657cd51f83015c3b7a443287250dc14e69910577c3e03bd2e06f27b"},
{file = "coverage-7.8.2-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:94316e13f0981cbbba132c1f9f365cac1d26716aaac130866ca812006f662199"},
{file = "coverage-7.8.2-cp313-cp313t-win32.whl", hash = "sha256:3f5673888d3676d0a745c3d0e16da338c5eea300cb1f4ada9c872981265e76d8"},
{file = "coverage-7.8.2-cp313-cp313t-win_amd64.whl", hash = "sha256:2c08b05ee8d7861e45dc5a2cc4195c8c66dca5ac613144eb6ebeaff2d502e73d"},
{file = "coverage-7.8.2-cp313-cp313t-win_arm64.whl", hash = "sha256:1e1448bb72b387755e1ff3ef1268a06617afd94188164960dba8d0245a46004b"},
{file = "coverage-7.8.2-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:496948261eaac5ac9cf43f5d0a9f6eb7a6d4cb3bedb2c5d294138142f5c18f2a"},
{file = "coverage-7.8.2-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:eacd2de0d30871eff893bab0b67840a96445edcb3c8fd915e6b11ac4b2f3fa6d"},
{file = "coverage-7.8.2-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b039ffddc99ad65d5078ef300e0c7eed08c270dc26570440e3ef18beb816c1ca"},
{file = "coverage-7.8.2-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:0e49824808d4375ede9dd84e9961a59c47f9113039f1a525e6be170aa4f5c34d"},
{file = "coverage-7.8.2-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b069938961dfad881dc2f8d02b47645cd2f455d3809ba92a8a687bf513839787"},
{file = "coverage-7.8.2-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:de77c3ba8bb686d1c411e78ee1b97e6e0b963fb98b1637658dd9ad2c875cf9d7"},
{file = "coverage-7.8.2-cp39-cp39-musllinux_1_2_i686.whl", hash = "sha256:1676628065a498943bd3f64f099bb573e08cf1bc6088bbe33cf4424e0876f4b3"},
{file = "coverage-7.8.2-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:8e1a26e7e50076e35f7afafde570ca2b4d7900a491174ca357d29dece5aacee7"},
{file = "coverage-7.8.2-cp39-cp39-win32.whl", hash = "sha256:6782a12bf76fa61ad9350d5a6ef5f3f020b57f5e6305cbc663803f2ebd0f270a"},
{file = "coverage-7.8.2-cp39-cp39-win_amd64.whl", hash = "sha256:1efa4166ba75ccefd647f2d78b64f53f14fb82622bc94c5a5cb0a622f50f1c9e"},
{file = "coverage-7.8.2-pp39.pp310.pp311-none-any.whl", hash = "sha256:ec455eedf3ba0bbdf8f5a570012617eb305c63cb9f03428d39bf544cb2b94837"},
{file = "coverage-7.8.2-py3-none-any.whl", hash = "sha256:726f32ee3713f7359696331a18daf0c3b3a70bb0ae71141b9d3c52be7c595e32"},
{file = "coverage-7.8.2.tar.gz", hash = "sha256:a886d531373a1f6ff9fad2a2ba4a045b68467b779ae729ee0b3b10ac20033b27"},
]
[package.extras]
toml = ["tomli ; python_full_version <= \"3.11.0a6\""]
[[package]]
name = "dill"
version = "0.3.8"
description = "serialize all of Python"
optional = false
python-versions = ">=3.8"
groups = ["dev"]
files = [
{file = "dill-0.3.8-py3-none-any.whl", hash = "sha256:c36ca9ffb54365bdd2f8eb3eff7d2a21237f8452b57ace88b1ac615b7e815bd7"},
{file = "dill-0.3.8.tar.gz", hash = "sha256:3ebe3c479ad625c4553aca177444d89b486b1d84982eeacded644afc0cf797ca"},
]
[package.extras]
graph = ["objgraph (>=1.7.2)"]
profile = ["gprof2dot (>=2022.7.29)"]
[[package]]
name = "distlib"
version = "0.3.8"
description = "Distribution utilities"
optional = false
python-versions = "*"
groups = ["dev"]
files = [
{file = "distlib-0.3.8-py2.py3-none-any.whl", hash = "sha256:034db59a0b96f8ca18035f36290806a9a6e6bd9d1ff91e45a7f172eb17e51784"},
{file = "distlib-0.3.8.tar.gz", hash = "sha256:1530ea13e350031b6312d8580ddb6b27a104275a31106523b8f123787f494f64"},
]
[[package]]
name = "filelock"
version = "3.15.4"
description = "A platform independent file lock."
optional = false
python-versions = ">=3.8"
groups = ["dev"]
files = [
{file = "filelock-3.15.4-py3-none-any.whl", hash = "sha256:6ca1fffae96225dab4c6eaf1c4f4f28cd2568d3ec2a44e15a08520504de468e7"},
{file = "filelock-3.15.4.tar.gz", hash = "sha256:2207938cbc1844345cb01a5a95524dae30f0ce089eba5b00378295a17e3e90cb"},
]
[package.extras]
docs = ["furo (>=2023.9.10)", "sphinx (>=7.2.6)", "sphinx-autodoc-typehints (>=1.25.2)"]
testing = ["covdefaults (>=2.3)", "coverage (>=7.3.2)", "diff-cover (>=8.0.1)", "pytest (>=7.4.3)", "pytest-asyncio (>=0.21)", "pytest-cov (>=4.1)", "pytest-mock (>=3.12)", "pytest-timeout (>=2.2)", "virtualenv (>=20.26.2)"]
typing = ["typing-extensions (>=4.8) ; python_version < \"3.11\""]
[[package]]
name = "identify"
version = "2.6.0"
description = "File identification library for Python"
optional = false
python-versions = ">=3.8"
groups = ["dev"]
files = [
{file = "identify-2.6.0-py2.py3-none-any.whl", hash = "sha256:e79ae4406387a9d300332b5fd366d8994f1525e8414984e1a59e058b2eda2dd0"},
{file = "identify-2.6.0.tar.gz", hash = "sha256:cb171c685bdc31bcc4c1734698736a7d5b6c8bf2e0c15117f4d469c8640ae5cf"},
]
[package.extras]
license = ["ukkonen"]
[[package]]
name = "iniconfig"
version = "2.0.0"
description = "brain-dead simple config-ini parsing"
optional = false
python-versions = ">=3.7"
groups = ["dev"]
files = [
{file = "iniconfig-2.0.0-py3-none-any.whl", hash = "sha256:b6a85871a79d2e3b22d2d1b94ac2824226a63c6b741c88f7ae975f18b6778374"},
{file = "iniconfig-2.0.0.tar.gz", hash = "sha256:2d91e135bf72d31a410b17c16da610a82cb55f6b0477d1a902134b24a455b8b3"},
]
[[package]]
name = "isort"
version = "5.13.2"
description = "A Python utility / library to sort Python imports."
optional = false
python-versions = ">=3.8.0"
groups = ["dev"]
files = [
{file = "isort-5.13.2-py3-none-any.whl", hash = "sha256:8ca5e72a8d85860d5a3fa69b8745237f2939afe12dbf656afbcb47fe72d947a6"},
{file = "isort-5.13.2.tar.gz", hash = "sha256:48fdfcb9face5d58a4f6dde2e72a1fb8dcaf8ab26f95ab49fab84c2ddefb0109"},
]
[package.extras]
colors = ["colorama (>=0.4.6)"]
[[package]]
name = "jinja2"
version = "3.1.4"
description = "A very fast and expressive template engine."
optional = false
python-versions = ">=3.7"
groups = ["docs"]
files = [
{file = "jinja2-3.1.4-py3-none-any.whl", hash = "sha256:bc5dd2abb727a5319567b7a813e6a2e7318c39f4f487cfe6c89c6f9c7d25197d"},
{file = "jinja2-3.1.4.tar.gz", hash = "sha256:4a3aee7acbbe7303aede8e9648d13b8bf88a429282aa6122a993f0ac800cb369"},
]
[package.dependencies]
MarkupSafe = ">=2.0"
[package.extras]
i18n = ["Babel (>=2.7)"]
[[package]]
name = "markupsafe"
version = "2.1.5"
description = "Safely add untrusted strings to HTML/XML markup."
optional = false
python-versions = ">=3.7"
groups = ["docs"]
files = [
{file = "MarkupSafe-2.1.5-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:a17a92de5231666cfbe003f0e4b9b3a7ae3afb1ec2845aadc2bacc93ff85febc"},
{file = "MarkupSafe-2.1.5-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:72b6be590cc35924b02c78ef34b467da4ba07e4e0f0454a2c5907f473fc50ce5"},
{file = "MarkupSafe-2.1.5-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e61659ba32cf2cf1481e575d0462554625196a1f2fc06a1c777d3f48e8865d46"},
{file = "MarkupSafe-2.1.5-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2174c595a0d73a3080ca3257b40096db99799265e1c27cc5a610743acd86d62f"},
{file = "MarkupSafe-2.1.5-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ae2ad8ae6ebee9d2d94b17fb62763125f3f374c25618198f40cbb8b525411900"},
{file = "MarkupSafe-2.1.5-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:075202fa5b72c86ad32dc7d0b56024ebdbcf2048c0ba09f1cde31bfdd57bcfff"},
{file = "MarkupSafe-2.1.5-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:598e3276b64aff0e7b3451b72e94fa3c238d452e7ddcd893c3ab324717456bad"},
{file = "MarkupSafe-2.1.5-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:fce659a462a1be54d2ffcacea5e3ba2d74daa74f30f5f143fe0c58636e355fdd"},
{file = "MarkupSafe-2.1.5-cp310-cp310-win32.whl", hash = "sha256:d9fad5155d72433c921b782e58892377c44bd6252b5af2f67f16b194987338a4"},
{file = "MarkupSafe-2.1.5-cp310-cp310-win_amd64.whl", hash = "sha256:bf50cd79a75d181c9181df03572cdce0fbb75cc353bc350712073108cba98de5"},
{file = "MarkupSafe-2.1.5-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:629ddd2ca402ae6dbedfceeba9c46d5f7b2a61d9749597d4307f943ef198fc1f"},
{file = "MarkupSafe-2.1.5-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:5b7b716f97b52c5a14bffdf688f971b2d5ef4029127f1ad7a513973cfd818df2"},
{file = "MarkupSafe-2.1.5-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6ec585f69cec0aa07d945b20805be741395e28ac1627333b1c5b0105962ffced"},
{file = "MarkupSafe-2.1.5-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b91c037585eba9095565a3556f611e3cbfaa42ca1e865f7b8015fe5c7336d5a5"},
{file = "MarkupSafe-2.1.5-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:7502934a33b54030eaf1194c21c692a534196063db72176b0c4028e140f8f32c"},
{file = "MarkupSafe-2.1.5-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:0e397ac966fdf721b2c528cf028494e86172b4feba51d65f81ffd65c63798f3f"},
{file = "MarkupSafe-2.1.5-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:c061bb86a71b42465156a3ee7bd58c8c2ceacdbeb95d05a99893e08b8467359a"},
{file = "MarkupSafe-2.1.5-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:3a57fdd7ce31c7ff06cdfbf31dafa96cc533c21e443d57f5b1ecc6cdc668ec7f"},
{file = "MarkupSafe-2.1.5-cp311-cp311-win32.whl", hash = "sha256:397081c1a0bfb5124355710fe79478cdbeb39626492b15d399526ae53422b906"},
{file = "MarkupSafe-2.1.5-cp311-cp311-win_amd64.whl", hash = "sha256:2b7c57a4dfc4f16f7142221afe5ba4e093e09e728ca65c51f5620c9aaeb9a617"},
{file = "MarkupSafe-2.1.5-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:8dec4936e9c3100156f8a2dc89c4b88d5c435175ff03413b443469c7c8c5f4d1"},
{file = "MarkupSafe-2.1.5-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:3c6b973f22eb18a789b1460b4b91bf04ae3f0c4234a0a6aa6b0a92f6f7b951d4"},
{file = "MarkupSafe-2.1.5-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ac07bad82163452a6884fe8fa0963fb98c2346ba78d779ec06bd7a6262132aee"},
{file = "MarkupSafe-2.1.5-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f5dfb42c4604dddc8e4305050aa6deb084540643ed5804d7455b5df8fe16f5e5"},
{file = "MarkupSafe-2.1.5-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ea3d8a3d18833cf4304cd2fc9cbb1efe188ca9b5efef2bdac7adc20594a0e46b"},
{file = "MarkupSafe-2.1.5-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:d050b3361367a06d752db6ead6e7edeb0009be66bc3bae0ee9d97fb326badc2a"},
{file = "MarkupSafe-2.1.5-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:bec0a414d016ac1a18862a519e54b2fd0fc8bbfd6890376898a6c0891dd82e9f"},
{file = "MarkupSafe-2.1.5-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:58c98fee265677f63a4385256a6d7683ab1832f3ddd1e66fe948d5880c21a169"},
{file = "MarkupSafe-2.1.5-cp312-cp312-win32.whl", hash = "sha256:8590b4ae07a35970728874632fed7bd57b26b0102df2d2b233b6d9d82f6c62ad"},
{file = "MarkupSafe-2.1.5-cp312-cp312-win_amd64.whl", hash = "sha256:823b65d8706e32ad2df51ed89496147a42a2a6e01c13cfb6ffb8b1e92bc910bb"},
{file = "MarkupSafe-2.1.5-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:c8b29db45f8fe46ad280a7294f5c3ec36dbac9491f2d1c17345be8e69cc5928f"},
{file = "MarkupSafe-2.1.5-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ec6a563cff360b50eed26f13adc43e61bc0c04d94b8be985e6fb24b81f6dcfdf"},
{file = "MarkupSafe-2.1.5-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a549b9c31bec33820e885335b451286e2969a2d9e24879f83fe904a5ce59d70a"},
{file = "MarkupSafe-2.1.5-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:4f11aa001c540f62c6166c7726f71f7573b52c68c31f014c25cc7901deea0b52"},
{file = "MarkupSafe-2.1.5-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:7b2e5a267c855eea6b4283940daa6e88a285f5f2a67f2220203786dfa59b37e9"},
{file = "MarkupSafe-2.1.5-cp37-cp37m-musllinux_1_1_i686.whl", hash = "sha256:2d2d793e36e230fd32babe143b04cec8a8b3eb8a3122d2aceb4a371e6b09b8df"},
{file = "MarkupSafe-2.1.5-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:ce409136744f6521e39fd8e2a24c53fa18ad67aa5bc7c2cf83645cce5b5c4e50"},
{file = "MarkupSafe-2.1.5-cp37-cp37m-win32.whl", hash = "sha256:4096e9de5c6fdf43fb4f04c26fb114f61ef0bf2e5604b6ee3019d51b69e8c371"},
{file = "MarkupSafe-2.1.5-cp37-cp37m-win_amd64.whl", hash = "sha256:4275d846e41ecefa46e2015117a9f491e57a71ddd59bbead77e904dc02b1bed2"},
{file = "MarkupSafe-2.1.5-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:656f7526c69fac7f600bd1f400991cc282b417d17539a1b228617081106feb4a"},
{file = "MarkupSafe-2.1.5-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:97cafb1f3cbcd3fd2b6fbfb99ae11cdb14deea0736fc2b0952ee177f2b813a46"},
{file = "MarkupSafe-2.1.5-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1f3fbcb7ef1f16e48246f704ab79d79da8a46891e2da03f8783a5b6fa41a9532"},
{file = "MarkupSafe-2.1.5-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fa9db3f79de01457b03d4f01b34cf91bc0048eb2c3846ff26f66687c2f6d16ab"},
{file = "MarkupSafe-2.1.5-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ffee1f21e5ef0d712f9033568f8344d5da8cc2869dbd08d87c84656e6a2d2f68"},
{file = "MarkupSafe-2.1.5-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:5dedb4db619ba5a2787a94d877bc8ffc0566f92a01c0ef214865e54ecc9ee5e0"},
{file = "MarkupSafe-2.1.5-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:30b600cf0a7ac9234b2638fbc0fb6158ba5bdcdf46aeb631ead21248b9affbc4"},
{file = "MarkupSafe-2.1.5-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:8dd717634f5a044f860435c1d8c16a270ddf0ef8588d4887037c5028b859b0c3"},
{file = "MarkupSafe-2.1.5-cp38-cp38-win32.whl", hash = "sha256:daa4ee5a243f0f20d528d939d06670a298dd39b1ad5f8a72a4275124a7819eff"},
{file = "MarkupSafe-2.1.5-cp38-cp38-win_amd64.whl", hash = "sha256:619bc166c4f2de5caa5a633b8b7326fbe98e0ccbfacabd87268a2b15ff73a029"},
{file = "MarkupSafe-2.1.5-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:7a68b554d356a91cce1236aa7682dc01df0edba8d043fd1ce607c49dd3c1edcf"},
{file = "MarkupSafe-2.1.5-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:db0b55e0f3cc0be60c1f19efdde9a637c32740486004f20d1cff53c3c0ece4d2"},
{file = "MarkupSafe-2.1.5-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3e53af139f8579a6d5f7b76549125f0d94d7e630761a2111bc431fd820e163b8"},
{file = "MarkupSafe-2.1.5-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:17b950fccb810b3293638215058e432159d2b71005c74371d784862b7e4683f3"},
{file = "MarkupSafe-2.1.5-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:4c31f53cdae6ecfa91a77820e8b151dba54ab528ba65dfd235c80b086d68a465"},
{file = "MarkupSafe-2.1.5-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:bff1b4290a66b490a2f4719358c0cdcd9bafb6b8f061e45c7a2460866bf50c2e"},
{file = "MarkupSafe-2.1.5-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:bc1667f8b83f48511b94671e0e441401371dfd0f0a795c7daa4a3cd1dde55bea"},
{file = "MarkupSafe-2.1.5-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:5049256f536511ee3f7e1b3f87d1d1209d327e818e6ae1365e8653d7e3abb6a6"},
{file = "MarkupSafe-2.1.5-cp39-cp39-win32.whl", hash = "sha256:00e046b6dd71aa03a41079792f8473dc494d564611a8f89bbbd7cb93295ebdcf"},
{file = "MarkupSafe-2.1.5-cp39-cp39-win_amd64.whl", hash = "sha256:fa173ec60341d6bb97a89f5ea19c85c5643c1e7dedebc22f5181eb73573142c5"},
{file = "MarkupSafe-2.1.5.tar.gz", hash = "sha256:d283d37a890ba4c1ae73ffadf8046435c76e7bc2247bbb63c00bd1a709c6544b"},
]
[[package]]
name = "mashumaro"
version = "3.16"
description = "Fast and well tested serialization library"
optional = false
python-versions = ">=3.9"
groups = ["main"]
files = [
{file = "mashumaro-3.16-py3-none-any.whl", hash = "sha256:d72782cdad5e164748ca883023bc5a214a80835cdca75826bf0bcbff827e0bd3"},
{file = "mashumaro-3.16.tar.gz", hash = "sha256:3844137cf053bbac30c4cbd0ee9984e839a5731a0ef96fd3dd9388359af3f2e1"},
]
[package.dependencies]
typing-extensions = ">=4.1.0"
[package.extras]
msgpack = ["msgpack (>=0.5.6)"]
orjson = ["orjson"]
toml = ["tomli (>=1.1.0) ; python_version < \"3.11\"", "tomli-w (>=1.0)"]
yaml = ["pyyaml (>=3.13)"]
[[package]]
name = "mccabe"
version = "0.7.0"
description = "McCabe checker, plugin for flake8"
optional = false
python-versions = ">=3.6"
groups = ["dev"]
files = [
{file = "mccabe-0.7.0-py2.py3-none-any.whl", hash = "sha256:6c2d30ab6be0e4a46919781807b4f0d834ebdd6c6e3dca0bda5a15f863427b6e"},
{file = "mccabe-0.7.0.tar.gz", hash = "sha256:348e0240c33b60bbdf4e523192ef919f28cb2c3d7d5c7794f74009290f236325"},
]
[[package]]
name = "mypy"
version = "1.16.0"
description = "Optional static typing for Python"
optional = false
python-versions = ">=3.9"
groups = ["dev"]
files = [
{file = "mypy-1.16.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:7909541fef256527e5ee9c0a7e2aeed78b6cda72ba44298d1334fe7881b05c5c"},
{file = "mypy-1.16.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:e71d6f0090c2256c713ed3d52711d01859c82608b5d68d4fa01a3fe30df95571"},
{file = "mypy-1.16.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:936ccfdd749af4766be824268bfe22d1db9eb2f34a3ea1d00ffbe5b5265f5491"},
{file = "mypy-1.16.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4086883a73166631307fdd330c4a9080ce24913d4f4c5ec596c601b3a4bdd777"},
{file = "mypy-1.16.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:feec38097f71797da0231997e0de3a58108c51845399669ebc532c815f93866b"},
{file = "mypy-1.16.0-cp310-cp310-win_amd64.whl", hash = "sha256:09a8da6a0ee9a9770b8ff61b39c0bb07971cda90e7297f4213741b48a0cc8d93"},
{file = "mypy-1.16.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:9f826aaa7ff8443bac6a494cf743f591488ea940dd360e7dd330e30dd772a5ab"},
{file = "mypy-1.16.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:82d056e6faa508501af333a6af192c700b33e15865bda49611e3d7d8358ebea2"},
{file = "mypy-1.16.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:089bedc02307c2548eb51f426e085546db1fa7dd87fbb7c9fa561575cf6eb1ff"},
{file = "mypy-1.16.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6a2322896003ba66bbd1318c10d3afdfe24e78ef12ea10e2acd985e9d684a666"},
{file = "mypy-1.16.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:021a68568082c5b36e977d54e8f1de978baf401a33884ffcea09bd8e88a98f4c"},
{file = "mypy-1.16.0-cp311-cp311-win_amd64.whl", hash = "sha256:54066fed302d83bf5128632d05b4ec68412e1f03ef2c300434057d66866cea4b"},
{file = "mypy-1.16.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:c5436d11e89a3ad16ce8afe752f0f373ae9620841c50883dc96f8b8805620b13"},
{file = "mypy-1.16.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:f2622af30bf01d8fc36466231bdd203d120d7a599a6d88fb22bdcb9dbff84090"},
{file = "mypy-1.16.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d045d33c284e10a038f5e29faca055b90eee87da3fc63b8889085744ebabb5a1"},
{file = "mypy-1.16.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b4968f14f44c62e2ec4a038c8797a87315be8df7740dc3ee8d3bfe1c6bf5dba8"},
{file = "mypy-1.16.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:eb14a4a871bb8efb1e4a50360d4e3c8d6c601e7a31028a2c79f9bb659b63d730"},
{file = "mypy-1.16.0-cp312-cp312-win_amd64.whl", hash = "sha256:bd4e1ebe126152a7bbaa4daedd781c90c8f9643c79b9748caa270ad542f12bec"},
{file = "mypy-1.16.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:a9e056237c89f1587a3be1a3a70a06a698d25e2479b9a2f57325ddaaffc3567b"},
{file = "mypy-1.16.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:0b07e107affb9ee6ce1f342c07f51552d126c32cd62955f59a7db94a51ad12c0"},
{file = "mypy-1.16.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c6fb60cbd85dc65d4d63d37cb5c86f4e3a301ec605f606ae3a9173e5cf34997b"},
{file = "mypy-1.16.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a7e32297a437cc915599e0578fa6bc68ae6a8dc059c9e009c628e1c47f91495d"},
{file = "mypy-1.16.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:afe420c9380ccec31e744e8baff0d406c846683681025db3531b32db56962d52"},
{file = "mypy-1.16.0-cp313-cp313-win_amd64.whl", hash = "sha256:55f9076c6ce55dd3f8cd0c6fff26a008ca8e5131b89d5ba6d86bd3f47e736eeb"},
{file = "mypy-1.16.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:f56236114c425620875c7cf71700e3d60004858da856c6fc78998ffe767b73d3"},
{file = "mypy-1.16.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:15486beea80be24ff067d7d0ede673b001d0d684d0095803b3e6e17a886a2a92"},
{file = "mypy-1.16.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f2ed0e0847a80655afa2c121835b848ed101cc7b8d8d6ecc5205aedc732b1436"},
{file = "mypy-1.16.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:eb5fbc8063cb4fde7787e4c0406aa63094a34a2daf4673f359a1fb64050e9cb2"},
{file = "mypy-1.16.0-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:a5fcfdb7318c6a8dd127b14b1052743b83e97a970f0edb6c913211507a255e20"},
{file = "mypy-1.16.0-cp39-cp39-win_amd64.whl", hash = "sha256:2e7e0ad35275e02797323a5aa1be0b14a4d03ffdb2e5f2b0489fa07b89c67b21"},
{file = "mypy-1.16.0-py3-none-any.whl", hash = "sha256:29e1499864a3888bca5c1542f2d7232c6e586295183320caa95758fc84034031"},
{file = "mypy-1.16.0.tar.gz", hash = "sha256:84b94283f817e2aa6350a14b4a8fb2a35a53c286f97c9d30f53b63620e7af8ab"},
]
[package.dependencies]
mypy_extensions = ">=1.0.0"
pathspec = ">=0.9.0"
typing_extensions = ">=4.6.0"
[package.extras]
dmypy = ["psutil (>=4.0)"]
faster-cache = ["orjson"]
install-types = ["pip"]
mypyc = ["setuptools (>=50)"]
reports = ["lxml"]
[[package]]
name = "mypy-extensions"
version = "1.0.0"
description = "Type system extensions for programs checked with the mypy type checker."
optional = false
python-versions = ">=3.5"
groups = ["dev"]
files = [
{file = "mypy_extensions-1.0.0-py3-none-any.whl", hash = "sha256:4392f6c0eb8a5668a69e23d168ffa70f0be9ccfd32b5cc2d26a34ae5b844552d"},
{file = "mypy_extensions-1.0.0.tar.gz", hash = "sha256:75dbf8955dc00442a438fc4d0666508a9a97b6bd41aa2f0ffe9d2f2725af0782"},
]
[[package]]
name = "nodeenv"
version = "1.9.1"
description = "Node.js virtual environment builder"
optional = false
python-versions = "!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,!=3.6.*,>=2.7"
groups = ["dev"]
files = [
{file = "nodeenv-1.9.1-py2.py3-none-any.whl", hash = "sha256:ba11c9782d29c27c70ffbdda2d7415098754709be8a7056d79a737cd901155c9"},
{file = "nodeenv-1.9.1.tar.gz", hash = "sha256:6ec12890a2dab7946721edbfbcd91f3319c6ccc9aec47be7c7e6b7011ee6645f"},
]
[[package]]
name = "orjson"
version = "3.10.18"
description = "Fast, correct Python JSON library supporting dataclasses, datetimes, and numpy"
optional = false
python-versions = ">=3.9"
groups = ["main"]
files = [
{file = "orjson-3.10.18-cp310-cp310-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:a45e5d68066b408e4bc383b6e4ef05e717c65219a9e1390abc6155a520cac402"},
{file = "orjson-3.10.18-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:be3b9b143e8b9db05368b13b04c84d37544ec85bb97237b3a923f076265ec89c"},
{file = "orjson-3.10.18-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:9b0aa09745e2c9b3bf779b096fa71d1cc2d801a604ef6dd79c8b1bfef52b2f92"},
{file = "orjson-3.10.18-cp310-cp310-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:53a245c104d2792e65c8d225158f2b8262749ffe64bc7755b00024757d957a13"},
{file = "orjson-3.10.18-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f9495ab2611b7f8a0a8a505bcb0f0cbdb5469caafe17b0e404c3c746f9900469"},
{file = "orjson-3.10.18-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:73be1cbcebadeabdbc468f82b087df435843c809cd079a565fb16f0f3b23238f"},
{file = "orjson-3.10.18-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fe8936ee2679e38903df158037a2f1c108129dee218975122e37847fb1d4ac68"},
{file = "orjson-3.10.18-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:7115fcbc8525c74e4c2b608129bef740198e9a120ae46184dac7683191042056"},
{file = "orjson-3.10.18-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:771474ad34c66bc4d1c01f645f150048030694ea5b2709b87d3bda273ffe505d"},
{file = "orjson-3.10.18-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:7c14047dbbea52886dd87169f21939af5d55143dad22d10db6a7514f058156a8"},
{file = "orjson-3.10.18-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:641481b73baec8db14fdf58f8967e52dc8bda1f2aba3aa5f5c1b07ed6df50b7f"},
{file = "orjson-3.10.18-cp310-cp310-win32.whl", hash = "sha256:607eb3ae0909d47280c1fc657c4284c34b785bae371d007595633f4b1a2bbe06"},
{file = "orjson-3.10.18-cp310-cp310-win_amd64.whl", hash = "sha256:8770432524ce0eca50b7efc2a9a5f486ee0113a5fbb4231526d414e6254eba92"},
{file = "orjson-3.10.18-cp311-cp311-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:e0a183ac3b8e40471e8d843105da6fbe7c070faab023be3b08188ee3f85719b8"},
{file = "orjson-3.10.18-cp311-cp311-macosx_15_0_arm64.whl", hash = "sha256:5ef7c164d9174362f85238d0cd4afdeeb89d9e523e4651add6a5d458d6f7d42d"},
{file = "orjson-3.10.18-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:afd14c5d99cdc7bf93f22b12ec3b294931518aa019e2a147e8aa2f31fd3240f7"},
{file = "orjson-3.10.18-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:7b672502323b6cd133c4af6b79e3bea36bad2d16bca6c1f645903fce83909a7a"},
{file = "orjson-3.10.18-cp311-cp311-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:51f8c63be6e070ec894c629186b1c0fe798662b8687f3d9fdfa5e401c6bd7679"},
{file = "orjson-3.10.18-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:3f9478ade5313d724e0495d167083c6f3be0dd2f1c9c8a38db9a9e912cdaf947"},
{file = "orjson-3.10.18-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:187aefa562300a9d382b4b4eb9694806e5848b0cedf52037bb5c228c61bb66d4"},
{file = "orjson-3.10.18-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9da552683bc9da222379c7a01779bddd0ad39dd699dd6300abaf43eadee38334"},
{file = "orjson-3.10.18-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:e450885f7b47a0231979d9c49b567ed1c4e9f69240804621be87c40bc9d3cf17"},
{file = "orjson-3.10.18-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:5e3c9cc2ba324187cd06287ca24f65528f16dfc80add48dc99fa6c836bb3137e"},
{file = "orjson-3.10.18-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:50ce016233ac4bfd843ac5471e232b865271d7d9d44cf9d33773bcd883ce442b"},
{file = "orjson-3.10.18-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:b3ceff74a8f7ffde0b2785ca749fc4e80e4315c0fd887561144059fb1c138aa7"},
{file = "orjson-3.10.18-cp311-cp311-win32.whl", hash = "sha256:fdba703c722bd868c04702cac4cb8c6b8ff137af2623bc0ddb3b3e6a2c8996c1"},
{file = "orjson-3.10.18-cp311-cp311-win_amd64.whl", hash = "sha256:c28082933c71ff4bc6ccc82a454a2bffcef6e1d7379756ca567c772e4fb3278a"},
{file = "orjson-3.10.18-cp311-cp311-win_arm64.whl", hash = "sha256:a6c7c391beaedd3fa63206e5c2b7b554196f14debf1ec9deb54b5d279b1b46f5"},
{file = "orjson-3.10.18-cp312-cp312-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:50c15557afb7f6d63bc6d6348e0337a880a04eaa9cd7c9d569bcb4e760a24753"},
{file = "orjson-3.10.18-cp312-cp312-macosx_15_0_arm64.whl", hash = "sha256:356b076f1662c9813d5fa56db7d63ccceef4c271b1fb3dd522aca291375fcf17"},
{file = "orjson-3.10.18-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:559eb40a70a7494cd5beab2d73657262a74a2c59aff2068fdba8f0424ec5b39d"},
{file = "orjson-3.10.18-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:f3c29eb9a81e2fbc6fd7ddcfba3e101ba92eaff455b8d602bf7511088bbc0eae"},
{file = "orjson-3.10.18-cp312-cp312-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:6612787e5b0756a171c7d81ba245ef63a3533a637c335aa7fcb8e665f4a0966f"},
{file = "orjson-3.10.18-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:7ac6bd7be0dcab5b702c9d43d25e70eb456dfd2e119d512447468f6405b4a69c"},
{file = "orjson-3.10.18-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:9f72f100cee8dde70100406d5c1abba515a7df926d4ed81e20a9730c062fe9ad"},
{file = "orjson-3.10.18-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9dca85398d6d093dd41dc0983cbf54ab8e6afd1c547b6b8a311643917fbf4e0c"},
{file = "orjson-3.10.18-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:22748de2a07fcc8781a70edb887abf801bb6142e6236123ff93d12d92db3d406"},
{file = "orjson-3.10.18-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:3a83c9954a4107b9acd10291b7f12a6b29e35e8d43a414799906ea10e75438e6"},
{file = "orjson-3.10.18-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:303565c67a6c7b1f194c94632a4a39918e067bd6176a48bec697393865ce4f06"},
{file = "orjson-3.10.18-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:86314fdb5053a2f5a5d881f03fca0219bfdf832912aa88d18676a5175c6916b5"},
{file = "orjson-3.10.18-cp312-cp312-win32.whl", hash = "sha256:187ec33bbec58c76dbd4066340067d9ece6e10067bb0cc074a21ae3300caa84e"},
{file = "orjson-3.10.18-cp312-cp312-win_amd64.whl", hash = "sha256:f9f94cf6d3f9cd720d641f8399e390e7411487e493962213390d1ae45c7814fc"},
{file = "orjson-3.10.18-cp312-cp312-win_arm64.whl", hash = "sha256:3d600be83fe4514944500fa8c2a0a77099025ec6482e8087d7659e891f23058a"},
{file = "orjson-3.10.18-cp313-cp313-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:69c34b9441b863175cc6a01f2935de994025e773f814412030f269da4f7be147"},
{file = "orjson-3.10.18-cp313-cp313-macosx_15_0_arm64.whl", hash = "sha256:1ebeda919725f9dbdb269f59bc94f861afbe2a27dce5608cdba2d92772364d1c"},
{file = "orjson-3.10.18-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5adf5f4eed520a4959d29ea80192fa626ab9a20b2ea13f8f6dc58644f6927103"},
{file = "orjson-3.10.18-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:7592bb48a214e18cd670974f289520f12b7aed1fa0b2e2616b8ed9e069e08595"},
{file = "orjson-3.10.18-cp313-cp313-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f872bef9f042734110642b7a11937440797ace8c87527de25e0c53558b579ccc"},
{file = "orjson-3.10.18-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:0315317601149c244cb3ecef246ef5861a64824ccbcb8018d32c66a60a84ffbc"},
{file = "orjson-3.10.18-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e0da26957e77e9e55a6c2ce2e7182a36a6f6b180ab7189315cb0995ec362e049"},
{file = "orjson-3.10.18-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bb70d489bc79b7519e5803e2cc4c72343c9dc1154258adf2f8925d0b60da7c58"},
{file = "orjson-3.10.18-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:e9e86a6af31b92299b00736c89caf63816f70a4001e750bda179e15564d7a034"},
{file = "orjson-3.10.18-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:c382a5c0b5931a5fc5405053d36c1ce3fd561694738626c77ae0b1dfc0242ca1"},
{file = "orjson-3.10.18-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:8e4b2ae732431127171b875cb2668f883e1234711d3c147ffd69fe5be51a8012"},
{file = "orjson-3.10.18-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:2d808e34ddb24fc29a4d4041dcfafbae13e129c93509b847b14432717d94b44f"},
{file = "orjson-3.10.18-cp313-cp313-win32.whl", hash = "sha256:ad8eacbb5d904d5591f27dee4031e2c1db43d559edb8f91778efd642d70e6bea"},
{file = "orjson-3.10.18-cp313-cp313-win_amd64.whl", hash = "sha256:aed411bcb68bf62e85588f2a7e03a6082cc42e5a2796e06e72a962d7c6310b52"},
{file = "orjson-3.10.18-cp313-cp313-win_arm64.whl", hash = "sha256:f54c1385a0e6aba2f15a40d703b858bedad36ded0491e55d35d905b2c34a4cc3"},
{file = "orjson-3.10.18-cp39-cp39-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:c95fae14225edfd699454e84f61c3dd938df6629a00c6ce15e704f57b58433bb"},
{file = "orjson-3.10.18-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5232d85f177f98e0cefabb48b5e7f60cff6f3f0365f9c60631fecd73849b2a82"},
{file = "orjson-3.10.18-cp39-cp39-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:2783e121cafedf0d85c148c248a20470018b4ffd34494a68e125e7d5857655d1"},
{file = "orjson-3.10.18-cp39-cp39-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e54ee3722caf3db09c91f442441e78f916046aa58d16b93af8a91500b7bbf273"},
{file = "orjson-3.10.18-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:2daf7e5379b61380808c24f6fc182b7719301739e4271c3ec88f2984a2d61f89"},
{file = "orjson-3.10.18-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:7f39b371af3add20b25338f4b29a8d6e79a8c7ed0e9dd49e008228a065d07781"},
{file = "orjson-3.10.18-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2b819ed34c01d88c6bec290e6842966f8e9ff84b7694632e88341363440d4cc0"},
{file = "orjson-3.10.18-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:2f6c57debaef0b1aa13092822cbd3698a1fb0209a9ea013a969f4efa36bdea57"},
{file = "orjson-3.10.18-cp39-cp39-musllinux_1_2_armv7l.whl", hash = "sha256:755b6d61ffdb1ffa1e768330190132e21343757c9aa2308c67257cc81a1a6f5a"},
{file = "orjson-3.10.18-cp39-cp39-musllinux_1_2_i686.whl", hash = "sha256:ce8d0a875a85b4c8579eab5ac535fb4b2a50937267482be402627ca7e7570ee3"},
{file = "orjson-3.10.18-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:57b5d0673cbd26781bebc2bf86f99dd19bd5a9cb55f71cc4f66419f6b50f3d77"},
{file = "orjson-3.10.18-cp39-cp39-win32.whl", hash = "sha256:951775d8b49d1d16ca8818b1f20c4965cae9157e7b562a2ae34d3967b8f21c8e"},
{file = "orjson-3.10.18-cp39-cp39-win_amd64.whl", hash = "sha256:fdd9d68f83f0bc4406610b1ac68bdcded8c5ee58605cc69e643a06f4d075f429"},
{file = "orjson-3.10.18.tar.gz", hash = "sha256:e8da3947d92123eda795b68228cafe2724815621fe35e8e320a9e9593a4bcd53"},
]
[[package]]
name = "packaging"
version = "24.1"
description = "Core utilities for Python packages"
optional = false
python-versions = ">=3.8"
groups = ["dev"]
files = [
{file = "packaging-24.1-py3-none-any.whl", hash = "sha256:5b8f2217dbdbd2f7f384c41c628544e6d52f2d0f53c6d0c3ea61aa5d1d7ff124"},
{file = "packaging-24.1.tar.gz", hash = "sha256:026ed72c8ed3fcce5bf8950572258698927fd1dbda10a5e981cdf0ac37f4f002"},
]
[[package]]
name = "pathspec"
version = "0.12.1"
description = "Utility library for gitignore style pattern matching of file paths."
optional = false
python-versions = ">=3.8"
groups = ["dev"]
files = [
{file = "pathspec-0.12.1-py3-none-any.whl", hash = "sha256:a0d503e138a4c123b27490a4f7beda6a01c6f288df0e4a8b79c7eb0dc7b4cc08"},
{file = "pathspec-0.12.1.tar.gz", hash = "sha256:a482d51503a1ab33b1c67a6c3813a26953dbdc71c31dacaef9a838c4e29f5712"},
]
[[package]]
name = "pdoc"
version = "15.0.4"
description = "API Documentation for Python Projects"
optional = false
python-versions = ">=3.9"
groups = ["docs"]
files = [
{file = "pdoc-15.0.4-py3-none-any.whl", hash = "sha256:f9028e85e7bb8475b054e69bde1f6d26fc4693d25d9fa1b1ce9009bec7f7a5c4"},
{file = "pdoc-15.0.4.tar.gz", hash = "sha256:cf9680f10f5b4863381f44ef084b1903f8f356acb0d4cc6b64576ba9fb712c82"},
]
[package.dependencies]
Jinja2 = ">=2.11.0"
MarkupSafe = ">=1.1.1"
pygments = ">=2.12.0"
[[package]]
name = "platformdirs"
version = "4.2.2"
description = "A small Python package for determining appropriate platform-specific dirs, e.g. a `user data dir`."
optional = false
python-versions = ">=3.8"
groups = ["dev"]
files = [
{file = "platformdirs-4.2.2-py3-none-any.whl", hash = "sha256:2d7a1657e36a80ea911db832a8a6ece5ee53d8de21edd5cc5879af6530b1bfee"},
{file = "platformdirs-4.2.2.tar.gz", hash = "sha256:38b7b51f512eed9e84a22788b4bce1de17c0adb134d6becb09836e37d8654cd3"},
]
[package.extras]
docs = ["furo (>=2023.9.10)", "proselint (>=0.13)", "sphinx (>=7.2.6)", "sphinx-autodoc-typehints (>=1.25.2)"]
test = ["appdirs (==1.4.4)", "covdefaults (>=2.3)", "pytest (>=7.4.3)", "pytest-cov (>=4.1)", "pytest-mock (>=3.12)"]
type = ["mypy (>=1.8)"]
[[package]]
name = "pluggy"
version = "1.5.0"
description = "plugin and hook calling mechanisms for python"
optional = false
python-versions = ">=3.8"
groups = ["dev"]
files = [
{file = "pluggy-1.5.0-py3-none-any.whl", hash = "sha256:44e1ad92c8ca002de6377e165f3e0f1be63266ab4d554740532335b9d75ea669"},
{file = "pluggy-1.5.0.tar.gz", hash = "sha256:2cffa88e94fdc978c4c574f15f9e59b7f4201d439195c3715ca9e2486f1d0cf1"},
]
[package.extras]
dev = ["pre-commit", "tox"]
testing = ["pytest", "pytest-benchmark"]
[[package]]
name = "pre-commit"
version = "4.2.0"
description = "A framework for managing and maintaining multi-language pre-commit hooks."
optional = false
python-versions = ">=3.9"
groups = ["dev"]
files = [
{file = "pre_commit-4.2.0-py2.py3-none-any.whl", hash = "sha256:a009ca7205f1eb497d10b845e52c838a98b6cdd2102a6c8e4540e94ee75c58bd"},
{file = "pre_commit-4.2.0.tar.gz", hash = "sha256:601283b9757afd87d40c4c4a9b2b5de9637a8ea02eaff7adc2d0fb4e04841146"},
]
[package.dependencies]
cfgv = ">=2.0.0"
identify = ">=1.0.0"
nodeenv = ">=0.11.1"
pyyaml = ">=5.1"
virtualenv = ">=20.10.0"
[[package]]
name = "pre-commit-hooks"
version = "5.0.0"
description = "Some out-of-the-box hooks for pre-commit."
optional = false
python-versions = ">=3.8"
groups = ["dev"]
files = [
{file = "pre_commit_hooks-5.0.0-py2.py3-none-any.whl", hash = "sha256:8d71cfb582c5c314a5498d94e0104b6567a8b93fb35903ea845c491f4e290a7a"},
{file = "pre_commit_hooks-5.0.0.tar.gz", hash = "sha256:10626959a9eaf602fbfc22bc61b6e75801436f82326bfcee82bb1f2fc4bc646e"},
]
[package.dependencies]
"ruamel.yaml" = ">=0.15"
[[package]]
name = "pygments"
version = "2.18.0"
description = "Pygments is a syntax highlighting package written in Python."
optional = false
python-versions = ">=3.8"
groups = ["dev", "docs"]
files = [
{file = "pygments-2.18.0-py3-none-any.whl", hash = "sha256:b8e6aca0523f3ab76fee51799c488e38782ac06eafcf95e7ba832985c8e7b13a"},
{file = "pygments-2.18.0.tar.gz", hash = "sha256:786ff802f32e91311bff3889f6e9a86e81505fe99f2735bb6d60ae0c5004f199"},
]
[package.extras]
windows-terminal = ["colorama (>=0.4.6)"]
[[package]]
name = "pylint"
version = "3.3.7"
description = "python code static checker"
optional = false
python-versions = ">=3.9.0"
groups = ["dev"]
files = [
{file = "pylint-3.3.7-py3-none-any.whl", hash = "sha256:43860aafefce92fca4cf6b61fe199cdc5ae54ea28f9bf4cd49de267b5195803d"},
{file = "pylint-3.3.7.tar.gz", hash = "sha256:2b11de8bde49f9c5059452e0c310c079c746a0a8eeaa789e5aa966ecc23e4559"},
]
[package.dependencies]
astroid = ">=3.3.8,<=3.4.0.dev0"
colorama = {version = ">=0.4.5", markers = "sys_platform == \"win32\""}
dill = [
{version = ">=0.3.7", markers = "python_version >= \"3.12\""},
{version = ">=0.3.6", markers = "python_version == \"3.11\""},
]
isort = ">=4.2.5,<5.13 || >5.13,<7"
mccabe = ">=0.6,<0.8"
platformdirs = ">=2.2"
tomlkit = ">=0.10.1"
[package.extras]
spelling = ["pyenchant (>=3.2,<4.0)"]
testutils = ["gitpython (>3)"]
[[package]]
name = "pytest"
version = "8.4.0"
description = "pytest: simple powerful testing with Python"
optional = false
python-versions = ">=3.9"
groups = ["dev"]
files = [
{file = "pytest-8.4.0-py3-none-any.whl", hash = "sha256:f40f825768ad76c0977cbacdf1fd37c6f7a468e460ea6a0636078f8972d4517e"},
{file = "pytest-8.4.0.tar.gz", hash = "sha256:14d920b48472ea0dbf68e45b96cd1ffda4705f33307dcc86c676c1b5104838a6"},
]
[package.dependencies]
colorama = {version = ">=0.4", markers = "sys_platform == \"win32\""}
iniconfig = ">=1"
packaging = ">=20"
pluggy = ">=1.5,<2"
pygments = ">=2.7.2"
[package.extras]
dev = ["argcomplete", "attrs (>=19.2)", "hypothesis (>=3.56)", "mock", "requests", "setuptools", "xmlschema"]
[[package]]
name = "pytest-asyncio"
version = "0.26.0"
description = "Pytest support for asyncio"
optional = false
python-versions = ">=3.9"
groups = ["dev"]
files = [
{file = "pytest_asyncio-0.26.0-py3-none-any.whl", hash = "sha256:7b51ed894f4fbea1340262bdae5135797ebbe21d8638978e35d31c6d19f72fb0"},
{file = "pytest_asyncio-0.26.0.tar.gz", hash = "sha256:c4df2a697648241ff39e7f0e4a73050b03f123f760673956cf0d72a4990e312f"},
]
[package.dependencies]
pytest = ">=8.2,<9"
[package.extras]
docs = ["sphinx (>=5.3)", "sphinx-rtd-theme (>=1)"]
testing = ["coverage (>=6.2)", "hypothesis (>=5.7.1)"]
[[package]]
name = "pytest-cov"
version = "6.1.1"
description = "Pytest plugin for measuring coverage."
optional = false
python-versions = ">=3.9"
groups = ["dev"]
files = [
{file = "pytest_cov-6.1.1-py3-none-any.whl", hash = "sha256:bddf29ed2d0ab6f4df17b4c55b0a657287db8684af9c42ea546b21b1041b3dde"},
{file = "pytest_cov-6.1.1.tar.gz", hash = "sha256:46935f7aaefba760e716c2ebfbe1c216240b9592966e7da99ea8292d4d3e2a0a"},
]
[package.dependencies]
coverage = {version = ">=7.5", extras = ["toml"]}
pytest = ">=4.6"
[package.extras]
testing = ["fields", "hunter", "process-tests", "pytest-xdist", "virtualenv"]
[[package]]
name = "pyyaml"
version = "6.0.2"
description = "YAML parser and emitter for Python"
optional = false
python-versions = ">=3.8"
groups = ["dev"]
files = [
{file = "PyYAML-6.0.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:0a9a2848a5b7feac301353437eb7d5957887edbf81d56e903999a75a3d743086"},
{file = "PyYAML-6.0.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:29717114e51c84ddfba879543fb232a6ed60086602313ca38cce623c1d62cfbf"},
{file = "PyYAML-6.0.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8824b5a04a04a047e72eea5cec3bc266db09e35de6bdfe34c9436ac5ee27d237"},
{file = "PyYAML-6.0.2-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:7c36280e6fb8385e520936c3cb3b8042851904eba0e58d277dca80a5cfed590b"},
{file = "PyYAML-6.0.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ec031d5d2feb36d1d1a24380e4db6d43695f3748343d99434e6f5f9156aaa2ed"},
{file = "PyYAML-6.0.2-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:936d68689298c36b53b29f23c6dbb74de12b4ac12ca6cfe0e047bedceea56180"},
{file = "PyYAML-6.0.2-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:23502f431948090f597378482b4812b0caae32c22213aecf3b55325e049a6c68"},
{file = "PyYAML-6.0.2-cp310-cp310-win32.whl", hash = "sha256:2e99c6826ffa974fe6e27cdb5ed0021786b03fc98e5ee3c5bfe1fd5015f42b99"},
{file = "PyYAML-6.0.2-cp310-cp310-win_amd64.whl", hash = "sha256:a4d3091415f010369ae4ed1fc6b79def9416358877534caf6a0fdd2146c87a3e"},
{file = "PyYAML-6.0.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:cc1c1159b3d456576af7a3e4d1ba7e6924cb39de8f67111c735f6fc832082774"},
{file = "PyYAML-6.0.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:1e2120ef853f59c7419231f3bf4e7021f1b936f6ebd222406c3b60212205d2ee"},
{file = "PyYAML-6.0.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5d225db5a45f21e78dd9358e58a98702a0302f2659a3c6cd320564b75b86f47c"},
{file = "PyYAML-6.0.2-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:5ac9328ec4831237bec75defaf839f7d4564be1e6b25ac710bd1a96321cc8317"},
{file = "PyYAML-6.0.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3ad2a3decf9aaba3d29c8f537ac4b243e36bef957511b4766cb0057d32b0be85"},
{file = "PyYAML-6.0.2-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:ff3824dc5261f50c9b0dfb3be22b4567a6f938ccce4587b38952d85fd9e9afe4"},
{file = "PyYAML-6.0.2-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:797b4f722ffa07cc8d62053e4cff1486fa6dc094105d13fea7b1de7d8bf71c9e"},
{file = "PyYAML-6.0.2-cp311-cp311-win32.whl", hash = "sha256:11d8f3dd2b9c1207dcaf2ee0bbbfd5991f571186ec9cc78427ba5bd32afae4b5"},
{file = "PyYAML-6.0.2-cp311-cp311-win_amd64.whl", hash = "sha256:e10ce637b18caea04431ce14fabcf5c64a1c61ec9c56b071a4b7ca131ca52d44"},
{file = "PyYAML-6.0.2-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:c70c95198c015b85feafc136515252a261a84561b7b1d51e3384e0655ddf25ab"},
{file = "PyYAML-6.0.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:ce826d6ef20b1bc864f0a68340c8b3287705cae2f8b4b1d932177dcc76721725"},
{file = "PyYAML-6.0.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1f71ea527786de97d1a0cc0eacd1defc0985dcf6b3f17bb77dcfc8c34bec4dc5"},
{file = "PyYAML-6.0.2-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:9b22676e8097e9e22e36d6b7bda33190d0d400f345f23d4065d48f4ca7ae0425"},
{file = "PyYAML-6.0.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:80bab7bfc629882493af4aa31a4cfa43a4c57c83813253626916b8c7ada83476"},
{file = "PyYAML-6.0.2-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:0833f8694549e586547b576dcfaba4a6b55b9e96098b36cdc7ebefe667dfed48"},
{file = "PyYAML-6.0.2-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:8b9c7197f7cb2738065c481a0461e50ad02f18c78cd75775628afb4d7137fb3b"},
{file = "PyYAML-6.0.2-cp312-cp312-win32.whl", hash = "sha256:ef6107725bd54b262d6dedcc2af448a266975032bc85ef0172c5f059da6325b4"},
{file = "PyYAML-6.0.2-cp312-cp312-win_amd64.whl", hash = "sha256:7e7401d0de89a9a855c839bc697c079a4af81cf878373abd7dc625847d25cbd8"},
{file = "PyYAML-6.0.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:efdca5630322a10774e8e98e1af481aad470dd62c3170801852d752aa7a783ba"},
{file = "PyYAML-6.0.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:50187695423ffe49e2deacb8cd10510bc361faac997de9efef88badc3bb9e2d1"},
{file = "PyYAML-6.0.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0ffe8360bab4910ef1b9e87fb812d8bc0a308b0d0eef8c8f44e0254ab3b07133"},
{file = "PyYAML-6.0.2-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:17e311b6c678207928d649faa7cb0d7b4c26a0ba73d41e99c4fff6b6c3276484"},
{file = "PyYAML-6.0.2-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:70b189594dbe54f75ab3a1acec5f1e3faa7e8cf2f1e08d9b561cb41b845f69d5"},
{file = "PyYAML-6.0.2-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:41e4e3953a79407c794916fa277a82531dd93aad34e29c2a514c2c0c5fe971cc"},
{file = "PyYAML-6.0.2-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:68ccc6023a3400877818152ad9a1033e3db8625d899c72eacb5a668902e4d652"},
{file = "PyYAML-6.0.2-cp313-cp313-win32.whl", hash = "sha256:bc2fa7c6b47d6bc618dd7fb02ef6fdedb1090ec036abab80d4681424b84c1183"},
{file = "PyYAML-6.0.2-cp313-cp313-win_amd64.whl", hash = "sha256:8388ee1976c416731879ac16da0aff3f63b286ffdd57cdeb95f3f2e085687563"},
{file = "PyYAML-6.0.2-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:24471b829b3bf607e04e88d79542a9d48bb037c2267d7927a874e6c205ca7e9a"},
{file = "PyYAML-6.0.2-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d7fded462629cfa4b685c5416b949ebad6cec74af5e2d42905d41e257e0869f5"},
{file = "PyYAML-6.0.2-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:d84a1718ee396f54f3a086ea0a66d8e552b2ab2017ef8b420e92edbc841c352d"},
{file = "PyYAML-6.0.2-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9056c1ecd25795207ad294bcf39f2db3d845767be0ea6e6a34d856f006006083"},
{file = "PyYAML-6.0.2-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:82d09873e40955485746739bcb8b4586983670466c23382c19cffecbf1fd8706"},
{file = "PyYAML-6.0.2-cp38-cp38-win32.whl", hash = "sha256:43fa96a3ca0d6b1812e01ced1044a003533c47f6ee8aca31724f78e93ccc089a"},
{file = "PyYAML-6.0.2-cp38-cp38-win_amd64.whl", hash = "sha256:01179a4a8559ab5de078078f37e5c1a30d76bb88519906844fd7bdea1b7729ff"},
{file = "PyYAML-6.0.2-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:688ba32a1cffef67fd2e9398a2efebaea461578b0923624778664cc1c914db5d"},
{file = "PyYAML-6.0.2-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:a8786accb172bd8afb8be14490a16625cbc387036876ab6ba70912730faf8e1f"},
{file = "PyYAML-6.0.2-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d8e03406cac8513435335dbab54c0d385e4a49e4945d2909a581c83647ca0290"},
{file = "PyYAML-6.0.2-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f753120cb8181e736c57ef7636e83f31b9c0d1722c516f7e86cf15b7aa57ff12"},
{file = "PyYAML-6.0.2-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3b1fdb9dc17f5a7677423d508ab4f243a726dea51fa5e70992e59a7411c89d19"},
{file = "PyYAML-6.0.2-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:0b69e4ce7a131fe56b7e4d770c67429700908fc0752af059838b1cfb41960e4e"},
{file = "PyYAML-6.0.2-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:a9f8c2e67970f13b16084e04f134610fd1d374bf477b17ec1599185cf611d725"},
{file = "PyYAML-6.0.2-cp39-cp39-win32.whl", hash = "sha256:6395c297d42274772abc367baaa79683958044e5d3835486c16da75d2a694631"},
{file = "PyYAML-6.0.2-cp39-cp39-win_amd64.whl", hash = "sha256:39693e1f8320ae4f43943590b49779ffb98acb81f788220ea932a6b6c51004d8"},
{file = "pyyaml-6.0.2.tar.gz", hash = "sha256:d584d9ec91ad65861cc08d42e834324ef890a082e591037abe114850ff7bbc3e"},
]
[[package]]
name = "ruamel-yaml"
version = "0.18.6"
description = "ruamel.yaml is a YAML parser/emitter that supports roundtrip preservation of comments, seq/map flow style, and map key order"
optional = false
python-versions = ">=3.7"
groups = ["dev"]
files = [
{file = "ruamel.yaml-0.18.6-py3-none-any.whl", hash = "sha256:57b53ba33def16c4f3d807c0ccbc00f8a6081827e81ba2491691b76882d0c636"},
{file = "ruamel.yaml-0.18.6.tar.gz", hash = "sha256:8b27e6a217e786c6fbe5634d8f3f11bc63e0f80f6a5890f28863d9c45aac311b"},
]
[package.dependencies]
"ruamel.yaml.clib" = {version = ">=0.2.7", markers = "platform_python_implementation == \"CPython\" and python_version < \"3.13\""}
[package.extras]
docs = ["mercurial (>5.7)", "ryd"]
jinja2 = ["ruamel.yaml.jinja2 (>=0.2)"]
[[package]]
name = "ruamel-yaml-clib"
version = "0.2.8"
description = "C version of reader, parser and emitter for ruamel.yaml derived from libyaml"
optional = false
python-versions = ">=3.6"
groups = ["dev"]
markers = "platform_python_implementation == \"CPython\" and python_version < \"3.13\""
files = [
{file = "ruamel.yaml.clib-0.2.8-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:b42169467c42b692c19cf539c38d4602069d8c1505e97b86387fcf7afb766e1d"},
{file = "ruamel.yaml.clib-0.2.8-cp310-cp310-macosx_13_0_arm64.whl", hash = "sha256:07238db9cbdf8fc1e9de2489a4f68474e70dffcb32232db7c08fa61ca0c7c462"},
{file = "ruamel.yaml.clib-0.2.8-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_24_x86_64.whl", hash = "sha256:fff3573c2db359f091e1589c3d7c5fc2f86f5bdb6f24252c2d8e539d4e45f412"},
{file = "ruamel.yaml.clib-0.2.8-cp310-cp310-manylinux_2_24_aarch64.whl", hash = "sha256:aa2267c6a303eb483de8d02db2871afb5c5fc15618d894300b88958f729ad74f"},
{file = "ruamel.yaml.clib-0.2.8-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:840f0c7f194986a63d2c2465ca63af8ccbbc90ab1c6001b1978f05119b5e7334"},
{file = "ruamel.yaml.clib-0.2.8-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:024cfe1fc7c7f4e1aff4a81e718109e13409767e4f871443cbff3dba3578203d"},
{file = "ruamel.yaml.clib-0.2.8-cp310-cp310-win32.whl", hash = "sha256:c69212f63169ec1cfc9bb44723bf2917cbbd8f6191a00ef3410f5a7fe300722d"},
{file = "ruamel.yaml.clib-0.2.8-cp310-cp310-win_amd64.whl", hash = "sha256:cabddb8d8ead485e255fe80429f833172b4cadf99274db39abc080e068cbcc31"},
{file = "ruamel.yaml.clib-0.2.8-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:bef08cd86169d9eafb3ccb0a39edb11d8e25f3dae2b28f5c52fd997521133069"},
{file = "ruamel.yaml.clib-0.2.8-cp311-cp311-macosx_13_0_arm64.whl", hash = "sha256:b16420e621d26fdfa949a8b4b47ade8810c56002f5389970db4ddda51dbff248"},
{file = "ruamel.yaml.clib-0.2.8-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_24_x86_64.whl", hash = "sha256:25c515e350e5b739842fc3228d662413ef28f295791af5e5110b543cf0b57d9b"},
{file = "ruamel.yaml.clib-0.2.8-cp311-cp311-manylinux_2_24_aarch64.whl", hash = "sha256:1707814f0d9791df063f8c19bb51b0d1278b8e9a2353abbb676c2f685dee6afe"},
{file = "ruamel.yaml.clib-0.2.8-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:46d378daaac94f454b3a0e3d8d78cafd78a026b1d71443f4966c696b48a6d899"},
{file = "ruamel.yaml.clib-0.2.8-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:09b055c05697b38ecacb7ac50bdab2240bfca1a0c4872b0fd309bb07dc9aa3a9"},
{file = "ruamel.yaml.clib-0.2.8-cp311-cp311-win32.whl", hash = "sha256:53a300ed9cea38cf5a2a9b069058137c2ca1ce658a874b79baceb8f892f915a7"},
{file = "ruamel.yaml.clib-0.2.8-cp311-cp311-win_amd64.whl", hash = "sha256:c2a72e9109ea74e511e29032f3b670835f8a59bbdc9ce692c5b4ed91ccf1eedb"},
{file = "ruamel.yaml.clib-0.2.8-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:ebc06178e8821efc9692ea7544aa5644217358490145629914d8020042c24aa1"},
{file = "ruamel.yaml.clib-0.2.8-cp312-cp312-macosx_13_0_arm64.whl", hash = "sha256:edaef1c1200c4b4cb914583150dcaa3bc30e592e907c01117c08b13a07255ec2"},
{file = "ruamel.yaml.clib-0.2.8-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d176b57452ab5b7028ac47e7b3cf644bcfdc8cacfecf7e71759f7f51a59e5c92"},
{file = "ruamel.yaml.clib-0.2.8-cp312-cp312-manylinux_2_24_aarch64.whl", hash = "sha256:1dc67314e7e1086c9fdf2680b7b6c2be1c0d8e3a8279f2e993ca2a7545fecf62"},
{file = "ruamel.yaml.clib-0.2.8-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:3213ece08ea033eb159ac52ae052a4899b56ecc124bb80020d9bbceeb50258e9"},
{file = "ruamel.yaml.clib-0.2.8-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:aab7fd643f71d7946f2ee58cc88c9b7bfc97debd71dcc93e03e2d174628e7e2d"},
{file = "ruamel.yaml.clib-0.2.8-cp312-cp312-win32.whl", hash = "sha256:5c365d91c88390c8d0a8545df0b5857172824b1c604e867161e6b3d59a827eaa"},
{file = "ruamel.yaml.clib-0.2.8-cp312-cp312-win_amd64.whl", hash = "sha256:1758ce7d8e1a29d23de54a16ae867abd370f01b5a69e1a3ba75223eaa3ca1a1b"},
{file = "ruamel.yaml.clib-0.2.8-cp36-cp36m-manylinux_2_5_x86_64.manylinux1_x86_64.whl", hash = "sha256:a5aa27bad2bb83670b71683aae140a1f52b0857a2deff56ad3f6c13a017a26ed"},
{file = "ruamel.yaml.clib-0.2.8-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:c58ecd827313af6864893e7af0a3bb85fd529f862b6adbefe14643947cfe2942"},
{file = "ruamel.yaml.clib-0.2.8-cp37-cp37m-macosx_12_0_arm64.whl", hash = "sha256:f481f16baec5290e45aebdc2a5168ebc6d35189ae6fea7a58787613a25f6e875"},
{file = "ruamel.yaml.clib-0.2.8-cp37-cp37m-manylinux_2_24_aarch64.whl", hash = "sha256:77159f5d5b5c14f7c34073862a6b7d34944075d9f93e681638f6d753606c6ce6"},
{file = "ruamel.yaml.clib-0.2.8-cp37-cp37m-manylinux_2_5_x86_64.manylinux1_x86_64.whl", hash = "sha256:7f67a1ee819dc4562d444bbafb135832b0b909f81cc90f7aa00260968c9ca1b3"},
{file = "ruamel.yaml.clib-0.2.8-cp37-cp37m-musllinux_1_1_i686.whl", hash = "sha256:4ecbf9c3e19f9562c7fdd462e8d18dd902a47ca046a2e64dba80699f0b6c09b7"},
{file = "ruamel.yaml.clib-0.2.8-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:87ea5ff66d8064301a154b3933ae406b0863402a799b16e4a1d24d9fbbcbe0d3"},
{file = "ruamel.yaml.clib-0.2.8-cp37-cp37m-win32.whl", hash = "sha256:75e1ed13e1f9de23c5607fe6bd1aeaae21e523b32d83bb33918245361e9cc51b"},
{file = "ruamel.yaml.clib-0.2.8-cp37-cp37m-win_amd64.whl", hash = "sha256:3f215c5daf6a9d7bbed4a0a4f760f3113b10e82ff4c5c44bec20a68c8014f675"},
{file = "ruamel.yaml.clib-0.2.8-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:1b617618914cb00bf5c34d4357c37aa15183fa229b24767259657746c9077615"},
{file = "ruamel.yaml.clib-0.2.8-cp38-cp38-macosx_12_0_arm64.whl", hash = "sha256:a6a9ffd280b71ad062eae53ac1659ad86a17f59a0fdc7699fd9be40525153337"},
{file = "ruamel.yaml.clib-0.2.8-cp38-cp38-manylinux_2_24_aarch64.whl", hash = "sha256:305889baa4043a09e5b76f8e2a51d4ffba44259f6b4c72dec8ca56207d9c6fe1"},
{file = "ruamel.yaml.clib-0.2.8-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.whl", hash = "sha256:700e4ebb569e59e16a976857c8798aee258dceac7c7d6b50cab63e080058df91"},
{file = "ruamel.yaml.clib-0.2.8-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:e2b4c44b60eadec492926a7270abb100ef9f72798e18743939bdbf037aab8c28"},
{file = "ruamel.yaml.clib-0.2.8-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:e79e5db08739731b0ce4850bed599235d601701d5694c36570a99a0c5ca41a9d"},
{file = "ruamel.yaml.clib-0.2.8-cp38-cp38-win32.whl", hash = "sha256:955eae71ac26c1ab35924203fda6220f84dce57d6d7884f189743e2abe3a9fbe"},
{file = "ruamel.yaml.clib-0.2.8-cp38-cp38-win_amd64.whl", hash = "sha256:56f4252222c067b4ce51ae12cbac231bce32aee1d33fbfc9d17e5b8d6966c312"},
{file = "ruamel.yaml.clib-0.2.8-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:03d1162b6d1df1caa3a4bd27aa51ce17c9afc2046c31b0ad60a0a96ec22f8001"},
{file = "ruamel.yaml.clib-0.2.8-cp39-cp39-macosx_12_0_arm64.whl", hash = "sha256:bba64af9fa9cebe325a62fa398760f5c7206b215201b0ec825005f1b18b9bccf"},
{file = "ruamel.yaml.clib-0.2.8-cp39-cp39-manylinux_2_24_aarch64.whl", hash = "sha256:a1a45e0bb052edf6a1d3a93baef85319733a888363938e1fc9924cb00c8df24c"},
{file = "ruamel.yaml.clib-0.2.8-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.whl", hash = "sha256:da09ad1c359a728e112d60116f626cc9f29730ff3e0e7db72b9a2dbc2e4beed5"},
{file = "ruamel.yaml.clib-0.2.8-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:184565012b60405d93838167f425713180b949e9d8dd0bbc7b49f074407c5a8b"},
{file = "ruamel.yaml.clib-0.2.8-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:a75879bacf2c987c003368cf14bed0ffe99e8e85acfa6c0bfffc21a090f16880"},
{file = "ruamel.yaml.clib-0.2.8-cp39-cp39-win32.whl", hash = "sha256:84b554931e932c46f94ab306913ad7e11bba988104c5cff26d90d03f68258cd5"},
{file = "ruamel.yaml.clib-0.2.8-cp39-cp39-win_amd64.whl", hash = "sha256:25ac8c08322002b06fa1d49d1646181f0b2c72f5cbc15a85e80b4c30a544bb15"},
{file = "ruamel.yaml.clib-0.2.8.tar.gz", hash = "sha256:beb2e0404003de9a4cab9753a8805a8fe9320ee6673136ed7f04255fe60bb512"},
]
[[package]]
name = "ruff"
version = "0.11.13"
description = "An extremely fast Python linter and code formatter, written in Rust."
optional = false
python-versions = ">=3.7"
groups = ["dev"]
files = [
{file = "ruff-0.11.13-py3-none-linux_armv6l.whl", hash = "sha256:4bdfbf1240533f40042ec00c9e09a3aade6f8c10b6414cf11b519488d2635d46"},
{file = "ruff-0.11.13-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:aef9c9ed1b5ca28bb15c7eac83b8670cf3b20b478195bd49c8d756ba0a36cf48"},
{file = "ruff-0.11.13-py3-none-macosx_11_0_arm64.whl", hash = "sha256:53b15a9dfdce029c842e9a5aebc3855e9ab7771395979ff85b7c1dedb53ddc2b"},
{file = "ruff-0.11.13-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ab153241400789138d13f362c43f7edecc0edfffce2afa6a68434000ecd8f69a"},
{file = "ruff-0.11.13-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:6c51f93029d54a910d3d24f7dd0bb909e31b6cd989a5e4ac513f4eb41629f0dc"},
{file = "ruff-0.11.13-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1808b3ed53e1a777c2ef733aca9051dc9bf7c99b26ece15cb59a0320fbdbd629"},
{file = "ruff-0.11.13-py3-none-manylinux_2_17_ppc64.manylinux2014_ppc64.whl", hash = "sha256:d28ce58b5ecf0f43c1b71edffabe6ed7f245d5336b17805803312ec9bc665933"},
{file = "ruff-0.11.13-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:55e4bc3a77842da33c16d55b32c6cac1ec5fb0fbec9c8c513bdce76c4f922165"},
{file = "ruff-0.11.13-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:633bf2c6f35678c56ec73189ba6fa19ff1c5e4807a78bf60ef487b9dd272cc71"},
{file = "ruff-0.11.13-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4ffbc82d70424b275b089166310448051afdc6e914fdab90e08df66c43bb5ca9"},
{file = "ruff-0.11.13-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:4a9ddd3ec62a9a89578c85842b836e4ac832d4a2e0bfaad3b02243f930ceafcc"},
{file = "ruff-0.11.13-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:d237a496e0778d719efb05058c64d28b757c77824e04ffe8796c7436e26712b7"},
{file = "ruff-0.11.13-py3-none-musllinux_1_2_i686.whl", hash = "sha256:26816a218ca6ef02142343fd24c70f7cd8c5aa6c203bca284407adf675984432"},
{file = "ruff-0.11.13-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:51c3f95abd9331dc5b87c47ac7f376db5616041173826dfd556cfe3d4977f492"},
{file = "ruff-0.11.13-py3-none-win32.whl", hash = "sha256:96c27935418e4e8e77a26bb05962817f28b8ef3843a6c6cc49d8783b5507f250"},
{file = "ruff-0.11.13-py3-none-win_amd64.whl", hash = "sha256:29c3189895a8a6a657b7af4e97d330c8a3afd2c9c8f46c81e2fc5a31866517e3"},
{file = "ruff-0.11.13-py3-none-win_arm64.whl", hash = "sha256:b4385285e9179d608ff1d2fb9922062663c658605819a6876d8beef0c30b7f3b"},
{file = "ruff-0.11.13.tar.gz", hash = "sha256:26fa247dc68d1d4e72c179e08889a25ac0c7ba4d78aecfc835d49cbfd60bf514"},
]
[[package]]
name = "tomlkit"
version = "0.13.2"
description = "Style preserving TOML library"
optional = false
python-versions = ">=3.8"
groups = ["dev"]
files = [
{file = "tomlkit-0.13.2-py3-none-any.whl", hash = "sha256:7a974427f6e119197f670fbbbeae7bef749a6c14e793db934baefc1b5f03efde"},
{file = "tomlkit-0.13.2.tar.gz", hash = "sha256:fff5fe59a87295b278abd31bec92c15d9bc4a06885ab12bcea52c71119392e79"},
]
[[package]]
name = "typing-extensions"
version = "4.12.2"
description = "Backported and Experimental Type Hints for Python 3.8+"
optional = false
python-versions = ">=3.8"
groups = ["main", "dev"]
files = [
{file = "typing_extensions-4.12.2-py3-none-any.whl", hash = "sha256:04e5ca0351e0f3f85c6853954072df659d0d13fac324d0072316b67d7794700d"},
{file = "typing_extensions-4.12.2.tar.gz", hash = "sha256:1a7ead55c7e559dd4dee8856e3a88b41225abfe1ce8df57b7c13915fe121ffb8"},
]
[[package]]
name = "virtualenv"
version = "20.26.3"
description = "Virtual Python Environment builder"
optional = false
python-versions = ">=3.7"
groups = ["dev"]
files = [
{file = "virtualenv-20.26.3-py3-none-any.whl", hash = "sha256:8cc4a31139e796e9a7de2cd5cf2489de1217193116a8fd42328f1bd65f434589"},
{file = "virtualenv-20.26.3.tar.gz", hash = "sha256:4c43a2a236279d9ea36a0d76f98d84bd6ca94ac4e0f4a3b9d46d05e10fea542a"},
]
[package.dependencies]
distlib = ">=0.3.7,<1"
filelock = ">=3.12.2,<4"
platformdirs = ">=3.9.1,<5"
[package.extras]
docs = ["furo (>=2023.7.26)", "proselint (>=0.13)", "sphinx (>=7.1.2,!=7.3)", "sphinx-argparse (>=0.4)", "sphinxcontrib-towncrier (>=0.2.1a0)", "towncrier (>=23.6)"]
test = ["covdefaults (>=2.3)", "coverage (>=7.2.7)", "coverage-enable-subprocess (>=1)", "flaky (>=3.7)", "packaging (>=23.1)", "pytest (>=7.4)", "pytest-env (>=0.8.2)", "pytest-freezer (>=0.4.8) ; platform_python_implementation == \"PyPy\" or platform_python_implementation == \"CPython\" and sys_platform == \"win32\" and python_version >= \"3.13\"", "pytest-mock (>=3.11.1)", "pytest-randomly (>=3.12)", "pytest-timeout (>=2.1)", "setuptools (>=68)", "time-machine (>=2.10) ; platform_python_implementation == \"CPython\""]
[metadata]
lock-version = "2.1"
python-versions = "^3.11"
content-hash = "d864b8cdfde7e8ba0dc882b8938b5e8149a1f943a443b5edfe678074e2f41323"
aiorussound-4.6.0/pyproject.toml 0000664 0000000 0000000 00000001567 15023134314 0017015 0 ustar 00root root 0000000 0000000 [tool.poetry]
name = "aiorussound"
version = "4.6.0"
description = "Asyncio client for Russound RIO devices."
authors = ["Noah Husby "]
maintainers = ["Noah Husby "]
license = "MIT"
readme = "README.md"
homepage = "https://github.com/noahhusby/aiorussound"
repository = "https://github.com/noahhusby/aiorussound"
documentation = "https://github.com/noahhusby/aiorussound"
[tool.poetry.dependencies]
python = "^3.11"
mashumaro = "^3.11"
orjson = ">=3.9.0"
[tool.poetry.group.dev.dependencies]
coverage = {version = "7.8.2"}
mypy = "1.16.0"
pre-commit = "4.2.0"
pre-commit-hooks = "5.0.0"
pylint = "3.3.7"
pytest = "8.4.0"
pytest-asyncio = "0.26.0"
pytest-cov = "6.1.1"
ruff = "0.11.13"
[tool.poetry.group.docs.dependencies]
pdoc = ">=14.7,<16.0"
[build-system]
build-backend = "poetry.core.masonry.api"
requires = ["poetry-core"]
aiorussound-4.6.0/sonar-project.properties 0000664 0000000 0000000 00000000153 15023134314 0020773 0 ustar 00root root 0000000 0000000 sonar.projectKey=noahhusby_aiorussound_AZCkW9bdnebbc8m1axNR
sonar.python.coverage.reportPaths=coverage.xml
aiorussound-4.6.0/tests/ 0000775 0000000 0000000 00000000000 15023134314 0015232 5 ustar 00root root 0000000 0000000 aiorussound-4.6.0/tests/__init__.py 0000664 0000000 0000000 00000000052 15023134314 0017340 0 ustar 00root root 0000000 0000000 """Tests for the Russound RIO package."""
aiorussound-4.6.0/tests/test_util.py 0000664 0000000 0000000 00000005532 15023134314 0017625 0 ustar 00root root 0000000 0000000 """Tests for the Russound RIO package."""
from contextlib import nullcontext
import pytest
from aiorussound.const import FeatureFlag
from aiorussound.exceptions import UnsupportedFeatureError
from aiorussound.util import (
controller_device_str,
get_max_zones,
is_feature_supported,
is_fw_version_higher,
raise_unsupported_feature,
source_device_str,
zone_device_str,
)
@pytest.mark.parametrize(
"version,expectation",
[("1.05.00", nullcontext()), ("1.03.00", pytest.raises(UnsupportedFeatureError))],
)
def test_raise_unsupported_feature(version: str, expectation: Exception) -> None:
"""Test whether raise_unsupported_feature raises an exception
under the proper circumstances.
"""
with expectation:
raise_unsupported_feature(version, FeatureFlag.PROPERTY_CTRL_TYPE)
@pytest.mark.parametrize("version,result", [("1.05.00", True), ("1.03.00", False)])
def test_is_feature_supported(version: str, result: bool) -> None:
"""Test whether features are being properly detected by version."""
assert is_feature_supported(version, FeatureFlag.PROPERTY_CTRL_TYPE) == result
@pytest.mark.parametrize(
"version,result",
[("1.10.00", True), ("1.03.00", True), ("1.10.01", False), ("1.12.00", False)],
)
def test_is_fw_version_higher(version: str, result: bool) -> None:
"""Test whether firmware versions are being properly compared."""
assert is_fw_version_higher("1.10.00", version) == result
def test_is_fw_version_higher_wrong_format() -> None:
"""Test if incorrect version formats are being detected."""
assert is_fw_version_higher("1.234.44", "1.10.00") is False
assert is_fw_version_higher("abcd", "1.10.00") is False
@pytest.mark.parametrize("controller_id,result", [(1, "C[1]"), (6, "C[6]")])
def test_controller_device_str(controller_id: int, result: str) -> None:
"""Test if the controller device string is correct."""
assert controller_device_str(controller_id) == result
@pytest.mark.parametrize(
"controller_id,zone_id,result", [(1, 2, "C[1].Z[2]"), (6, 3, "C[6].Z[3]")]
)
def test_zone_device_str(controller_id: int, zone_id: int, result: str) -> None:
"""Test if the zone device string is correct."""
assert zone_device_str(controller_id, zone_id) == result
@pytest.mark.parametrize("source_id,result", [(1, "S[1]"), (2, "S[2]")])
def test_source_device_str(source_id: int, result: str) -> None:
"""Test if the source device string is correct."""
assert source_device_str(source_id) == result
@pytest.mark.parametrize(
"model,max_zones",
[
("MCA-C5", 8),
("MCA-88", 8),
("MCA-66", 6),
("MCA-C3", 6),
("MBX-PRE", 1),
("Other", 1),
],
)
def test_get_max_zones(model: str, max_zones: int) -> None:
"""Test if the maximum number of zones is correct."""
assert get_max_zones(model) == max_zones
aiorussound-4.6.0/tox.ini 0000664 0000000 0000000 00000001256 15023134314 0015407 0 ustar 00root root 0000000 0000000 # Tox (https://tox.readthedocs.io/) is a tool for running tests
# in multiple virtualenvs. This configuration file will run the
# test suite on all supported python versions. To use it, "pip install tox"
# and then run "tox" from this directory.
[tox]
envlist = py37, py38, py39, py310, py311, flake8
[testenv]
commands =
coverage run -m pytest
coverage xml
deps =
pytest
pytest-cov
[testenv:flake8]
basepython = python3
deps =
flake8
commands = flake8 aiorussound/
[travis]
python =
3.7: py37, flake8
3.8: py38, flake8
3.9: py39, flake8
3.10: py310, flake8
3.11: py311, flake8
[coverage:run]
relative_files = True
source = aiorussound/
branch = True