minor version bump

add 2.4.0 section to CHANGELOG

upd README with HeadAmp class

closes #10

.gitignore

@@ -130,4 +130,6 @@ dmypy.json
 
 # config, quick test
 config.toml
-quick.py
+quick.py
+
+.vscode/

CHANGELOG.md

@@ -9,62 +9,138 @@ Before any major/minor/patch bump all unit tests will be run to verify they pass
 
 ## [Unreleased]
 
--   [x]
+- [ ] 
+
+## [2.4.0] - 2025-01-04
+
+### Added
+
+- HeadAmp class to all kinds for enabling phantom power and setting preamp gain.
+- headamp example.
+
+## [2.3.2] - 2024-02-16
+
+### Added
+
+- Configurable kwarg `connect_timeout` added. Defaults to 2 seconds.
+- New error class `XAirRemoteConnectionTimeoutError`. Raised if a connection validation times out.
+- timeout kwarg + Errors section added to README.
+
+## [2.3.1] - 2024-02-15
+
+### Changed
+
+- Module level loggers implemented
+  - class loggers are now child loggers
+- Passing an incorrect kind_id to the entry point now raises an XAirRemoteError.
+- Passing a value out of bounds to a setter now logs a warning instead of raising an exception.
+- Send class added to README.
+
+## [2.2.4] - 2024-02-14
+
+### Added
+
+- Send class mixed into Strip, AuxRtn, FxRtn. May now be accessed with {Class}.send
+- Sends example added
+
+### Changed
+
+- delay kwarg now applies to getters. See [Issue #6](https://github.com/onyx-and-iris/xair-api-python/issues/6).
+
+## [2.2.0] - 2022-11-08
+
+### Added
+
+- mute prop to Bus, FX, LR, RTN, Strip classes.
+
+## [2.1.0] - 2022-11-08
+
+### Added
+
+- delay keyword argument
+- bounds checks for vals passed to lin_set/log_set
+
+### Removed
+
+- type checks, prefer duck typing
+
+## [2.0.0] - 2022-11-07
+
+Some support for the X32 mixer has been added using an adapter module but the code related to the XAir api has been left largely untouched.
+However, a couple of changes have been made which are breaking, they are as follows:
+
+### Changed
+
+- FX class added to fx module. This now deals with osc addresses that begin with "/fx/". Call it with mixer.fx.
+- FxRtn class added to rtn module. This now deals with addresses that begin with "/rtn/". Call it with mixer.fxreturn
+- Aux class renamed to AuxRtn in rtn module. Call it with mixer.auxreturn.
+
+These changes were made to better resemble the underlying osc api and to better describe the function of the classes.
+
+### Added
+
+- A small number of X32 tests. More will be added. XAir tests moved into it's own test module.
+- XAirRemote lower level section added to README.
+- Links to OSC command documentation added to README.
+
+### Removed
+
+- mixer.aux was renamed to mixer.auxreturn
 
 ## [1.1.0] - 2022-09-05
 
 ### Added
 
--   tomli/tomllib compatibility layer to support python 3.10
+- tomli/tomllib compatibility layer to support python 3.10
 
 ## [1.0.2] - 2022-08-07
 
 ### Added
 
--   now packaged with poetry
+- now packaged with poetry
--   package added to pypi
+- package added to pypi
--   pypi, isort badges added to readme
+- pypi, isort badges added to readme
 
 ### Changed
 
--   package renamed to xair-api
+- package renamed to xair-api
--   now using tomllib for config, requires python 3.11
+- now using tomllib for config, requires python 3.11
--   readme, example updated.
+- readme, example updated.
--   imports isorted.
+- imports isorted.
 
 ## [0.1.0] - 2022-05-01
 
 ### Added
 
--   kind maps for "XR16", "XR12" added.
+- kind maps for "XR16", "XR12" added.
--   get() added to kind module.
+- get() added to kind module.
--   pre-commit.ps1 added for use with git hook.
+- pre-commit.ps1 added for use with git hook.
--   tests passed badge added to readme.
+- tests passed badge added to readme.
 
 ### Changed
 
--   readme updated to reflect changes.
+- readme updated to reflect changes.
 
 ### Fixed
 
--   link to clone repo fixed in readme.
+- link to clone repo fixed in readme.
--   unit tests migrated from nose to pytest since nose will not be supported from python 3.10 onwards.
+- unit tests migrated from nose to pytest since nose will not be supported from python 3.10 onwards.
 
 ## [0.0.1] - 2022-04-05
 
 ### Added
 
--   \_query() added to base class, allows testing a single parameter.
+- \_query() added to base class, allows testing a single parameter.
--   Interface entry point defined.
+- Interface entry point defined.
--   Kind map for XR18/MR18 added
+- Kind map for XR18/MR18 added
--   Higher level classes (lr, strip, bus, fxsend, aux, rtn) implemented
+- Higher level classes (lr, strip, bus, fxsend, aux, rtn) implemented
--   Subclass mixin implemented (shared classes)
+- Subclass mixin implemented (shared classes)
--   meta module added
+- meta module added
--   util module added, mostly functions that perform math operations.
+- util module added, mostly functions that perform math operations.
--   readme initial commit.
+- readme initial commit.
 
 ### Changed
 
--   base class now supports context manager.
+- base class now supports context manager.
--   load ip from ini
+- load ip from ini
--   unit tests initial commit. tests for shared classes added.
+- unit tests initial commit. tests for shared classes added.

README.md

@@ -1,8 +1,7 @@
 [![PyPI version](https://badge.fury.io/py/xair-api.svg)](https://badge.fury.io/py/xair-api)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://github.com/onyx-and-iris/xair-api-python/blob/dev/LICENSE)
-[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
+[![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
-[![Imports: isort](https://img.shields.io/badge/%20imports-isort-%231674b1?style=flat&labelColor=ef8336)](https://pycqa.github.io/isort/)
+![Tests Status](./tests/xair/MR18.svg?dummy=8484744)
-![Tests Status](./tests/MR18.svg?dummy=8484744)
 
 # Xair API
 
@@ -12,7 +11,7 @@ For an outline of past/future changes refer to: [CHANGELOG](CHANGELOG.md)
 
 ## Prerequisites
 
--   Python 3.10 or greater
+- Python 3.10 or greater
 
 ## Installation
 
@@ -40,6 +39,9 @@ import xair_api
 
 
 def main():
+    kind_id = "XR18"
+    ip = "<ip address>"
+
     with xair_api.connect(kind_id, ip=ip) as mixer:
         mixer.strip[8].config.name = "sm7b"
         mixer.strip[8].mix.on = True
@@ -49,21 +51,30 @@ def main():
 
 
 if __name__ == "__main__":
-    kind_id = "MR18"
-    ip = "<ip address>"
-
     main()
 ```
 
+#### `xair_api.connect(kind_id, ip=ip, delay=0.02, connect_timeout=2)`
+
+Currently the following devices are supported:
+
+- `MR18`
+- `XR18`
+- `XR16`
+- `XR12`
+
+The `X32` is partially supported. However, this document covers specifically the `XAir` series.
+
+The following keyword arguments may be passed:
+
+- `ip`: ip address of the mixer
+- `port`: mixer port, defaults to 10023 for x32 and 10024 for xair
+- `delay`: a delay between each command (applies to the getters). Defaults to 20ms.
+  - a note about delay, stability may rely on network connection. For wired connections the delay can be safely reduced.
+- `connect_timeout`: amount of time to wait for a validated connection. Defaults to 2s.
+
 ## API
 
-Currently the following devices are support:
-
--   `XR18`
--   `MR18`
--   `XR16`
--   `XR12`
-
 ### XAirRemote class (higher level)
 
 `mixer.lr`
@@ -82,6 +93,10 @@ A Bus tuple containing a class for each output bus channel
 
 A DCA tuple containing a class for each DCA group
 
+`mixer.fx`
+
+An FX tuple containing a class for each FX channel
+
 `mixer.fxsend`
 
 An FXSend tuple containing a class for each FX Send channel
@@ -90,18 +105,18 @@ An FXSend tuple containing a class for each FX Send channel
 
 An FXReturn tuple containing a class for each FX Return channel
 
-`mixer.aux`
+`mixer.auxreturn`
 
-A class representing aux channel
+A class representing auxreturn channel
-
-`mixer.rtn`
-
-An RTN tuple containing a class for each rtn channel
 
 `mixer.config`
 
 A class representing the main config settings
 
+`mixer.headamp`
+
+A class representing the channel preamps (phantom power/gain).
+
 ### `LR`
 
 Contains the subclasses:
@@ -110,7 +125,7 @@ Contains the subclasses:
 ### `Strip`
 
 Contains the subclasses:
-(`Config`, `Preamp`, `Gate`, `Dyn`, `Insert`, `GEQ`, `EQ`, `Mix`, `Group`, `Automix`)
+(`Config`, `Preamp`, `Gate`, `Dyn`, `Insert`, `GEQ`, `EQ`, `Mix`, `Group`, `Automix`, `Send`)
 
 ### `Bus`
 
@@ -122,15 +137,22 @@ Contains the subclasses:
 Contains the subclasses:
 (`Config`, `Mix`, `Group`)
 
-### `Aux`
+### `FXRtn`
 
 Contains the subclasses:
-(`Config`, `Preamp`, `EQ`, `Mix`, `Group`)
+(`Config`, `Preamp`, `EQ`, `Mix`, `Group`, `Send`)
 
-### `Rtn`
+### `AuxRtn`
 
 Contains the subclasses:
-(`Config`, `Preamp`, `EQ`, `Mix`, `Group`)
+(`Config`, `Preamp`, `EQ`, `Mix`, `Group`, `Send`)
+
+### `HeadAmp`
+
+The following properties are available:
+
+- `gain`: float, from -12.0 to 60.0
+- `phantom`: bool
 
 ### `Subclasses`
 
@@ -138,132 +160,134 @@ For each subclass the corresponding properties are available.
 
 `Config`
 
--   `name`: string
+- `name`: string
--   `color`: int, from 0, 16
+- `color`: int, from 0, 16
--   `inputsource`: int
+- `inputsource`: int
--   `usbreturn`: int
+- `usbreturn`: int
 
 `Preamp`
 
--   `on`: bool
+- `on`: bool
--   `usbtrim`: float, from -18.0 to 18.0
+- `usbtrim`: float, from -18.0 to 18.0
--   `usbinput`: bool
+- `usbinput`: bool
--   `invert`: bool
+- `invert`: bool
--   `highpasson`: bool
+- `highpasson`: bool
--   `highpassfilter`: int, from 20 to 400
+- `highpassfilter`: int, from 20 to 400
 
 `Gate`
 
--   `on`: bool
+- `on`: bool
--   `mode`: str, one of ('gate', 'exp2', 'exp3', 'exp4', 'duck')
+- `mode`: str, one of ('gate', 'exp2', 'exp3', 'exp4', 'duck')
--   `threshold`: float, from -80.0 to 0.0
+- `threshold`: float, from -80.0 to 0.0
--   `range`: int, from 3 to 60
+- `range`: int, from 3 to 60
--   `attack`: int, from 0 to 120
+- `attack`: int, from 0 to 120
--   `hold`: float, from 0.02 to 2000
+- `hold`: float, from 0.02 to 2000
--   `release`: int, from 5 to 4000
+- `release`: int, from 5 to 4000
--   `keysource`, from 0 to 22
+- `keysource`, from 0 to 22
--   `filteron`: bool
+- `filteron`: bool
--   `filtertype`: int, from 0 to 8
+- `filtertype`: int, from 0 to 8
--   `filterfreq`: float, from 20 to 20000
+- `filterfreq`: float, from 20 to 20000
 
 `Dyn`
 
--   `on`: bool
+- `on`: bool
--   `mode`: str, one of ('comp', 'exp')
+- `mode`: str, one of ('comp', 'exp')
--   `det`: str, one of ('peak', 'rms')
+- `det`: str, one of ('peak', 'rms')
--   `env`: str, one of ('lin', 'log')
+- `env`: str, one of ('lin', 'log')
--   `threshold`: float, from -60.0 to 0.0
+- `threshold`: float, from -60.0 to 0.0
--   `ratio`: int, from 0 to 11
+- `ratio`: int, from 0 to 11
--   `knee`: int, from 0 to 5
+- `knee`: int, from 0 to 5
--   `mgain`: float, from 0.0 to 24.0
+- `mgain`: float, from 0.0 to 24.0
--   `attack`: int, from 0 to 120
+- `attack`: int, from 0 to 120
--   `hold`: float, from 0.02 to 2000
+- `hold`: float, from 0.02 to 2000
--   `release`: int, from 5 to 4000
+- `release`: int, from 5 to 4000
--   `mix`: int, from 0 to 100
+- `mix`: int, from 0 to 100
--   `keysource`: int, from 0 to 22
+- `keysource`: int, from 0 to 22
--   `auto`: bool
+- `auto`: bool
--   `filteron`: bool
+- `filteron`: bool
--   `filtertype`: int, from 0 to 8
+- `filtertype`: int, from 0 to 8
--   `filterfreq`: float, from 20 to 20000
+- `filterfreq`: float, from 20 to 20000
 
 `Insert`
 
--   `on`: bool
+- `on`: bool
--   `sel`: int
+- `sel`: int
 
 `GEQ`
 The following method names preceded by `slider_`
 
--   `20`, `25`, `31_5`, `40`, `50`, `63`, `80`, `100`, `125`, `160`,
+- `20`, `25`, `31_5`, `40`, `50`, `63`, `80`, `100`, `125`, `160`,
--   `200`, `250`, `315`, `400`, `500`, `630`, `800`, `1k`, `1k25`, `1k6`, `2k`,
+- `200`, `250`, `315`, `400`, `500`, `630`, `800`, `1k`, `1k25`, `1k6`, `2k`,
--   `2k5`, `3k15`, `4k`, `5k`, `6k3`, `8k`, `10k`, `12k5`, `16k`, `20k`: float, from -15.0 to 15.0
+- `2k5`, `3k15`, `4k`, `5k`, `6k3`, `8k`, `10k`, `12k5`, `16k`, `20k`: float, from -15.0 to 15.0
 
 for example: `slider_20`, `slider_6k3` etc..
 
 `EQ`
 
--   `on`: bool
+- `on`: bool
--   `mode`: str, one of ('peq', 'geq', 'teq')
+- `mode`: str, one of ('peq', 'geq', 'teq')
 
 For the subclasses: `low`, `low2`, `lomid`, `himid`, `high2`, `high` the following properties are available:
 
--   `type`: int, from 0 to 5
+- `type`: int, from 0 to 5
--   `frequency`: float, from 20.0 to 20000.0
+- `frequency`: float, from 20.0 to 20000.0
--   `gain`: float, -15.0 to 15.0
+- `gain`: float, -15.0 to 15.0
--   `quality`: float, from 0.3 to 10.0
+- `quality`: float, from 0.3 to 10.0
 
 for example: `eq.low2.type`
 
 `Mix`
 
--   `on`: bool
+- `on`: bool
--   `fader`: float, -inf, to 10.0
+- `fader`: float, -inf, to 10.0
--   `lr`: bool
+- `lr`: bool
 
 `Group`
 
--   `dca`: int, from 0 to 15
+- `dca`: int, from 0 to 15
--   `mute`: int, from 0 to 15
+- `mute`: int, from 0 to 15
 
 `Automix`
 
--   `group`: int, from 0 to 2
+- `group`: int, from 0 to 2
--   `weight`: float, from -12.0 to 12.0
+- `weight`: float, from -12.0 to 12.0
 
 ### `DCA`
 
--   `on`: bool
+- `on`: bool
--   `name`: str
+- `name`: str
--   `color`: int, from 0 to 15
+- `color`: int, from 0 to 15
 
 ### `Config`
 
 The following method names preceded by `chlink`
 
--   `1_2`, `3_4`, `5_6`, `7_8`, `9_10`, `11_12`, `13_14`, `15_16`
+- `1_2`, `3_4`, `5_6`, `7_8`, `9_10`, `11_12`, `13_14`, `15_16`
 
 The following method names preceded by `buslink`
 
--   `1_2`, `3_4`, `5_6`
+- `1_2`, `3_4`, `5_6`
 
 for example: `chlink1_2`, `buslink5_6` etc..
 
--   `link_eq`: bool
+- `link_eq`: bool
--   `link_dyn`: bool
+- `link_dyn`: bool
--   `link_fader_mute`: bool
+- `link_fader_mute`: bool
--   `amixenable`: bool
+- `amixenable`: bool
--   `amixlock`: bool
+- `amixlock`: bool
 
 For the subclass `monitor` the following properties are available
 
--   `level`: float, -inf to 10.0
+- `level`: float, -inf to 10.0
--   `source`: int, from 0 to 14
+- `source`: int, from 0 to 14
--   `chmode` bool
+- `sourcetrim`: float, from -18.0 to 18.0
--   `busmode` bool
+- `chmode`: bool
--   `dim` bool
+- `busmode`: bool
--   `mono` bool
+- `dim`: bool
--   `mute` bool
+- `dimgain`: float, from -40.0 to 0.0
--   `dimfpl` bool
+- `mono`: bool
+- `mute`: bool
+- `dimfpl`: bool
 
 for example: `config.monitor.chmode`
 
@@ -271,10 +295,47 @@ for example: `config.monitor.chmode`
 
 tuple containing a class for each mute group
 
--   `on`: bool, from 0 to 3
+- `on`: bool, from 0 to 3
 
 for example: `config.mute_group[0].on = True`
 
+### `Send`
+
+- `level`: float, -inf to 10.0
+
+for example: `mixer.strip[10].send[3].level = -16.5`
+
+### XAirRemote class (lower level)
+
+Send an OSC command directly to the mixer
+
+- `send(osc command, value)`
+
+for example:
+
+```python
+mixer.send("/ch/01/mix/on", 1)
+mixer.send("/bus/2/config/name", "somename")
+```
+
+Query the value of a command:
+
+- `query(osc command)`
+
+for example:
+
+```python
+print(mixer.query("/ch/01/mix/on"))
+```
+
+### Errors
+
+- `errors.XAirRemoteError`: Base error class for XAIR Remote.
+- `errors.XAirRemoteConnectionTimeoutError`:Exception raised when a connection attempt times out.
+  - The following attributes are available:
+    - `ip`: IP of the mixer.
+    - `port`: Port of the mixer.
+
 ### `Tests`
 
 Unplug any expensive equipment before running tests.
@@ -290,6 +351,12 @@ To run all tests:
 
 This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details
 
+## Documentation
+
+[XAir OSC Commands](https://behringer.world/wiki/doku.php?id=x-air_osc)
+
+[X32 OSC Commands](https://wiki.munichmakerlab.de/images/1/17/UNOFFICIAL_X32_OSC_REMOTE_PROTOCOL_%281%29.pdf)
+
 ## Special Thanks
 
 [Peter Dikant](https://github.com/peterdikant) for writing the base class

__main__.py

@@ -2,6 +2,9 @@ import xair_api
 
 
 def main():
+    kind_id = "XR18"
+    ip = "<ip address>"
+
     with xair_api.connect(kind_id, ip=ip) as mixer:
         mixer.strip[8].config.name = "sm7b"
         mixer.strip[8].config.on = True
@@ -11,7 +14,4 @@ def main():
 
 
 if __name__ == "__main__":
-    kind_id = "MR18"
-    ip = "<ip address>"
-
     main()

examples/headamp/__main__.py

@@ -0,0 +1,20 @@
+# Warning this script enables the phantom power for strip 09
+
+import logging
+
+import xair_api
+
+logging.basicConfig(level=logging.DEBUG)
+
+
+def main():
+    with xair_api.connect("XR18", ip="mixer.local") as mixer:
+        mixer.headamp[8].phantom = True
+        for i in range(-12, -6):
+            mixer.headamp[8].gain = i
+            print(mixer.headamp[8].gain)
+            input("Press Enter to continue...")
+
+
+if __name__ == "__main__":
+    main()

examples/sends/__main__.py

@@ -0,0 +1,24 @@
+import logging
+
+import xair_api
+
+logging.basicConfig(level=logging.DEBUG)
+
+
+def main():
+    with xair_api.connect("XR18", ip="mixer.local") as mixer:
+        for send in mixer.strip[0].send:
+            send.level = -22.8
+
+        mixer.strip[15].send[0].level = -16.5
+        print(mixer.strip[15].send[0].level)
+
+        mixer.auxreturn.send[0].level = -15.5
+        print(mixer.auxreturn.send[0].level)
+
+        mixer.fxreturn[0].send[0].level = -14.5
+        print(mixer.fxreturn[0].send[0].level)
+
+
+if __name__ == "__main__":
+    main()

examples/xair_obs/__main__.py

@@ -1,12 +1,19 @@
 import obsws_python as obs
+
 import xair_api
 
 
 class Observer:
     def __init__(self, mixer):
         self._mixer = mixer
-        self._cl = obs.EventClient()
+        self._client = obs.EventClient()
-        self._cl.callback.register(self.on_current_program_scene_changed)
+        self._client.callback.register(self.on_current_program_scene_changed)
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_value, exc_traceback):
+        self._client.disconnect()
 
     def on_current_program_scene_changed(self, data):
         scene = data.scene_name
@@ -28,11 +35,9 @@ class Observer:
 
 def main():
     with xair_api.connect("MR18", ip="mixer.local") as mixer:
-        Observer(mixer)
+        with Observer(mixer):
-
+            while _ := input("Press <Enter> to exit\n"):
-        while cmd := input("<Enter> to exit\n"):
+                pass
-            if not cmd:
-                break
 
 
 if __name__ == "__main__":

poetry.lock

@@ -1,176 +1,194 @@
-[[package]]
+# This file is automatically @generated by Poetry 1.8.5 and should not be changed by hand.
-name = "attrs"
-version = "22.1.0"
-description = "Classes Without Boilerplate"
-category = "dev"
-optional = false
-python-versions = ">=3.5"
-
-[package.extras]
-dev = ["coverage[toml] (>=5.0.2)", "hypothesis", "pympler", "pytest (>=4.3.0)", "mypy (>=0.900,!=0.940)", "pytest-mypy-plugins", "zope.interface", "furo", "sphinx", "sphinx-notfound-page", "pre-commit", "cloudpickle"]
-docs = ["furo", "sphinx", "zope.interface", "sphinx-notfound-page"]
-tests = ["coverage[toml] (>=5.0.2)", "hypothesis", "pympler", "pytest (>=4.3.0)", "mypy (>=0.900,!=0.940)", "pytest-mypy-plugins", "zope.interface", "cloudpickle"]
-tests_no_zope = ["coverage[toml] (>=5.0.2)", "hypothesis", "pympler", "pytest (>=4.3.0)", "mypy (>=0.900,!=0.940)", "pytest-mypy-plugins", "cloudpickle"]
 
 [[package]]
-name = "black"
+name = "cachetools"
-version = "22.8.0"
+version = "5.5.0"
-description = "The uncompromising code formatter."
+description = "Extensible memoizing collections and decorators"
-category = "dev"
-optional = false
-python-versions = ">=3.6.2"
-
-[package.dependencies]
-click = ">=8.0.0"
-mypy-extensions = ">=0.4.3"
-pathspec = ">=0.9.0"
-platformdirs = ">=2"
-tomli = {version = ">=1.1.0", markers = "python_full_version < \"3.11.0a7\""}
-
-[package.extras]
-colorama = ["colorama (>=0.4.3)"]
-d = ["aiohttp (>=3.7.4)"]
-jupyter = ["ipython (>=7.8.0)", "tokenize-rt (>=3.2.0)"]
-uvloop = ["uvloop (>=0.15.2)"]
-
-[[package]]
-name = "click"
-version = "8.1.3"
-description = "Composable command line interface toolkit"
-category = "dev"
 optional = false
 python-versions = ">=3.7"
+files = [
+    {file = "cachetools-5.5.0-py3-none-any.whl", hash = "sha256:02134e8439cdc2ffb62023ce1debca2944c3f289d66bb17ead3ab3dede74b292"},
+    {file = "cachetools-5.5.0.tar.gz", hash = "sha256:2cc24fb4cbe39633fb7badd9db9ca6295d766d9c2995f245725a46715d050f2a"},
+]
 
-[package.dependencies]
+[[package]]
-colorama = {version = "*", markers = "platform_system == \"Windows\""}
+name = "chardet"
+version = "5.2.0"
+description = "Universal encoding detector for Python 3"
+optional = false
+python-versions = ">=3.7"
+files = [
+    {file = "chardet-5.2.0-py3-none-any.whl", hash = "sha256:e1cf59446890a00105fe7b7912492ea04b6e6f06d4b742b2c788469e34c82970"},
+    {file = "chardet-5.2.0.tar.gz", hash = "sha256:1b3b6ff479a8c414bc3fa2c0852995695c4a026dcd6d0633b2dd092ca39c1cf7"},
+]
 
 [[package]]
 name = "colorama"
-version = "0.4.5"
+version = "0.4.6"
 description = "Cross-platform colored terminal text."
-category = "dev"
 optional = false
-python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*"
+python-versions = "!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,!=3.6.*,>=2.7"
+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 = "distlib"
+version = "0.3.9"
+description = "Distribution utilities"
+optional = false
+python-versions = "*"
+files = [
+    {file = "distlib-0.3.9-py2.py3-none-any.whl", hash = "sha256:47f8c22fd27c27e25a65601af709b38e4f0a45ea4fc2e710f65755fa8caaaf87"},
+    {file = "distlib-0.3.9.tar.gz", hash = "sha256:a60f20dea646b8a33f3e7772f74dc0b2d0772d2837ee1342a00645c81edf9403"},
+]
+
+[[package]]
+name = "exceptiongroup"
+version = "1.2.0"
+description = "Backport of PEP 654 (exception groups)"
+optional = false
+python-versions = ">=3.7"
+files = [
+    {file = "exceptiongroup-1.2.0-py3-none-any.whl", hash = "sha256:4bfd3996ac73b41e9b9628b04e079f193850720ea5945fc96a08633c66912f14"},
+    {file = "exceptiongroup-1.2.0.tar.gz", hash = "sha256:91f5c769735f051a4290d52edd0858999b57e5876e9f85937691bd4c9fa3ed68"},
+]
+
+[package.extras]
+test = ["pytest (>=6)"]
+
+[[package]]
+name = "filelock"
+version = "3.16.1"
+description = "A platform independent file lock."
+optional = false
+python-versions = ">=3.8"
+files = [
+    {file = "filelock-3.16.1-py3-none-any.whl", hash = "sha256:2082e5703d51fbf98ea75855d9d5527e33d8ff23099bec374a134febee6946b0"},
+    {file = "filelock-3.16.1.tar.gz", hash = "sha256:c249fbfcd5db47e5e2d6d62198e565475ee65e4831e2561c8e313fa7eb961435"},
+]
+
+[package.extras]
+docs = ["furo (>=2024.8.6)", "sphinx (>=8.0.2)", "sphinx-autodoc-typehints (>=2.4.1)"]
+testing = ["covdefaults (>=2.3)", "coverage (>=7.6.1)", "diff-cover (>=9.2)", "pytest (>=8.3.3)", "pytest-asyncio (>=0.24)", "pytest-cov (>=5)", "pytest-mock (>=3.14)", "pytest-timeout (>=2.3.1)", "virtualenv (>=20.26.4)"]
+typing = ["typing-extensions (>=4.12.2)"]
 
 [[package]]
 name = "iniconfig"
 version = "1.1.1"
 description = "iniconfig: brain-dead simple config-ini parsing"
-category = "dev"
-optional = false
-python-versions = "*"
-
-[[package]]
-name = "isort"
-version = "5.10.1"
-description = "A Python utility / library to sort Python imports."
-category = "dev"
-optional = false
-python-versions = ">=3.6.1,<4.0"
-
-[package.extras]
-pipfile_deprecated_finder = ["pipreqs", "requirementslib"]
-requirements_deprecated_finder = ["pipreqs", "pip-api"]
-colors = ["colorama (>=0.4.3,<0.5.0)"]
-plugins = ["setuptools"]
-
-[[package]]
-name = "mypy-extensions"
-version = "0.4.3"
-description = "Experimental type system extensions for programs checked with the mypy typechecker."
-category = "dev"
 optional = false
 python-versions = "*"
+files = [
+    {file = "iniconfig-1.1.1-py2.py3-none-any.whl", hash = "sha256:011e24c64b7f47f6ebd835bb12a743f2fbe9a26d4cecaa7f53bc4f35ee9da8b3"},
+    {file = "iniconfig-1.1.1.tar.gz", hash = "sha256:bc3af051d7d14b2ee5ef9969666def0cd1a000e121eaea580d4a313df4b37f32"},
+]
 
 [[package]]
 name = "packaging"
-version = "21.3"
+version = "24.2"
 description = "Core utilities for Python packages"
-category = "dev"
 optional = false
-python-versions = ">=3.6"
+python-versions = ">=3.8"
-
+files = [
-[package.dependencies]
+    {file = "packaging-24.2-py3-none-any.whl", hash = "sha256:09abb1bccd265c01f4a3aa3f7a7db064b36514d2cba19a2f694fe6150451a759"},
-pyparsing = ">=2.0.2,<3.0.5 || >3.0.5"
+    {file = "packaging-24.2.tar.gz", hash = "sha256:c228a6dc5e932d346bc5739379109d49e8853dd8223571c7c5b55260edc0b97f"},
-
+]
-[[package]]
-name = "pathspec"
-version = "0.10.1"
-description = "Utility library for gitignore style pattern matching of file paths."
-category = "dev"
-optional = false
-python-versions = ">=3.7"
 
 [[package]]
 name = "platformdirs"
-version = "2.5.2"
+version = "4.3.6"
-description = "A small Python module for determining appropriate platform-specific dirs, e.g. a \"user data dir\"."
+description = "A small Python package for determining appropriate platform-specific dirs, e.g. a `user data dir`."
-category = "dev"
 optional = false
-python-versions = ">=3.7"
+python-versions = ">=3.8"
+files = [
+    {file = "platformdirs-4.3.6-py3-none-any.whl", hash = "sha256:73e575e1408ab8103900836b97580d5307456908a03e92031bab39e4554cc3fb"},
+    {file = "platformdirs-4.3.6.tar.gz", hash = "sha256:357fb2acbc885b0419afd3ce3ed34564c13c9b95c89360cd9563f73aa5e2b907"},
+]
 
 [package.extras]
-docs = ["furo (>=2021.7.5b38)", "proselint (>=0.10.2)", "sphinx-autodoc-typehints (>=1.12)", "sphinx (>=4)"]
+docs = ["furo (>=2024.8.6)", "proselint (>=0.14)", "sphinx (>=8.0.2)", "sphinx-autodoc-typehints (>=2.4)"]
-test = ["appdirs (==1.4.4)", "pytest-cov (>=2.7)", "pytest-mock (>=3.6)", "pytest (>=6)"]
+test = ["appdirs (==1.4.4)", "covdefaults (>=2.3)", "pytest (>=8.3.2)", "pytest-cov (>=5)", "pytest-mock (>=3.14)"]
+type = ["mypy (>=1.11.2)"]
 
 [[package]]
 name = "pluggy"
-version = "1.0.0"
+version = "1.5.0"
 description = "plugin and hook calling mechanisms for python"
-category = "dev"
 optional = false
-python-versions = ">=3.6"
+python-versions = ">=3.8"
+files = [
+    {file = "pluggy-1.5.0-py3-none-any.whl", hash = "sha256:44e1ad92c8ca002de6377e165f3e0f1be63266ab4d554740532335b9d75ea669"},
+    {file = "pluggy-1.5.0.tar.gz", hash = "sha256:2cffa88e94fdc978c4c574f15f9e59b7f4201d439195c3715ca9e2486f1d0cf1"},
+]
 
 [package.extras]
 dev = ["pre-commit", "tox"]
 testing = ["pytest", "pytest-benchmark"]
 
 [[package]]
-name = "py"
+name = "pyenv-inspect"
-version = "1.11.0"
+version = "0.4.0"
-description = "library with cross-python path, ini-parsing, io, code, log facilities"
+description = "An auxiliary library for the virtualenv-pyenv and tox-pyenv-redux plugins"
-category = "dev"
 optional = false
-python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*"
+python-versions = ">=3.8"
+files = [
+    {file = "pyenv-inspect-0.4.0.tar.gz", hash = "sha256:ec429d1d81b67ab0b08a0408414722a79d24fd1845a5b264267e44e19d8d60f0"},
+    {file = "pyenv_inspect-0.4.0-py3-none-any.whl", hash = "sha256:618683ae7d3e6db14778d58aa0fc6b3170180d944669b5d35a8aa4fb7db550d2"},
+]
 
 [[package]]
-name = "pyparsing"
+name = "pyproject-api"
-version = "3.0.9"
+version = "1.8.0"
-description = "pyparsing module - Classes and methods to define and execute parsing grammars"
+description = "API to interact with the python pyproject.toml based projects"
-category = "dev"
 optional = false
-python-versions = ">=3.6.8"
+python-versions = ">=3.8"
+files = [
+    {file = "pyproject_api-1.8.0-py3-none-any.whl", hash = "sha256:3d7d347a047afe796fd5d1885b1e391ba29be7169bd2f102fcd378f04273d228"},
+    {file = "pyproject_api-1.8.0.tar.gz", hash = "sha256:77b8049f2feb5d33eefcc21b57f1e279636277a8ac8ad6b5871037b243778496"},
+]
+
+[package.dependencies]
+packaging = ">=24.1"
+tomli = {version = ">=2.0.1", markers = "python_version < \"3.11\""}
 
 [package.extras]
-diagrams = ["railroad-diagrams", "jinja2"]
+docs = ["furo (>=2024.8.6)", "sphinx-autodoc-typehints (>=2.4.1)"]
+testing = ["covdefaults (>=2.3)", "pytest (>=8.3.3)", "pytest-cov (>=5)", "pytest-mock (>=3.14)", "setuptools (>=75.1)"]
 
 [[package]]
 name = "pytest"
-version = "7.1.3"
+version = "7.4.4"
 description = "pytest: simple powerful testing with Python"
-category = "dev"
 optional = false
 python-versions = ">=3.7"
+files = [
+    {file = "pytest-7.4.4-py3-none-any.whl", hash = "sha256:b090cdf5ed60bf4c45261be03239c2c1c22df034fbffe691abe93cd80cea01d8"},
+    {file = "pytest-7.4.4.tar.gz", hash = "sha256:2cf0005922c6ace4a3e2ec8b4080eb0d9753fdc93107415332f50ce9e7994280"},
+]
 
 [package.dependencies]
-attrs = ">=19.2.0"
 colorama = {version = "*", markers = "sys_platform == \"win32\""}
+exceptiongroup = {version = ">=1.0.0rc8", markers = "python_version < \"3.11\""}
 iniconfig = "*"
 packaging = "*"
 pluggy = ">=0.12,<2.0"
-py = ">=1.8.2"
+tomli = {version = ">=1.0.0", markers = "python_version < \"3.11\""}
-tomli = ">=1.0.0"
 
 [package.extras]
-testing = ["argcomplete", "hypothesis (>=3.56)", "mock", "nose", "pygments (>=2.7.2)", "requests", "xmlschema"]
+testing = ["argcomplete", "attrs (>=19.2.0)", "hypothesis (>=3.56)", "mock", "nose", "pygments (>=2.7.2)", "requests", "setuptools", "xmlschema"]
 
 [[package]]
 name = "pytest-randomly"
 version = "3.12.0"
 description = "Pytest plugin to randomly order tests and control random.seed."
-category = "dev"
 optional = false
 python-versions = ">=3.7"
+files = [
+    {file = "pytest-randomly-3.12.0.tar.gz", hash = "sha256:d60c2db71ac319aee0fc6c4110a7597d611a8b94a5590918bfa8583f00caccb2"},
+    {file = "pytest_randomly-3.12.0-py3-none-any.whl", hash = "sha256:f4f2e803daf5d1ba036cc22bf4fe9dbbf99389ec56b00e5cba732fb5c1d07fdd"},
+]
 
 [package.dependencies]
 pytest = "*"
@@ -179,74 +197,125 @@ pytest = "*"
 name = "python-osc"
 version = "1.8.0"
 description = "Open Sound Control server and client implementations in pure Python"
-category = "main"
 optional = false
 python-versions = "*"
+files = [
+    {file = "python-osc-1.8.0.tar.gz", hash = "sha256:2f8c187c68d239960fb2eddcb5346a62a9b35e64f2de045b3e5e509f475ca73d"},
+    {file = "python_osc-1.8.0-py3-none-any.whl", hash = "sha256:9e2abb2fc9ba2c356f8e951609a03c9c7017bf0bad82cca8490e9b8af9e92a0b"},
+]
+
+[[package]]
+name = "ruff"
+version = "0.8.6"
+description = "An extremely fast Python linter and code formatter, written in Rust."
+optional = false
+python-versions = ">=3.7"
+files = [
+    {file = "ruff-0.8.6-py3-none-linux_armv6l.whl", hash = "sha256:defed167955d42c68b407e8f2e6f56ba52520e790aba4ca707a9c88619e580e3"},
+    {file = "ruff-0.8.6-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:54799ca3d67ae5e0b7a7ac234baa657a9c1784b48ec954a094da7c206e0365b1"},
+    {file = "ruff-0.8.6-py3-none-macosx_11_0_arm64.whl", hash = "sha256:e88b8f6d901477c41559ba540beeb5a671e14cd29ebd5683903572f4b40a9807"},
+    {file = "ruff-0.8.6-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0509e8da430228236a18a677fcdb0c1f102dd26d5520f71f79b094963322ed25"},
+    {file = "ruff-0.8.6-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:91a7ddb221779871cf226100e677b5ea38c2d54e9e2c8ed847450ebbdf99b32d"},
+    {file = "ruff-0.8.6-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:248b1fb3f739d01d528cc50b35ee9c4812aa58cc5935998e776bf8ed5b251e75"},
+    {file = "ruff-0.8.6-py3-none-manylinux_2_17_ppc64.manylinux2014_ppc64.whl", hash = "sha256:bc3c083c50390cf69e7e1b5a5a7303898966be973664ec0c4a4acea82c1d4315"},
+    {file = "ruff-0.8.6-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:52d587092ab8df308635762386f45f4638badb0866355b2b86760f6d3c076188"},
+    {file = "ruff-0.8.6-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:61323159cf21bc3897674e5adb27cd9e7700bab6b84de40d7be28c3d46dc67cf"},
+    {file = "ruff-0.8.6-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7ae4478b1471fc0c44ed52a6fb787e641a2ac58b1c1f91763bafbc2faddc5117"},
+    {file = "ruff-0.8.6-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:0c000a471d519b3e6cfc9c6680025d923b4ca140ce3e4612d1a2ef58e11f11fe"},
+    {file = "ruff-0.8.6-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:9257aa841e9e8d9b727423086f0fa9a86b6b420fbf4bf9e1465d1250ce8e4d8d"},
+    {file = "ruff-0.8.6-py3-none-musllinux_1_2_i686.whl", hash = "sha256:45a56f61b24682f6f6709636949ae8cc82ae229d8d773b4c76c09ec83964a95a"},
+    {file = "ruff-0.8.6-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:496dd38a53aa173481a7d8866bcd6451bd934d06976a2505028a50583e001b76"},
+    {file = "ruff-0.8.6-py3-none-win32.whl", hash = "sha256:e169ea1b9eae61c99b257dc83b9ee6c76f89042752cb2d83486a7d6e48e8f764"},
+    {file = "ruff-0.8.6-py3-none-win_amd64.whl", hash = "sha256:f1d70bef3d16fdc897ee290d7d20da3cbe4e26349f62e8a0274e7a3f4ce7a905"},
+    {file = "ruff-0.8.6-py3-none-win_arm64.whl", hash = "sha256:7d7fc2377a04b6e04ffe588caad613d0c460eb2ecba4c0ccbbfe2bc973cbc162"},
+    {file = "ruff-0.8.6.tar.gz", hash = "sha256:dcad24b81b62650b0eb8814f576fc65cfee8674772a6e24c9b747911801eeaa5"},
+]
 
 [[package]]
 name = "tomli"
 version = "2.0.1"
 description = "A lil' TOML parser"
-category = "main"
 optional = false
 python-versions = ">=3.7"
-
+files = [
-[metadata]
-lock-version = "1.1"
-python-versions = "^3.10"
-content-hash = "80440f75f4191b46dc73824fbfc4fd2fc1ea4dfbdba08591cabb600a86ae2400"
-
-[metadata.files]
-attrs = []
-black = []
-click = [
-    {file = "click-8.1.3-py3-none-any.whl", hash = "sha256:bb4d8133cb15a609f44e8213d9b391b0809795062913b383c62be0ee95b1db48"},
-    {file = "click-8.1.3.tar.gz", hash = "sha256:7682dc8afb30297001674575ea00d1814d808d6a36af415a82bd481d37ba7b8e"},
-]
-colorama = [
-    {file = "colorama-0.4.5-py2.py3-none-any.whl", hash = "sha256:854bf444933e37f5824ae7bfc1e98d5bce2ebe4160d46b5edf346a89358e99da"},
-    {file = "colorama-0.4.5.tar.gz", hash = "sha256:e6c6b4334fc50988a639d9b98aa429a0b57da6e17b9a44f0451f930b6967b7a4"},
-]
-iniconfig = [
-    {file = "iniconfig-1.1.1-py2.py3-none-any.whl", hash = "sha256:011e24c64b7f47f6ebd835bb12a743f2fbe9a26d4cecaa7f53bc4f35ee9da8b3"},
-    {file = "iniconfig-1.1.1.tar.gz", hash = "sha256:bc3af051d7d14b2ee5ef9969666def0cd1a000e121eaea580d4a313df4b37f32"},
-]
-isort = [
-    {file = "isort-5.10.1-py3-none-any.whl", hash = "sha256:6f62d78e2f89b4500b080fe3a81690850cd254227f27f75c3a0c491a1f351ba7"},
-    {file = "isort-5.10.1.tar.gz", hash = "sha256:e8443a5e7a020e9d7f97f1d7d9cd17c88bcb3bc7e218bf9cf5095fe550be2951"},
-]
-mypy-extensions = [
-    {file = "mypy_extensions-0.4.3-py2.py3-none-any.whl", hash = "sha256:090fedd75945a69ae91ce1303b5824f428daf5a028d2f6ab8a299250a846f15d"},
-    {file = "mypy_extensions-0.4.3.tar.gz", hash = "sha256:2d82818f5bb3e369420cb3c4060a7970edba416647068eb4c5343488a6c604a8"},
-]
-packaging = [
-    {file = "packaging-21.3-py3-none-any.whl", hash = "sha256:ef103e05f519cdc783ae24ea4e2e0f508a9c99b2d4969652eed6a2e1ea5bd522"},
-    {file = "packaging-21.3.tar.gz", hash = "sha256:dd47c42927d89ab911e606518907cc2d3a1f38bbd026385970643f9c5b8ecfeb"},
-]
-pathspec = []
-platformdirs = [
-    {file = "platformdirs-2.5.2-py3-none-any.whl", hash = "sha256:027d8e83a2d7de06bbac4e5ef7e023c02b863d7ea5d079477e722bb41ab25788"},
-    {file = "platformdirs-2.5.2.tar.gz", hash = "sha256:58c8abb07dcb441e6ee4b11d8df0ac856038f944ab98b7be6b27b2a3c7feef19"},
-]
-pluggy = [
-    {file = "pluggy-1.0.0-py2.py3-none-any.whl", hash = "sha256:74134bbf457f031a36d68416e1509f34bd5ccc019f0bcc952c7b909d06b37bd3"},
-    {file = "pluggy-1.0.0.tar.gz", hash = "sha256:4224373bacce55f955a878bf9cfa763c1e360858e330072059e10bad68531159"},
-]
-py = [
-    {file = "py-1.11.0-py2.py3-none-any.whl", hash = "sha256:607c53218732647dff4acdfcd50cb62615cedf612e72d1724fb1a0cc6405b378"},
-    {file = "py-1.11.0.tar.gz", hash = "sha256:51c75c4126074b472f746a24399ad32f6053d1b34b68d2fa41e558e6f4a98719"},
-]
-pyparsing = [
-    {file = "pyparsing-3.0.9-py3-none-any.whl", hash = "sha256:5026bae9a10eeaefb61dab2f09052b9f4307d44aee4eda64b309723d8d206bbc"},
-    {file = "pyparsing-3.0.9.tar.gz", hash = "sha256:2b020ecf7d21b687f219b71ecad3631f644a47f01403fa1d1036b0c6416d70fb"},
-]
-pytest = []
-pytest-randomly = [
-    {file = "pytest-randomly-3.12.0.tar.gz", hash = "sha256:d60c2db71ac319aee0fc6c4110a7597d611a8b94a5590918bfa8583f00caccb2"},
-    {file = "pytest_randomly-3.12.0-py3-none-any.whl", hash = "sha256:f4f2e803daf5d1ba036cc22bf4fe9dbbf99389ec56b00e5cba732fb5c1d07fdd"},
-]
-python-osc = []
-tomli = [
     {file = "tomli-2.0.1-py3-none-any.whl", hash = "sha256:939de3e7a6161af0c887ef91b7d41a53e7c5a1ca976325f429cb46ea9bc30ecc"},
     {file = "tomli-2.0.1.tar.gz", hash = "sha256:de526c12914f0c550d15924c62d72abc48d6fe7364aa87328337a31007fe8a4f"},
 ]
+
+[[package]]
+name = "tox"
+version = "4.23.2"
+description = "tox is a generic virtualenv management and test command line tool"
+optional = false
+python-versions = ">=3.8"
+files = [
+    {file = "tox-4.23.2-py3-none-any.whl", hash = "sha256:452bc32bb031f2282881a2118923176445bac783ab97c874b8770ab4c3b76c38"},
+    {file = "tox-4.23.2.tar.gz", hash = "sha256:86075e00e555df6e82e74cfc333917f91ecb47ffbc868dcafbd2672e332f4a2c"},
+]
+
+[package.dependencies]
+cachetools = ">=5.5"
+chardet = ">=5.2"
+colorama = ">=0.4.6"
+filelock = ">=3.16.1"
+packaging = ">=24.1"
+platformdirs = ">=4.3.6"
+pluggy = ">=1.5"
+pyproject-api = ">=1.8"
+tomli = {version = ">=2.0.1", markers = "python_version < \"3.11\""}
+typing-extensions = {version = ">=4.12.2", markers = "python_version < \"3.11\""}
+virtualenv = ">=20.26.6"
+
+[package.extras]
+test = ["devpi-process (>=1.0.2)", "pytest (>=8.3.3)", "pytest-mock (>=3.14)"]
+
+[[package]]
+name = "typing-extensions"
+version = "4.12.2"
+description = "Backported and Experimental Type Hints for Python 3.8+"
+optional = false
+python-versions = ">=3.8"
+files = [
+    {file = "typing_extensions-4.12.2-py3-none-any.whl", hash = "sha256:04e5ca0351e0f3f85c6853954072df659d0d13fac324d0072316b67d7794700d"},
+    {file = "typing_extensions-4.12.2.tar.gz", hash = "sha256:1a7ead55c7e559dd4dee8856e3a88b41225abfe1ce8df57b7c13915fe121ffb8"},
+]
+
+[[package]]
+name = "virtualenv"
+version = "20.28.1"
+description = "Virtual Python Environment builder"
+optional = false
+python-versions = ">=3.8"
+files = [
+    {file = "virtualenv-20.28.1-py3-none-any.whl", hash = "sha256:412773c85d4dab0409b83ec36f7a6499e72eaf08c80e81e9576bca61831c71cb"},
+    {file = "virtualenv-20.28.1.tar.gz", hash = "sha256:5d34ab240fdb5d21549b76f9e8ff3af28252f5499fb6d6f031adac4e5a8c5329"},
+]
+
+[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)", "pytest-mock (>=3.11.1)", "pytest-randomly (>=3.12)", "pytest-timeout (>=2.1)", "setuptools (>=68)", "time-machine (>=2.10)"]
+
+[[package]]
+name = "virtualenv-pyenv"
+version = "0.5.0"
+description = "A virtualenv Python discovery plugin for pyenv-installed interpreters"
+optional = false
+python-versions = ">=3.8"
+files = [
+    {file = "virtualenv-pyenv-0.5.0.tar.gz", hash = "sha256:7b0e5fe3dfbdf484f4cf9b01e1f98111e398db6942237910f666356e6293597f"},
+    {file = "virtualenv_pyenv-0.5.0-py3-none-any.whl", hash = "sha256:21750247e36c55b3c547cfdeb08f51a3867fe7129922991a4f9c96980c0a4a5d"},
+]
+
+[package.dependencies]
+pyenv-inspect = ">=0.4,<0.5"
+virtualenv = "*"
+
+[metadata]
+lock-version = "2.0"
+python-versions = "^3.10"
+content-hash = "03c4b24c8bf12ad78f55f6e99a5001183bbb855bf8ef841dd3522fb79c1f7288"

pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "xair-api"
-version = "1.1.1"
+version = "2.4.0"
 description = "Remote control Behringer X-Air | Midas MR mixers through OSC"
 authors = ["onyx-and-iris <code@onyxandiris.online>"]
 license = "MIT"
@@ -12,15 +12,124 @@ python = "^3.10"
 python-osc = "^1.8.0"
 tomli = { version = "^2.0.1", python = "<3.11" }
 
-[tool.poetry.dev-dependencies]
+[tool.poetry.group.dev.dependencies]
-pytest = "^7.1.2"
+pytest = "^7.4.4"
 pytest-randomly = "^3.12.0"
-black = "^22.6.0"
+ruff = "^0.8.6"
-isort = "^5.10.1"
+tox = "^4.23.2"
+virtualenv-pyenv = "^0.5.0"
 
 [build-system]
 requires = ["poetry-core>=1.0.0"]
 build-backend = "poetry.core.masonry.api"
 
 [tool.poetry.scripts]
-obs = "examples.xair-obs.__main__:main"
+obs = "scripts:ex_obs"
+sends = "scripts:ex_sends"
+xair = "scripts:test_xair"
+x32 = "scripts:test_x32"
+all = "scripts:test_all"
+
+[tool.tox]
+legacy_tox_ini = """
+[tox]
+envlist = py310,py311,py312
+
+[testenv]
+setenv = VIRTUALENV_DISCOVERY=pyenv
+allowlist_externals = poetry
+commands =
+  poetry install -v
+  poetry run pytest tests/
+"""
+
+[tool.ruff]
+lint.select = [
+    "E",
+    "F",
+]
+lint.ignore = [
+    "E501",
+]
+lint.fixable = [
+    "A",
+    "B",
+    "C",
+    "D",
+    "E",
+    "F",
+    "G",
+    "I",
+    "N",
+    "Q",
+    "S",
+    "T",
+    "W",
+    "ANN",
+    "ARG",
+    "BLE",
+    "COM",
+    "DJ",
+    "DTZ",
+    "EM",
+    "ERA",
+    "EXE",
+    "FBT",
+    "ICN",
+    "INP",
+    "ISC",
+    "NPY",
+    "PD",
+    "PGH",
+    "PIE",
+    "PL",
+    "PT",
+    "PTH",
+    "PYI",
+    "RET",
+    "RSE",
+    "RUF",
+    "SIM",
+    "SLF",
+    "TCH",
+    "TID",
+    "TRY",
+    "UP",
+    "YTT",
+]
+lint.unfixable = []
+exclude = [
+    ".bzr",
+    ".direnv",
+    ".eggs",
+    ".git",
+    ".git-rewrite",
+    ".hg",
+    ".mypy_cache",
+    ".nox",
+    ".pants.d",
+    ".pytype",
+    ".ruff_cache",
+    ".svn",
+    ".tox",
+    ".venv",
+    "__pypackages__",
+    "_build",
+    "buck-out",
+    "build",
+    "dist",
+    "node_modules",
+    "venv",
+]
+line-length = 88
+lint.dummy-variable-rgx = "^(_+|(_+[a-zA-Z0-9_]*[a-zA-Z0-9]+?))$"
+target-version = "py312"
+
+[tool.ruff.lint.mccabe]
+max-complexity = 10
+
+[tool.ruff.lint.per-file-ignores]
+"__init__.py" = [
+    "E402",
+    "F401",
+]

scripts.py

@@ -0,0 +1,27 @@
+import subprocess
+import sys
+from pathlib import Path
+
+
+def ex_obs():
+    path = Path.cwd() / "examples" / "xair_obs" / "."
+    subprocess.run([sys.executable, str(path)])
+
+
+def ex_sends():
+    path = Path.cwd() / "examples" / "sends" / "."
+    subprocess.run([sys.executable, str(path)])
+
+
+def test_xair():
+    path = Path.cwd() / "tests" / "xair"
+    subprocess.run(["pytest", "-v", str(path)])
+
+
+def test_x32():
+    path = Path.cwd() / "tests" / "x32"
+    subprocess.run(["pytest", "-v", str(path)])
+
+
+def test_all():
+    subprocess.run(["tox"])

tests/__init__.py

@@ -1,40 +0,0 @@
-import sys
-import threading
-from dataclasses import dataclass
-
-import xair_api
-from xair_api import kinds
-
-kind_id = "MR18"
-ip = "mixer.local"
-
-tests = xair_api.connect(kind_id, ip=ip)
-
-kind = kinds.get(kind_id)
-
-
-@dataclass
-class Data:
-    """bounds data to map tests to a kind"""
-
-    name: str = kind.id_
-    dca: int = kind.num_dca - 1
-    strip: int = kind.num_strip - 1
-    bus: int = kind.num_bus - 1
-    fx: int = kind.num_fx - 1
-    rtn: int = kind.num_rtn - 1
-
-
-data = Data()
-
-
-def setup_module():
-    print(f"\nRunning tests for kind [{data.name}]\n", file=sys.stdout)
-    tests.worker = threading.Thread(target=tests.run_server)
-    tests.worker.daemon = True
-    tests.worker.start()
-    tests.validate_connection()
-
-
-def teardown_module():
-    tests.server.shutdown()

tests/x32/__init__.py

@@ -0,0 +1,41 @@
+import sys
+import threading
+from dataclasses import dataclass
+
+import xair_api
+from xair_api import kinds
+
+kind_id = "X32"
+ip = "x32.local"
+
+tests = xair_api.connect(kind_id, ip=ip)
+
+kind = kinds.get(kind_id)
+
+
+@dataclass
+class Data:
+    """bounds test data to a kind"""
+
+    name: str = kind.id_
+    dca: int = kind.num_dca - 1
+    strip: int = kind.num_strip - 1
+    bus: int = kind.num_bus - 1
+    fx: int = kind.num_fx - 1
+    auxrtn: int = kind.num_auxrtn - 1
+    matrix: int = kind.num_matrix - 1
+
+
+data = Data()
+
+
+def setup_module():
+    print(f"\nRunning tests for kind [{data.name}]\n", file=sys.stdout)
+    tests.worker = threading.Thread(target=tests.run_server)
+    tests.worker.daemon = True
+    tests.worker.start()
+    tests.validate_connection()
+
+
+def teardown_module():
+    tests.server.shutdown()

tests/x32/test_adapter.py

@@ -0,0 +1,144 @@
+import pytest
+
+from tests.x32 import data, tests
+
+""" STRIP TESTS """
+
+
+class TestSetAndGetStripMuteHigher:
+    """Mute"""
+
+    __test__ = True
+
+    def setup_class(self):
+        self.target = getattr(tests, "strip")[data.strip]
+
+    @pytest.mark.parametrize(
+        "param,value",
+        [("mute", True), ("mute", False)],
+    )
+    def test_it_sets_and_gets_strip_mute_bool_params(self, param, value):
+        setattr(self.target, param, value)
+        assert getattr(self.target, param) == value
+
+
+class TestSetAndGetStripMixHigher:
+    """Mix"""
+
+    __test__ = True
+
+    def setup_class(self):
+        self.target = getattr(tests, "strip")
+        self.target = getattr(self.target[data.strip], "mix")
+
+    @pytest.mark.parametrize(
+        "param,value",
+        [("on", True), ("on", False)],
+    )
+    def test_it_sets_and_gets_strip_bool_params(self, param, value):
+        setattr(self.target, param, value)
+        assert getattr(self.target, param) == value
+
+
+""" BUS TESTS """
+
+
+class TestSetAndGetBusConfigHigher:
+    """Config"""
+
+    __test__ = True
+
+    def setup_class(self):
+        self.target = getattr(tests, "bus")
+        self.target = getattr(self.target[data.bus], "config")
+
+    @pytest.mark.parametrize(
+        "param,value",
+        [("color", 0), ("color", 15)],
+    )
+    def test_it_sets_and_gets_bus_int_params(self, param, value):
+        setattr(self.target, param, value)
+        assert getattr(self.target, param) == value
+
+
+""" AUXIN TESTS """
+
+
+class TestSetAndGetAuxInPreampHigher:
+    """Preamp"""
+
+    __test__ = True
+
+    def setup_class(self):
+        self.target = getattr(tests, "auxin")
+        self.target = getattr(self.target[data.auxrtn], "preamp")
+
+    @pytest.mark.parametrize(
+        "param,value",
+        [("invert", True), ("invert", False)],
+    )
+    def test_it_sets_and_gets_auxrtn_bool_params(self, param, value):
+        setattr(self.target, param, value)
+        assert getattr(self.target, param) == value
+
+
+""" FX RETURN TESTS """
+
+
+class TestSetAndGetFXReturnEQHigher:
+    """EQ"""
+
+    __test__ = True
+
+    def setup_class(self):
+        self.target = getattr(tests, "fxreturn")
+        self.target = getattr(self.target[data.fx], "eq")
+
+    @pytest.mark.parametrize(
+        "param,value",
+        [("on", True), ("on", False)],
+    )
+    def test_it_sets_and_gets_fxrtn_bool_params(self, param, value):
+        setattr(self.target, param, value)
+        assert getattr(self.target, param) == value
+
+
+""" MATRIX TESTS """
+
+
+class TestSetAndGetMatrixDynHigher:
+    """Dyn"""
+
+    __test__ = True
+
+    def setup_class(self):
+        self.target = getattr(tests, "matrix")
+        self.target = getattr(self.target[data.matrix], "dyn")
+
+    @pytest.mark.parametrize(
+        "param,value",
+        [("mode", "comp"), ("mode", "exp")],
+    )
+    def test_it_sets_and_gets_matrix_string_params(self, param, value):
+        setattr(self.target, param, value)
+        assert getattr(self.target, param) == value
+
+
+""" MAIN STEREO TESTS """
+
+
+class TestSetAndGetMainStereoInsertHigher:
+    """Insert"""
+
+    __test__ = True
+
+    def setup_class(self):
+        self.target = getattr(tests, "mainst")
+
+    @pytest.mark.parametrize(
+        "param,value",
+        [("mode", "comp"), ("mode", "exp")],
+    )
+    def test_it_sets_and_gets_mainst_string_params(self, param, value):
+        setattr(self.target, param, value)
+        assert getattr(self.target, param) == value

tests/xair/MR18.svg

@@ -1 +1 @@
-<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="60" height="20" role="img" aria-label="tests: 67"><title>tests: 67</title><linearGradient id="s" x2="0" y2="100%"><stop offset="0" stop-color="#bbb" stop-opacity=".1"/><stop offset="1" stop-opacity=".1"/></linearGradient><clipPath id="r"><rect width="60" height="20" rx="3" fill="#fff"/></clipPath><g clip-path="url(#r)"><rect width="37" height="20" fill="#555"/><rect x="37" width="23" height="20" fill="#4c1"/><rect width="60" height="20" fill="url(#s)"/></g><g fill="#fff" text-anchor="middle" font-family="Verdana,Geneva,DejaVu Sans,sans-serif" text-rendering="geometricPrecision" font-size="110"><text aria-hidden="true" x="195" y="150" fill="#010101" fill-opacity=".3" transform="scale(.1)" textLength="270">tests</text><text x="195" y="140" transform="scale(.1)" fill="#fff" textLength="270">tests</text><text aria-hidden="true" x="475" y="150" fill="#010101" fill-opacity=".3" transform="scale(.1)" textLength="130">67</text><text x="475" y="140" transform="scale(.1)" fill="#fff" textLength="130">67</text></g></svg>
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="60" height="20" role="img" aria-label="tests: 77"><title>tests: 77</title><linearGradient id="s" x2="0" y2="100%"><stop offset="0" stop-color="#bbb" stop-opacity=".1"/><stop offset="1" stop-opacity=".1"/></linearGradient><clipPath id="r"><rect width="60" height="20" rx="3" fill="#fff"/></clipPath><g clip-path="url(#r)"><rect width="37" height="20" fill="#555"/><rect x="37" width="23" height="20" fill="#4c1"/><rect width="60" height="20" fill="url(#s)"/></g><g fill="#fff" text-anchor="middle" font-family="Verdana,Geneva,DejaVu Sans,sans-serif" text-rendering="geometricPrecision" font-size="110"><text aria-hidden="true" x="195" y="150" fill="#010101" fill-opacity=".3" transform="scale(.1)" textLength="270">tests</text><text x="195" y="140" transform="scale(.1)" fill="#fff" textLength="270">tests</text><text aria-hidden="true" x="475" y="150" fill="#010101" fill-opacity=".3" transform="scale(.1)" textLength="130">77</text><text x="475" y="140" transform="scale(.1)" fill="#fff" textLength="130">77</text></g></svg>

tests/xair/__init__.py

@@ -0,0 +1,39 @@
+import sys
+import threading
+from dataclasses import dataclass
+
+import xair_api
+from xair_api import kinds
+
+kind_id = "MR18"
+ip = "mixer.local"
+
+tests = xair_api.connect(kind_id, ip=ip)
+
+kind = kinds.get(kind_id)
+
+
+@dataclass
+class Data:
+    """bounds test data to a kind"""
+
+    name: str = kind.id_
+    dca: int = kind.num_dca - 1
+    strip: int = kind.num_strip - 1
+    bus: int = kind.num_bus - 1
+    fx: int = kind.num_fx - 1
+
+
+data = Data()
+
+
+def setup_module():
+    print(f"\nRunning tests for kind [{data.name}]\n", file=sys.stdout)
+    tests.worker = threading.Thread(target=tests.run_server)
+    tests.worker.daemon = True
+    tests.worker.start()
+    tests.validate_connection()
+
+
+def teardown_module():
+    tests.server.shutdown()

tests/xair/pre-commit.ps1

@@ -1,6 +1,7 @@
 Function RunTests {
-    $coverage = "./tests/pytest_coverage.log"
+    "Running tests in directory $PSScriptRoot" | Write-Host
-    $run_tests = "pytest -v --capture=tee-sys --junitxml=./tests/.coverage.xml"
+    $coverage = Join-Path $PSScriptRoot "pytest_coverage.log"
+    $run_tests = "pytest -v $PSScriptRoot --capture=tee-sys --junitxml=$(Join-Path $PSScriptRoot ".coverage.xml")"
     $match_pattern = "^=|^\s*$|^Running|^Using|^plugins|^collecting|^tests"
 
     if ( Test-Path $coverage ) { Clear-Content $coverage }
@@ -13,7 +14,7 @@ Function RunTests {
     }
     Write-Output "$(Get-TimeStamp)" | Out-File $coverage -Append
 
-    Invoke-Expression "genbadge tests -t 90 -i ./tests/.coverage.xml -o ./tests/$kind.svg"
+    Invoke-Expression "genbadge tests -t 90 -i $(Join-Path $PSScriptRoot ".coverage.xml") -o $(Join-Path $PSScriptRoot "$kind.svg")"
 }
 
 Function Get-TimeStamp {

tests/xair/test_shared.py

@@ -1,6 +1,6 @@
 import pytest
 
-from tests import data, tests
+from tests.xair import data, tests
 
 """
 Not every subclass is tested for every superclass to avoid redundancy.
@@ -106,6 +106,23 @@ class TestSetAndGetLRGEQHigher:
 """ STRIP TESTS """
 
 
+class TestSetAndGetStripMuteHigher:
+    """Mute"""
+
+    __test__ = True
+
+    def setup_class(self):
+        self.target = getattr(tests, "strip")[data.strip]
+
+    @pytest.mark.parametrize(
+        "param,value",
+        [("mute", True), ("mute", False)],
+    )
+    def test_it_sets_and_gets_strip_mute_bool_params(self, param, value):
+        setattr(self.target, param, value)
+        assert getattr(self.target, param) == value
+
+
 class TestSetAndGetStripMixHigher:
     """Mix"""
 
@@ -259,7 +276,7 @@ class TestSetAndGetStripAutomixHigher:
         "param,value",
         [("group", 0), ("group", 2)],
     )
-    def test_it_sets_and_gets_fxsend_int_params(self, param, value):
+    def test_it_sets_and_gets_strip_int_params(self, param, value):
         setattr(self.target, param, value)
         assert getattr(self.target, param) == value
 
@@ -267,7 +284,7 @@ class TestSetAndGetStripAutomixHigher:
         "param,value",
         [("weight", -10.5), ("weight", 3.5)],
     )
-    def test_it_sets_and_gets_fxsend_float_params(self, param, value):
+    def test_it_sets_and_gets_strip_float_params(self, param, value):
         setattr(self.target, param, value)
         assert getattr(self.target, param) == value
 
@@ -326,7 +343,7 @@ class TestSetAndGetBusDynHigher:
         assert getattr(self.target, param) == value
 
 
-class TestSetAndGetBusDynHigher:
+class TestSetAndGetBusEQHigher:
     """EQ"""
 
     __test__ = True
@@ -368,6 +385,6 @@ class TestSetAndGetFXSendGroupHigher:
         "param,value",
         [("dca", 0), ("dca", 12), ("mute", 3), ("mute", 8)],
     )
-    def test_it_sets_and_gets_bus_bool_params(self, param, value):
+    def test_it_sets_and_gets_fxsend_int_params(self, param, value):
         setattr(self.target, param, value)
         assert getattr(self.target, param) == value

xair_api/adapter.py

@@ -0,0 +1,47 @@
+from .bus import Bus as IBus
+from .headamp import HeadAmp as IHeadAmp
+from .lr import LR as ILR
+from .rtn import AuxRtn as IAuxRtn
+from .rtn import FxRtn as IFxRtn
+
+
+class Bus(IBus):
+    @property
+    def address(self):
+        return f"/bus/{str(self.index).zfill(2)}"
+
+
+class AuxRtn(IAuxRtn):
+    @property
+    def address(self):
+        return f"/auxin/{str(self.index).zfill(2)}"
+
+
+class FxRtn(IFxRtn):
+    @property
+    def address(self):
+        return f"/fxrtn/{str(self.index).zfill(2)}"
+
+
+class MainStereo(ILR):
+    @property
+    def address(self) -> str:
+        return "/main/st"
+
+
+class MainMono(ILR):
+    @property
+    def address(self) -> str:
+        return "/main/m"
+
+
+class Matrix(ILR):
+    @property
+    def address(self) -> str:
+        return f"/mtx/{str(self.index).zfill(2)}"
+
+
+class HeadAmp(IHeadAmp):
+    @property
+    def address(self):
+        return f"/headamp/{str(self.index).zfill(3)}"

xair_api/bus.py

@@ -1,7 +1,10 @@
 import abc
+import logging
 
-from .errors import XAirRemoteError
+from .meta import mute_prop
-from .shared import EQ, GEQ, Automix, Config, Dyn, Gate, Group, Insert, Mix, Preamp
+from .shared import EQ, GEQ, Config, Dyn, Group, Insert, Mix
+
+logger = logging.getLogger(__name__)
 
 
 class IBus(abc.ABC):
@@ -10,10 +13,10 @@ class IBus(abc.ABC):
     def __init__(self, remote, index: int):
         self._remote = remote
         self.index = index + 1
+        self.logger = logger.getChild(self.__class__.__name__)
 
     def getter(self, param: str):
-        self._remote.send(f"{self.address}/{param}")
+        return self._remote.query(f"{self.address}/{param}")
-        return self._remote.info_response
 
     def setter(self, param: str, val: int):
         self._remote.send(f"{self.address}/{param}", val)
@@ -52,7 +55,8 @@ class Bus(IBus):
                         Mix,
                         Group,
                     )
-                }
+                },
+                "mute": mute_prop(),
             },
         )
         return BUS_cls(remote, index)

xair_api/config.py

@@ -1,9 +1,10 @@
 import abc
+import logging
 
-from . import kinds
+from . import kinds, util
-from .errors import XAirRemoteError
 from .meta import bool_prop
-from .util import _get_level_val, _set_level_val, lin_get, lin_set
+
+logger = logging.getLogger(__name__)
 
 
 class IConfig(abc.ABC):
@@ -11,10 +12,10 @@ class IConfig(abc.ABC):
 
     def __init__(self, remote):
         self._remote = remote
+        self.logger = logger.getChild(self.__class__.__name__)
 
     def getter(self, param: str):
-        self._remote.send(f"{self.address}/{param}")
+        return self._remote.query(f"{self.address}/{param}")
-        return self._remote.info_response
 
     def setter(self, param: str, val: int):
         self._remote.send(f"{self.address}/{param}", val)
@@ -35,8 +36,8 @@ class Config(IConfig):
         Returns a Config class of a kind.
         """
         LINKS_cls = _make_links_mixins[remote.kind.id_]
-        MUTEGROUP_cls = type(f"MuteGroup", (Config.MuteGroup, cls), {})
+        MUTEGROUP_cls = type("MuteGroup", (Config.MuteGroup, cls), {})
-        MONITOR_cls = type(f"ConfigMonitor", (Config.Monitor, cls), {})
+        MONITOR_cls = type("ConfigMonitor", (Config.Monitor, cls), {})
         CONFIG_cls = type(
             f"Config{remote.kind}",
             (cls, LINKS_cls),
@@ -49,7 +50,7 @@ class Config(IConfig):
 
     @property
     def address(self) -> str:
-        return f"/config"
+        return "/config"
 
     @property
     def amixenable(self) -> bool:
@@ -57,8 +58,6 @@ class Config(IConfig):
 
     @amixenable.setter
     def amixenable(self, val: bool):
-        if not isinstance(val, bool):
-            raise XAirRemoteError("amixenable is a bool parameter")
         self.setter("amixenable", 1 if val else 0)
 
     @property
@@ -67,8 +66,6 @@ class Config(IConfig):
 
     @amixlock.setter
     def amixlock(self, val: bool):
-        if not isinstance(val, bool):
-            raise XAirRemoteError("amixlock is a bool parameter")
         self.setter("amixlock", 1 if val else 0)
 
     class MuteGroup:
@@ -87,8 +84,6 @@ class Config(IConfig):
 
         @on.setter
         def on(self, val: bool):
-            if not isinstance(val, bool):
-                raise XAirRemoteError("on is a boolean parameter")
             self.setter(f"{self.i}", 1 if val else 0)
 
     class Monitor:
@@ -98,13 +93,14 @@ class Config(IConfig):
             return f"{root}/solo"
 
         @property
+        @util.db_from
         def level(self) -> float:
-            retval = self.getter("level")[0]
+            return self.getter("level")[0]
-            return _get_level_val(retval)
 
         @level.setter
+        @util.db_to
         def level(self, val: float):
-            _set_level_val(self, val)
+            self.setter("level", val)
 
         @property
         def source(self) -> int:
@@ -112,21 +108,19 @@ class Config(IConfig):
 
         @source.setter
         def source(self, val: int):
-            if not isinstance(val, int):
+            self.setter("source", val)
-                raise XAirRemoteError("source is an int parameter")
-            self.setter(f"source", val)
 
         @property
         def sourcetrim(self) -> float:
-            return round(lin_get(-18, 18, self.getter("sourcetrim")[0]), 1)
+            return round(util.lin_get(-18, 18, self.getter("sourcetrim")[0]), 1)
 
         @sourcetrim.setter
         def sourcetrim(self, val: float):
-            if not isinstance(val, float):
+            if not -18 <= val <= 18:
-                raise XAirRemoteError(
+                self.logger.warning(
-                    "sourcetrim is a float parameter, expected value in range -18 to 18"
+                    f"sourcetrim got {val}, expected value in range -18.0 to 18.0"
                 )
-            self.setter("sourcetrim", lin_set(-18, 18, val))
+            self.setter("sourcetrim", util.lin_set(-18, 18, val))
 
         @property
         def chmode(self) -> bool:
@@ -134,8 +128,6 @@ class Config(IConfig):
 
         @chmode.setter
         def chmode(self, val: bool):
-            if not isinstance(val, bool):
-                raise XAirRemoteError("chmode is a bool parameter")
             self.setter("chmode", 1 if val else 0)
 
         @property
@@ -144,21 +136,19 @@ class Config(IConfig):
 
         @busmode.setter
         def busmode(self, val: bool):
-            if not isinstance(val, bool):
-                raise XAirRemoteError("busmode is a bool parameter")
             self.setter("busmode", 1 if val else 0)
 
         @property
         def dimgain(self) -> int:
-            return int(lin_get(-40, 0, self.getter("dimatt")[0]))
+            return int(util.lin_get(-40, 0, self.getter("dimatt")[0]))
 
         @dimgain.setter
         def dimgain(self, val: int):
-            if not isinstance(val, int):
+            if not -40 <= val <= 0:
-                raise XAirRemoteError(
+                self.logger.warning(
-                    "dimgain is an int parameter, expected value in range -40 to 0"
+                    f"dimgain got {val}, expected value in range -40 to 0"
                 )
-            self.setter("dimatt", lin_set(-40, 0, val))
+            self.setter("dimatt", util.lin_set(-40, 0, val))
 
         @property
         def dim(self) -> bool:
@@ -166,8 +156,6 @@ class Config(IConfig):
 
         @dim.setter
         def dim(self, val: bool):
-            if not isinstance(val, bool):
-                raise XAirRemoteError("dim is a bool parameter")
             self.setter("dim", 1 if val else 0)
 
         @property
@@ -176,8 +164,6 @@ class Config(IConfig):
 
         @mono.setter
         def mono(self, val: bool):
-            if not isinstance(val, bool):
-                raise XAirRemoteError("mono is a bool parameter")
             self.setter("mono", 1 if val else 0)
 
         @property
@@ -186,8 +172,6 @@ class Config(IConfig):
 
         @mute.setter
         def mute(self, val: bool):
-            if not isinstance(val, bool):
-                raise XAirRemoteError("mute is a bool parameter")
             self.setter("mute", 1 if val else 0)
 
         @property
@@ -196,8 +180,6 @@ class Config(IConfig):
 
         @dimfpl.setter
         def dimfpl(self, val: bool):
-            if not isinstance(val, bool):
-                raise XAirRemoteError("dimfpl is a bool parameter")
             self.setter("dimfpl", 1 if val else 0)
 
 

xair_api/dca.py

@@ -1,6 +1,7 @@
 import abc
+import logging
 
-from .errors import XAirRemoteError
+logger = logging.getLogger(__name__)
 
 
 class IDCA(abc.ABC):
@@ -9,10 +10,10 @@ class IDCA(abc.ABC):
     def __init__(self, remote, index: int):
         self._remote = remote
         self.index = index + 1
+        self.logger = logger.getChild(self.__class__.__name__)
 
     def getter(self, param: str) -> tuple:
-        self._remote.send(f"{self.address}/{param}")
+        return self._remote.query(f"{self.address}/{param}")
-        return self._remote.info_response
 
     def setter(self, param: str, val: int):
         self._remote.send(f"{self.address}/{param}", val)
@@ -35,19 +36,23 @@ class DCA(IDCA):
 
     @on.setter
     def on(self, val: bool):
-        if not isinstance(val, bool):
-            raise XAirRemoteError("on is a boolean parameter")
         self.setter("on", 1 if val else 0)
 
+    @property
+    def mute(self) -> bool:
+        return not self.on
+
+    @mute.setter
+    def mute(self, val: bool):
+        self.on = not val
+
     @property
     def name(self) -> str:
         return self.getter("config/name")[0]
 
     @name.setter
     def name(self, val: str):
-        if not isinstance(val, str):
+        self.setter("config/name", val)
-            raise XAirRemoteError("name is a str parameter")
-        self.setter("config/name")[0]
 
     @property
     def color(self) -> int:
@@ -55,6 +60,4 @@ class DCA(IDCA):
 
     @color.setter
     def color(self, val: int):
-        if not isinstance(val, int):
-            raise XAirRemoteError("color is an int parameter")
         self.setter("config/color", val)

xair_api/errors.py

@@ -1,4 +1,14 @@
 class XAirRemoteError(Exception):
     """Base error class for XAIR Remote."""
 
-    pass
+
+class XAirRemoteConnectionTimeoutError(XAirRemoteError):
+    """Exception raised when a connection attempt times out"""
+
+    def __init__(self, ip, port):
+        self.ip = ip
+        self.port = port
+
+        super().__init__(
+            f"Timeout attempting to connect to mixer at {self.ip}:{self.port}"
+        )

xair_api/fx.py

@@ -1,7 +1,10 @@
 import abc
+import logging
 
-from .errors import XAirRemoteError
+from .meta import mute_prop
-from .shared import EQ, GEQ, Automix, Config, Dyn, Gate, Group, Insert, Mix, Preamp
+from .shared import Config, Group, Mix
+
+logger = logging.getLogger(__name__)
 
 
 class IFX(abc.ABC):
@@ -10,10 +13,10 @@ class IFX(abc.ABC):
     def __init__(self, remote, index: int):
         self._remote = remote
         self.index = index + 1
+        self.logger = logger.getChild(self.__class__.__name__)
 
     def getter(self, param: str):
-        self._remote.send(f"{self.address}/{param}")
+        return self._remote.query(f"{self.address}/{param}")
-        return self._remote.info_response
 
     def setter(self, param: str, val: int):
         self._remote.send(f"{self.address}/{param}", val)
@@ -23,6 +26,22 @@ class IFX(abc.ABC):
         pass
 
 
+class FX(IFX):
+    """Concrete class for fx"""
+
+    @property
+    def address(self) -> str:
+        return f"/fx/{self.index}"
+
+    @property
+    def type(self) -> int:
+        return self.getter("type")[0]
+
+    @type.setter
+    def type(self, val: int):
+        self.setter("type", val)
+
+
 class FXSend(IFX):
     """Concrete class for fxsend"""
 
@@ -44,7 +63,8 @@ class FXSend(IFX):
                         f"{_cls.__name__}{remote.kind}", (_cls, cls), {}
                     )(remote, index)
                     for _cls in (Config, Mix, Group)
-                }
+                },
+                "mute": mute_prop(),
             },
         )
         return FXSEND_cls(remote, index)
@@ -52,21 +72,3 @@ class FXSend(IFX):
     @property
     def address(self) -> str:
         return f"/fxsend/{self.index}"
-
-
-class FXReturn(IFX):
-    """Concrete class for fxreturn"""
-
-    @property
-    def address(self) -> str:
-        return f"/fx/{self.index}"
-
-    @property
-    def type(self) -> int:
-        return self.getter("type")[0]
-
-    @type.setter
-    def type(self, val: int):
-        if not isinstance(val, int):
-            raise XAirRemoteError("type is an integer parameter")
-        self.setter("type", val)

xair_api/headamp.py

@@ -0,0 +1,49 @@
+import abc
+import logging
+
+from . import util
+
+logger = logging.getLogger(__name__)
+
+
+class IHeadAmp(abc.ABC):
+    """Abstract Base Class for headamps"""
+
+    def __init__(self, remote, index: int):
+        self._remote = remote
+        self.index = index + 1
+        self.logger = logger.getChild(self.__class__.__name__)
+
+    def getter(self, param: str):
+        return self._remote.query(f"{self.address}/{param}")
+
+    def setter(self, param: str, val: int):
+        self._remote.send(f"{self.address}/{param}", val)
+
+    @abc.abstractmethod
+    def address(self):
+        pass
+
+
+class HeadAmp(IHeadAmp):
+    """Concrete class for headamps"""
+
+    @property
+    def address(self):
+        return f"/headamp/{str(self.index).zfill(2)}"
+
+    @property
+    def gain(self):
+        return round(util.lin_get(-12, 60, self.getter("gain")[0]), 1)
+
+    @gain.setter
+    def gain(self, val):
+        self.setter("gain", util.lin_set(-12, 60, val))
+
+    @property
+    def phantom(self):
+        return self.getter("phantom")[0] == 1
+
+    @phantom.setter
+    def phantom(self, val):
+        self.setter("phantom", 1 if val else 0)

xair_api/kinds.py

@@ -1,18 +1,5 @@
 from dataclasses import dataclass
 
-"""
-# osc slightly different, interface would need adjusting to support this mixer.
-
-@dataclass
-class X32KindMap:
-    id_: str = "X32"
-    num_dca: int = 8
-    num_strip: int = 32
-    num_bus: int = 16
-    num_fx: int = 8
-    num_rtn: int = 6
-"""
-
 
 @dataclass
 class KindMap:
@@ -21,14 +8,25 @@ class KindMap:
 
 
 @dataclass
-class MR18KindMap(KindMap):
+class X32KindMap(KindMap):
-    # note ch 17-18 defined as aux rtn
+    id_: str
+    num_dca: int = 8
+    num_strip: int = 32
+    num_bus: int = 16
+    num_fx: int = 8
+    num_auxrtn: int = 8
+    num_matrix: int = 6
+    num_headamp: int = 127
+
+
+@dataclass
+class XR18KindMap(KindMap):
+    # note ch 17-18 defined as aux return
     id_: str
     num_dca: int = 4
     num_strip: int = 16
     num_bus: int = 6
     num_fx: int = 4
-    num_rtn: int = 4
 
 
 @dataclass
@@ -38,7 +36,6 @@ class XR16KindMap(KindMap):
     num_strip: int = 16
     num_bus: int = 4
     num_fx: int = 4
-    num_rtn: int = 4
 
 
 @dataclass
@@ -48,12 +45,12 @@ class XR12KindMap(KindMap):
     num_strip: int = 12
     num_bus: int = 2
     num_fx: int = 4
-    num_rtn: int = 4
 
 
 _kinds = {
-    "XR18": MR18KindMap(id_="XR18"),
+    "X32": X32KindMap(id_="X32"),
-    "MR18": MR18KindMap(id_="MR18"),
+    "MR18": XR18KindMap(id_="MR18"),
+    "XR18": XR18KindMap(id_="XR18"),
     "XR16": XR16KindMap(id_="XR16"),
     "XR12": XR12KindMap(id_="XR12"),
 }

xair_api/lr.py

@@ -1,18 +1,24 @@
 import abc
+import logging
+from typing import Optional
 
-from .errors import XAirRemoteError
+from .meta import mute_prop
-from .shared import EQ, GEQ, Automix, Config, Dyn, Gate, Group, Insert, Mix, Preamp
+from .shared import EQ, GEQ, Config, Dyn, Insert, Mix
+
+logger = logging.getLogger(__name__)
 
 
 class ILR(abc.ABC):
-    """Abstract Base Class for buses"""
+    """Abstract Base Class for lr"""
 
-    def __init__(self, remote):
+    def __init__(self, remote, index: Optional[int] = None):
         self._remote = remote
+        if index is not None:
+            self.index = index + 1
+        self.logger = logger.getChild(self.__class__.__name__)
 
     def getter(self, param: str):
-        self._remote.send(f"{self.address}/{param}")
+        return self._remote.query(f"{self.address}/{param}")
-        return self._remote.info_response
 
     def setter(self, param: str, val: int):
         self._remote.send(f"{self.address}/{param}", val)
@@ -23,10 +29,10 @@ class ILR(abc.ABC):
 
 
 class LR(ILR):
-    """Concrete class for buses"""
+    """Concrete class for lr"""
 
     @classmethod
-    def make(cls, remote):
+    def make(cls, remote, index=None):
         """
         Factory function for LR
 
@@ -41,20 +47,21 @@ class LR(ILR):
                 **{
                     _cls.__name__.lower(): type(
                         f"{_cls.__name__}{remote.kind}", (_cls, cls), {}
-                    )(remote)
+                    )(remote, index)
                     for _cls in (
                         Config,
                         Dyn,
                         Insert,
                         GEQ.make(),
-                        EQ.make_sixband(cls, remote),
+                        EQ.make_sixband(cls, remote, index),
                         Mix,
                     )
                 },
+                "mute": mute_prop(),
             },
         )
-        return LR_cls(remote)
+        return LR_cls(remote, index)
 
     @property
     def address(self) -> str:
-        return f"/lr"
+        return "/lr"

xair_api/meta.py

@@ -1,4 +1,3 @@
-from .errors import XAirRemoteError
 from .util import lin_get, lin_set
 
 
@@ -9,8 +8,6 @@ def bool_prop(param):
         return self.getter(param)[0] == 1
 
     def fset(self, val):
-        if not isinstance(val, bool):
-            raise XAirRemoteError(f"{param} is a boolean parameter")
         self.setter(param, 1 if val else 0)
 
     return property(fget, fset)
@@ -23,8 +20,6 @@ def string_prop(param):
         return self.getter(param)[0]
 
     def fset(self, val):
-        if not isinstance(val, str):
-            raise XAirRemoteError(f"{param} is a string parameter")
         self.setter(param, val)
 
     return property(fget, fset)
@@ -37,8 +32,6 @@ def int_prop(param):
         return int(self.getter(param)[0])
 
     def fset(self, val):
-        if not isinstance(val, int):
-            raise XAirRemoteError(f"{param} is an integer parameter")
         self.setter(param, val)
 
     return property(fget, fset)
@@ -51,27 +44,32 @@ def float_prop(param):
         return round(self.getter(param)[0], 1)
 
     def fset(self, val):
-        if not isinstance(val, int):
-            raise XAirRemoteError(f"{param} is a float parameter")
         self.setter(param, val)
 
     return property(fget, fset)
 
 
 def geq_prop(param):
-    # fmt: off
-    opts = {
-        "1k": 1000, "1k25": 1250, "1k6": 1600, "2k": 2000, "3k15": 3150, "4k": 4000,
-        "5k": 5000, "6k3": 6300, "8k": 8000, "10k": 10000, "12k5": 12500, "16k": 16000,
-        "20k": 20000,
-    }
-    # fmt: on
     param = param.replace("_", ".")
 
     def fget(self) -> float:
         return round(lin_get(-15, 15, self.getter(param)[0]), 1)
 
     def fset(self, val):
+        if not -15 <= val <= 15:
+            self.logger.warning(
+                f"slider_{param} got {val}, expected value in range -15.0 to 15.0"
+            )
         self.setter(param, lin_set(-15, 15, val))
 
     return property(fget, fset)
+
+
+def mute_prop():
+    def fget(self):
+        return not self.mix.on
+
+    def fset(self, val):
+        self.mix.on = not val
+
+    return property(fget, fset)

xair_api/rtn.py

@@ -1,21 +1,24 @@
 import abc
+import logging
 from typing import Optional
 
-from .errors import XAirRemoteError
+from .meta import mute_prop
-from .shared import EQ, GEQ, Automix, Config, Dyn, Gate, Group, Insert, Mix, Preamp
+from .shared import EQ, Config, Group, Mix, Preamp, Send
+
+logger = logging.getLogger(__name__)
 
 
 class IRtn(abc.ABC):
-    """Abstract Base Class for aux"""
+    """Abstract Base Class for rtn"""
 
     def __init__(self, remote, index: Optional[int] = None):
         self._remote = remote
         if index is not None:
             self.index = index + 1
+        self.logger = logger.getChild(self.__class__.__name__)
 
     def getter(self, param: str):
-        self._remote.send(f"{self.address}/{param}")
+        return self._remote.query(f"{self.address}/{param}")
-        return self._remote.info_response
 
     def setter(self, param: str, val: int):
         self._remote.send(f"{self.address}/{param}", val)
@@ -25,26 +28,26 @@ class IRtn(abc.ABC):
         pass
 
 
-class Aux(IRtn):
+class AuxRtn(IRtn):
-    """Concrete class for aux"""
+    """Concrete class for auxrtn"""
 
     @classmethod
-    def make(cls, remote):
+    def make(cls, remote, index=None):
         """
-        Factory function for aux
+        Factory function for auxrtn
 
         Creates a mixin of shared subclasses, sets them as class attributes.
 
-        Returns an Aux class of a kind.
+        Returns an AuxRtn class of a kind.
         """
-        AUX_cls = type(
+        AUXRTN_cls = type(
-            f"Aux{remote.kind}",
+            f"AuxRtn{remote.kind}",
             (cls,),
             {
                 **{
                     _cls.__name__.lower(): type(
                         f"{_cls.__name__}{remote.kind}", (_cls, cls), {}
-                    )(remote)
+                    )(remote, index)
                     for _cls in (
                         Config,
                         Preamp,
@@ -52,35 +55,40 @@ class Aux(IRtn):
                         Mix,
                         Group,
                     )
-                }
+                },
+                "send": tuple(
+                    Send.make(cls, i, remote)
+                    for i in range(remote.kind.num_bus + remote.kind.num_fx)
+                ),
+                "mute": mute_prop(),
             },
         )
-        return AUX_cls(remote)
+        return AUXRTN_cls(remote, index)
 
     @property
     def address(self):
         return "/rtn/aux"
 
 
-class Rtn(IRtn):
+class FxRtn(IRtn):
-    """Concrete class for rtn"""
+    """Concrete class for fxrtn"""
 
     @classmethod
     def make(cls, remote, index):
         """
-        Factory function for rtn
+        Factory function for fxrtn
 
         Creates a mixin of shared subclasses, sets them as class attributes.
 
-        Returns an Rtn class of a kind.
+        Returns an FxRtn class of a kind.
         """
-        RTN_cls = type(
+        FXRTN_cls = type(
-            f"Rtn{remote.kind.id_}",
+            f"FxRtn{remote.kind}",
             (cls,),
             {
                 **{
                     _cls.__name__.lower(): type(
-                        f"{_cls.__name__}{remote.kind.id_}", (_cls, cls), {}
+                        f"{_cls.__name__}{remote.kind}", (_cls, cls), {}
                     )(remote, index)
                     for _cls in (
                         Config,
@@ -89,10 +97,15 @@ class Rtn(IRtn):
                         Mix,
                         Group,
                     )
-                }
+                },
+                "send": tuple(
+                    Send.make(cls, i, remote, index)
+                    for i in range(remote.kind.num_bus + remote.kind.num_fx)
+                ),
+                "mute": mute_prop(),
             },
         )
-        return RTN_cls(remote, index)
+        return FXRTN_cls(remote, index)
 
     @property
     def address(self):

xair_api/shared.py

@@ -1,11 +1,10 @@
-from typing import Union
+from typing import Optional, Union
 
-from .errors import XAirRemoteError
+from . import util
 from .meta import geq_prop
-from .util import _get_fader_val, _set_fader_val, lin_get, lin_set, log_get, log_set
 
 """
-Classes shared by /ch, /rtn, /rt/aux, /bus, /fxsend, /lr
+Classes shared by /ch, /rtn, /rtn/aux, /bus, /fxsend, /lr
 """
 
 
@@ -21,8 +20,6 @@ class Config:
 
     @name.setter
     def name(self, val: str):
-        if not isinstance(val, str):
-            raise XAirRemoteError("name is a string parameter")
         self.setter("name", val)
 
     @property
@@ -31,8 +28,6 @@ class Config:
 
     @color.setter
     def color(self, val: int):
-        if not isinstance(val, int):
-            raise XAirRemoteError("color is an int parameter")
         self.setter("color", val)
 
     @property
@@ -41,8 +36,6 @@ class Config:
 
     @inputsource.setter
     def inputsource(self, val: int):
-        if not isinstance(val, int):
-            raise XAirRemoteError("inputsource is an int parameter")
         self.setter("insrc", val)
 
     @property
@@ -51,8 +44,6 @@ class Config:
 
     @usbreturn.setter
     def usbreturn(self, val: int):
-        if not isinstance(val, int):
-            raise XAirRemoteError("usbreturn is an int parameter")
         self.setter("rtnsrc", val)
 
 
@@ -64,15 +55,15 @@ class Preamp:
 
     @property
     def usbtrim(self) -> float:
-        return round(lin_get(-18, 18, self.getter("rtntrim")[0]), 1)
+        return round(util.lin_get(-18, 18, self.getter("rtntrim")[0]), 1)
 
     @usbtrim.setter
     def usbtrim(self, val: float):
-        if not isinstance(val, float):
+        if not -18 <= val <= 18:
-            raise XAirRemoteError(
+            self.logger.warning(
-                "usbtrim is a float parameter, expected value in range -18 to 18"
+                f"usbtrim got {val}, expected value in range -18.0 to 18.0"
             )
-        self.setter("rtntrim", lin_set(-18, 18, val))
+        self.setter("rtntrim", util.lin_set(-18, 18, val))
 
     @property
     def usbinput(self) -> bool:
@@ -80,8 +71,6 @@ class Preamp:
 
     @usbinput.setter
     def usbinput(self, val: bool):
-        if not isinstance(val, bool):
-            raise XAirRemoteError("rtnsw is a bool parameter")
         self.setter("rtnsw", 1 if val else 0)
 
     @property
@@ -90,8 +79,6 @@ class Preamp:
 
     @invert.setter
     def invert(self, val: bool):
-        if not isinstance(val, bool):
-            raise XAirRemoteError("invert is a bool parameter")
         self.setter("invert", 1 if val else 0)
 
     @property
@@ -100,19 +87,19 @@ class Preamp:
 
     @highpasson.setter
     def highpasson(self, val: bool):
-        if not isinstance(val, bool):
-            raise XAirRemoteError("hpon is a bool parameter")
         self.setter("hpon", 1 if val else 0)
 
     @property
     def highpassfilter(self) -> int:
-        return int(log_get(20, 400, self.getter("hpf")[0]))
+        return int(util.log_get(20, 400, self.getter("hpf")[0]))
 
     @highpassfilter.setter
     def highpassfilter(self, val: int):
-        if not isinstance(val, int):
+        if not 20 <= val <= 400:
-            raise XAirRemoteError("highpassfilter is an int parameter")
+            self.logger.warning(
-        self.setter("hpf", log_set(20, 400, val))
+                f"highpassfilter got {val}, expected value in range 20 to 400"
+            )
+        self.setter("hpf", util.log_set(20, 400, val))
 
 
 class Gate:
@@ -127,8 +114,6 @@ class Gate:
 
     @on.setter
     def on(self, val: bool):
-        if not isinstance(val, bool):
-            raise XAirRemoteError("on is a boolean parameter")
         self.setter("on", 1 if val else 0)
 
     @property
@@ -139,66 +124,64 @@ class Gate:
     @mode.setter
     def mode(self, val: str):
         opts = ("gate", "exp2", "exp3", "exp4", "duck")
-        if not isinstance(val, str) and val not in opts:
+        if val not in opts:
-            raise XAirRemoteError(f"mode is a string parameter, expected one of {opts}")
+            self.logger.warning(f"mode got {val}, expected one of {opts}")
         self.setter("mode", opts.index(val))
 
     @property
     def threshold(self) -> float:
-        return round(lin_get(-80, 0, self.getter("thr")[0]), 1)
+        return round(util.lin_get(-80, 0, self.getter("thr")[0]), 1)
 
     @threshold.setter
     def threshold(self, val: float):
-        if not isinstance(val, float):
+        if not -80 <= val <= 0:
-            raise XAirRemoteError(
+            self.logger.warning(
-                "threshold is a float parameter, expected value in range -80 to 0"
+                f"threshold got {val}, expected value in range -80.0 to 0.0"
             )
-        self.setter("thr", lin_set(-80, 0, val))
+        self.setter("thr", util.lin_set(-80, 0, val))
 
     @property
     def range(self) -> int:
-        return int(lin_get(3, 60, self.getter("range")[0]))
+        return int(util.lin_get(3, 60, self.getter("range")[0]))
 
     @range.setter
     def range(self, val: int):
-        if not isinstance(val, int):
+        if not 3 <= val <= 60:
-            raise XAirRemoteError(
+            self.logger.warning(f"range got {val}, expected value in range 3 to 60")
-                "range is an int parameter, expected value in range 3 to 60"
+        self.setter("range", util.lin_set(3, 60, val))
-            )
-        self.setter("range", lin_set(3, 60, val))
 
     @property
     def attack(self) -> int:
-        return int(lin_get(0, 120, self.getter("attack")[0]))
+        return int(util.lin_get(0, 120, self.getter("attack")[0]))
 
     @attack.setter
     def attack(self, val: int):
-        if not isinstance(val, int):
+        if not 0 <= val <= 120:
-            raise XAirRemoteError(
+            self.logger.warning(f"attack got {val}, expected value in range 0 to 120")
-                "attack is an int parameter, expected value in range 0 to 120"
+        self.setter("attack", util.lin_set(0, 120, val))
-            )
-        self.setter("attack", lin_set(0, 120, val))
 
     @property
     def hold(self) -> Union[float, int]:
-        val = log_get(0.02, 2000, self.getter("hold")[0])
+        val = util.log_get(0.02, 2000, self.getter("hold")[0])
         return round(val, 1) if val < 100 else int(val)
 
     @hold.setter
     def hold(self, val: float):
-        self.setter("hold", log_set(0.02, 2000, val))
+        if not 0.02 <= val <= 2000:
+            self.logger.warning(
+                f"hold got {val}, expected value in range 0.02 to 2000.0"
+            )
+        self.setter("hold", util.log_set(0.02, 2000, val))
 
     @property
     def release(self) -> int:
-        return int(log_get(5, 4000, self.getter("release")[0]))
+        return int(util.log_get(5, 4000, self.getter("release")[0]))
 
     @release.setter
     def release(self, val: int):
-        if not isinstance(val, int):
+        if not 5 <= val <= 4000:
-            raise XAirRemoteError(
+            self.logger.warning(f"release got {val}, expected value in range 5 to 4000")
-                "release is an int parameter, expected value in range 5 to 4000"
+        self.setter("release", util.log_set(5, 4000, val))
-            )
-        self.setter("release", log_set(5, 4000, val))
 
     @property
     def keysource(self):
@@ -206,8 +189,6 @@ class Gate:
 
     @keysource.setter
     def keysource(self, val):
-        if not isinstance(val, int):
-            raise XAirRemoteError("keysource is an int parameter")
         self.setter("keysrc", val)
 
     @property
@@ -216,8 +197,6 @@ class Gate:
 
     @filteron.setter
     def filteron(self, val: bool):
-        if not isinstance(val, bool):
-            raise XAirRemoteError("filteron is a boolean parameter")
         self.setter("filter/on", 1 if val else 0)
 
     @property
@@ -226,18 +205,20 @@ class Gate:
 
     @filtertype.setter
     def filtertype(self, val: int):
-        if not isinstance(val, int):
-            raise XAirRemoteError("filtertype is an int parameter")
         self.setter("filter/type", val)
 
     @property
     def filterfreq(self) -> Union[float, int]:
-        retval = log_get(20, 20000, self.getter("filter/f")[0])
+        retval = util.log_get(20, 20000, self.getter("filter/f")[0])
         return int(retval) if retval > 1000 else round(retval, 1)
 
     @filterfreq.setter
     def filterfreq(self, val: Union[float, int]):
-        self.setter("filter/f", log_set(20, 20000, val))
+        if not 20 <= val <= 20000:
+            self.logger.warning(
+                f"filterfreq got {val}, expected value in range 20 to 20000"
+            )
+        self.setter("filter/f", util.log_set(20, 20000, val))
 
 
 class Dyn:
@@ -252,8 +233,6 @@ class Dyn:
 
     @on.setter
     def on(self, val: bool):
-        if not isinstance(val, bool):
-            raise XAirRemoteError("on is a boolean parameter")
         self.setter("on", 1 if val else 0)
 
     @property
@@ -264,8 +243,8 @@ class Dyn:
     @mode.setter
     def mode(self, val: str):
         opts = ("comp", "exp")
-        if not isinstance(val, str) and val not in opts:
+        if val not in opts:
-            raise XAirRemoteError(f"mode is a string parameter, expected one of {opts}")
+            self.logger.warning(f"mode got {val}, expected one of {opts}")
         self.setter("mode", opts.index(val))
 
     @property
@@ -276,8 +255,8 @@ class Dyn:
     @det.setter
     def det(self, val: str):
         opts = ("peak", "rms")
-        if not isinstance(val, str) and val not in opts:
+        if val not in opts:
-            raise XAirRemoteError(f"det is a string parameter, expected one of {opts}")
+            self.logger.warning(f"det got {val}, expected one of {opts}")
         self.setter("det", opts.index(val))
 
     @property
@@ -288,21 +267,21 @@ class Dyn:
     @env.setter
     def env(self, val: str):
         opts = ("lin", "log")
-        if not isinstance(val, str) and val not in opts:
+        if val not in opts:
-            raise XAirRemoteError(f"env is a string parameter, expected one of {opts}")
+            self.logger.warning(f"env got {val}, expected one of {opts}")
         self.setter("env", opts.index(val))
 
     @property
     def threshold(self) -> float:
-        return round(lin_get(-60, 0, self.getter("thr")[0]), 1)
+        return round(util.lin_get(-60, 0, self.getter("thr")[0]), 1)
 
     @threshold.setter
     def threshold(self, val: float):
-        if not isinstance(val, float):
+        if not -60 <= val <= 0:
-            raise XAirRemoteError(
+            self.logger.warning(
-                "threshold is a float parameter, expected value in range -80 to 0"
+                f"threshold got {val}, expected value in range -60.0 to 0"
             )
-        self.setter("thr", lin_set(-60, 0, val))
+        self.setter("thr", util.lin_set(-60, 0, val))
 
     @property
     def ratio(self) -> Union[float, int]:
@@ -311,70 +290,70 @@ class Dyn:
 
     @ratio.setter
     def ratio(self, val: int):
-        if not isinstance(val, int):
-            raise XAirRemoteError("ratio is an int parameter")
         self.setter("ratio", val)
 
     @property
     def knee(self) -> int:
-        return int(lin_get(0, 5, self.getter("knee")[0]))
+        return int(util.lin_get(0, 5, self.getter("knee")[0]))
 
     @knee.setter
     def knee(self, val: int):
-        if not isinstance(val, int):
+        if not 0 <= val <= 5:
-            raise XAirRemoteError(
+            self.logger.warning(f"knee got {val}, expected value in range 0 to 5")
-                "knee is an int parameter, expected value in range 0 to 5"
+        self.setter("knee", util.lin_set(0, 5, val))
-            )
-        self.setter("knee", lin_set(0, 5, val))
 
     @property
     def mgain(self) -> float:
-        return round(lin_get(0, 24, self.getter("mgain")[0]), 1)
+        return round(util.lin_get(0, 24, self.getter("mgain")[0]), 1)
 
     @mgain.setter
     def mgain(self, val: float):
-        self.setter("mgain", lin_set(0, 24, val))
+        if not 0 <= val <= 24:
+            self.logger.warning(f"mgain got {val}, expected value in range 0.0 to 24.0")
+        self.setter("mgain", util.lin_set(0, 24, val))
 
     @property
     def attack(self) -> int:
-        return int(lin_get(0, 120, self.getter("attack")[0]))
+        return int(util.lin_get(0, 120, self.getter("attack")[0]))
 
     @attack.setter
     def attack(self, val: int):
-        self.setter("attack", lin_set(0, 120, val))
+        if not 0 <= val <= 120:
+            self.logger.warning(f"attack got {val}, expected value in range 0 to 120")
+        self.setter("attack", util.lin_set(0, 120, val))
 
     @property
     def hold(self) -> Union[float, int]:
-        val = log_get(0.02, 2000, self.getter("hold")[0])
+        val = util.log_get(0.02, 2000, self.getter("hold")[0])
         return round(val, 1) if val < 100 else int(val)
 
     @hold.setter
     def hold(self, val: float):
-        self.setter("hold", log_set(0.02, 2000, val))
+        if not 0.02 <= val <= 2000:
+            self.logger.warning(
+                f"hold got {val}, expected value in range 0.02 to 2000.0"
+            )
+        self.setter("hold", util.log_set(0.02, 2000, val))
 
     @property
     def release(self) -> int:
-        return int(log_get(5, 4000, self.getter("release")[0]))
+        return int(util.log_get(5, 4000, self.getter("release")[0]))
 
     @release.setter
     def release(self, val: int):
-        if not isinstance(val, int):
+        if not 5 <= val <= 4000:
-            raise XAirRemoteError(
+            self.logger.warning(f"release got {val}, expected value in range 5 to 4000")
-                "release is an int parameter, expected value in range 5 to 4000"
+        self.setter("release", util.log_set(5, 4000, val))
-            )
-        self.setter("release", log_set(5, 4000, val))
 
     @property
     def mix(self) -> int:
-        return int(lin_get(0, 100, self.getter("mix")[0]))
+        return int(util.lin_get(0, 100, self.getter("mix")[0]))
 
     @mix.setter
     def mix(self, val: int):
-        if not isinstance(val, int):
+        if not 0 <= val <= 100:
-            raise XAirRemoteError(
+            self.logger.warning(f"mix got {val}, expected value in range 0 to 100")
-                "mix is an int parameter, expected value in range 0 to 5"
+        self.setter("mix", util.lin_set(0, 100, val))
-            )
-        self.setter("mix", lin_set(0, 100, val))
 
     @property
     def keysource(self):
@@ -382,8 +361,6 @@ class Dyn:
 
     @keysource.setter
     def keysource(self, val):
-        if not isinstance(val, int):
-            raise XAirRemoteError("keysource is an int parameter")
         self.setter("keysrc", val)
 
     @property
@@ -392,8 +369,6 @@ class Dyn:
 
     @auto.setter
     def auto(self, val: bool):
-        if not isinstance(val, bool):
-            raise XAirRemoteError("auto is a boolean parameter")
         self.setter("auto", 1 if val else 0)
 
     @property
@@ -402,8 +377,6 @@ class Dyn:
 
     @filteron.setter
     def filteron(self, val: bool):
-        if not isinstance(val, bool):
-            raise XAirRemoteError("filteron is a boolean parameter")
         self.setter("filter/on", 1 if val else 0)
 
     @property
@@ -412,18 +385,20 @@ class Dyn:
 
     @filtertype.setter
     def filtertype(self, val: int):
-        if not isinstance(val, int):
-            raise XAirRemoteError("filtertype is an int parameter")
         self.setter("filter/type", val)
 
     @property
     def filterfreq(self) -> Union[float, int]:
-        retval = log_get(20, 20000, self.getter("filter/f")[0])
+        retval = util.log_get(20, 20000, self.getter("filter/f")[0])
         return int(retval) if retval > 1000 else round(retval, 1)
 
     @filterfreq.setter
     def filterfreq(self, val: Union[float, int]):
-        self.setter("filter/f", log_set(20, 20000, val))
+        if not 20 <= val <= 20000:
+            self.logger.warning(
+                f"filterfreq got {val}, expected value in range 20 to 20000"
+            )
+        self.setter("filter/f", util.log_set(20, 20000, val))
 
 
 class Insert:
@@ -438,8 +413,6 @@ class Insert:
 
     @on.setter
     def on(self, val: bool):
-        if not isinstance(val, bool):
-            raise XAirRemoteError("on is a boolean parameter")
         self.setter("on", 1 if val else 0)
 
     @property
@@ -448,8 +421,6 @@ class Insert:
 
     @sel.setter
     def sel(self, val: int):
-        if not isinstance(val, int):
-            raise XAirRemoteError("sel is an int parameter")
         self.setter("sel", val)
 
 
@@ -495,8 +466,6 @@ class EQ:
 
     @on.setter
     def on(self, val: bool):
-        if not isinstance(val, bool):
-            raise XAirRemoteError("on is a boolean parameter")
         self.setter("on", 1 if val else 0)
 
     @property
@@ -507,16 +476,13 @@ class EQ:
     @mode.setter
     def mode(self, val: str):
         opts = ("peq", "geq", "teq")
-        if not isinstance(val, str) and val not in opts:
+        if val not in opts:
-            raise XAirRemoteError(f"mode is a string parameter, expected one of {opts}")
+            self.logger.warning(f"mode got {val}, expected one of {opts}")
         self.setter("mode", opts.index(val))
 
     class EQBand:
         def __init__(self, i, remote, index):
-            if index is None:
+            super(EQ.EQBand, self).__init__(remote, index)
-                super(EQ.EQBand, self).__init__(remote)
-            else:
-                super(EQ.EQBand, self).__init__(remote, index)
             self.i = i
 
         @property
@@ -530,35 +496,45 @@ class EQ:
 
         @type.setter
         def type(self, val: int):
-            if not isinstance(val, int):
+            self.setter("type", val)
-                raise XAirRemoteError("type is an int parameter")
-            self.setter(f"type", val)
 
         @property
         def frequency(self) -> float:
-            retval = log_get(20, 20000, self.getter("f")[0])
+            retval = util.log_get(20, 20000, self.getter("f")[0])
             return round(retval, 1)
 
         @frequency.setter
         def frequency(self, val: float):
-            self.setter("f", log_set(20, 20000, val))
+            if not 20 <= val <= 20000:
+                self.logger.warning(
+                    f"frequency got {val}, expected value in range 20.0 to 20000.0"
+                )
+            self.setter("f", util.log_set(20, 20000, val))
 
         @property
         def gain(self) -> float:
-            return round(lin_get(-15, 15, self.getter("g")[0]), 1)
+            return round(util.lin_get(-15, 15, self.getter("g")[0]), 1)
 
         @gain.setter
         def gain(self, val: float):
-            self.setter("g", lin_set(-15, 15, val))
+            if not -15 <= val <= 15:
+                self.logger.warning(
+                    f"gain got {val}, expected value in range -15.0 to 15.0"
+                )
+            self.setter("g", util.lin_set(-15, 15, val))
 
         @property
         def quality(self) -> float:
-            retval = log_get(0.3, 10, self.getter("q")[0])
+            retval = util.log_get(0.3, 10, self.getter("q")[0])
             return round(retval, 1)
 
         @quality.setter
         def quality(self, val: float):
-            self.setter("q", log_set(0.3, 10, val))
+            if not 0.3 <= val <= 10:
+                self.logger.warning(
+                    f"quality got {val}, expected value in range 0.3 to 10.0"
+                )
+            self.setter("q", util.log_set(0.3, 10, val))
 
 
 class GEQ:
@@ -573,7 +549,7 @@ class GEQ:
                     f"slider_{param}": geq_prop(param)
                     for param in [
                         "20", "25", "31_5", "40", "50", "63", "80", "100", "125",
-                        "160", "200", "250", "315" "400", "500", "630", "800", "1k",
+                        "160", "200", "250", "315", "400", "500", "630", "800", "1k",
                         "1k25", "1k6", "2k", "2k5", "3k15", "4k", "5k", "6k3", "8k",
                         "10k", "12k5", "16k", "20k",
                     ]
@@ -600,18 +576,17 @@ class Mix:
 
     @on.setter
     def on(self, val: bool):
-        if not isinstance(val, bool):
-            raise XAirRemoteError("on is a boolean parameter")
         self.setter("on", 1 if val else 0)
 
     @property
+    @util.db_from
     def fader(self) -> float:
-        retval = self.getter("fader")[0]
+        return self.getter("fader")[0]
-        return _get_fader_val(retval)
 
     @fader.setter
+    @util.db_to
     def fader(self, val: float):
-        _set_fader_val(self, val)
+        self.setter("fader", val)
 
     @property
     def lr(self) -> bool:
@@ -619,8 +594,6 @@ class Mix:
 
     @lr.setter
     def lr(self, val: bool):
-        if not isinstance(val, bool):
-            raise XAirRemoteError("lr is a boolean parameter")
         self.setter("lr", 1 if val else 0)
 
 
@@ -636,8 +609,6 @@ class Group:
 
     @dca.setter
     def dca(self, val: int):
-        if not isinstance(val, int):
-            raise XAirRemoteError("dca is an int parameter")
         self.setter("dca", val)
 
     @property
@@ -646,8 +617,6 @@ class Group:
 
     @mute.setter
     def mute(self, val: int):
-        if not isinstance(val, int):
-            raise XAirRemoteError("mute is an int parameter")
         self.setter("mute", val)
 
 
@@ -663,18 +632,42 @@ class Automix:
 
     @group.setter
     def group(self, val: int):
-        if not isinstance(val, int):
-            raise XAirRemoteError("group is an int parameter")
         self.setter("group", val)
 
     @property
     def weight(self) -> float:
-        return round(lin_get(-12, 12, self.getter("weight")[0]), 1)
+        return round(util.lin_get(-12, 12, self.getter("weight")[0]), 1)
 
     @weight.setter
     def weight(self, val: float):
-        if not isinstance(val, float):
+        if not -12 <= val <= 12:
-            raise XAirRemoteError(
+            self.logger.warning(
-                "weight is a float parameter, expected value in range -12 to 12"
+                f"weight got {val}, expected value in range -12.0 to 12.0"
             )
-        self.setter("weight", lin_set(-12, 12, val))
+        self.setter("weight", util.lin_set(-12, 12, val))
+
+
+class Send:
+    def __init__(self, i, remote, index: Optional[int] = None):
+        super(Send, self).__init__(remote, index)
+        self.i = i + 1
+
+    @classmethod
+    def make(cls, _cls, i, remote, index=None):
+        SEND_cls = type("Send", (cls, _cls), {})
+        return SEND_cls(i, remote, index)
+
+    @property
+    def address(self) -> str:
+        root = super(Send, self).address
+        return f"{root}/mix/{str(self.i).zfill(2)}"
+
+    @property
+    @util.db_from
+    def level(self) -> float:
+        return self.getter("level")[0]
+
+    @level.setter
+    @util.db_to
+    def level(self, val: float):
+        self.setter("level", val)

xair_api/strip.py

@@ -1,7 +1,10 @@
 import abc
+import logging
 
-from .errors import XAirRemoteError
+from .meta import mute_prop
-from .shared import EQ, GEQ, Automix, Config, Dyn, Gate, Group, Insert, Mix, Preamp
+from .shared import EQ, Automix, Config, Dyn, Gate, Group, Insert, Mix, Preamp, Send
+
+logger = logging.getLogger(__name__)
 
 
 class IStrip(abc.ABC):
@@ -10,10 +13,10 @@ class IStrip(abc.ABC):
     def __init__(self, remote, index: int):
         self._remote = remote
         self.index = index + 1
+        self.logger = logger.getChild(self.__class__.__name__)
 
     def getter(self, param: str) -> tuple:
-        self._remote.send(f"{self.address}/{param}")
+        return self._remote.query(f"{self.address}/{param}")
-        return self._remote.info_response
 
     def setter(self, param: str, val: int):
         self._remote.send(f"{self.address}/{param}", val)
@@ -35,6 +38,7 @@ class Strip(IStrip):
 
         Returns a Strip class of a kind.
         """
+
         STRIP_cls = type(
             f"Strip{remote.kind}",
             (cls,),
@@ -55,6 +59,11 @@ class Strip(IStrip):
                         Automix,
                     )
                 },
+                "send": tuple(
+                    Send.make(cls, i, remote, index)
+                    for i in range(remote.kind.num_bus + remote.kind.num_fx)
+                ),
+                "mute": mute_prop(),
             },
         )
         return STRIP_cls(remote, index)

xair_api/util.py

@@ -1,5 +1,35 @@
+import functools
+import time
 from math import exp, log
 
+from .errors import XAirRemoteConnectionTimeoutError
+
+
+def timeout(func):
+    """
+    Times out the validate_connection function once time elapsed exceeds remote.connect_timeout.
+    """
+
+    @functools.wraps(func)
+    def wrapper(*args, **kwargs):
+        remote, *_ = args
+
+        err = None
+        start = time.time()
+        while time.time() < start + remote.connect_timeout:
+            try:
+                func(*args, **kwargs)
+                remote.logger.debug(f"login time: {round(time.time() - start, 2)}")
+                err = None
+                break
+            except XAirRemoteConnectionTimeoutError as e:
+                err = e
+                continue
+        if err:
+            raise err
+
+    return wrapper
+
 
 def lin_get(min, max, val):
     return min + (max - min) * val
@@ -17,61 +47,48 @@ def log_set(min, max, val):
     return log(val / min) / log(max / min)
 
 
-def _get_fader_val(retval):
+def db_from(func):
-    if retval >= 1:
+    """fader|level converter for getters"""
-        return 10
+
-    elif retval >= 0.5:
+    @functools.wraps(func)
-        return round((40 * retval) - 30, 1)
+    def wrapper(*args, **kwargs):
-    elif retval >= 0.25:
+        retval = func(*args, **kwargs)
-        return round((80 * retval) - 50, 1)
+
-    elif retval >= 0.0625:
+        if retval >= 1:
-        return round((160 * retval) - 70, 1)
+            return 10
-    elif retval >= 0:
+        elif retval >= 0.5:
-        return round((480 * retval) - 90, 1)
+            return round((40 * retval) - 30, 1)
-    else:
+        elif retval >= 0.25:
-        return -90
+            return round((80 * retval) - 50, 1)
+        elif retval >= 0.0625:
+            return round((160 * retval) - 70, 1)
+        elif retval >= 0:
+            return round((480 * retval) - 90, 1)
+        else:
+            return -90
+
+    return wrapper
 
 
-def _set_fader_val(self, val):
+def db_to(func):
-    if val >= 10:
+    """fader|level converter for setters"""
-        self.setter("fader", 1)
-    elif val >= -10:
-        self.setter("fader", (val + 30) / 40)
-    elif val >= -30:
-        self.setter("fader", (val + 50) / 80)
-    elif val >= -60:
-        self.setter("fader", (val + 70) / 160)
-    elif val >= -90:
-        self.setter("fader", (val + 90) / 480)
-    else:
-        self.setter("fader", 0)
 
+    @functools.wraps(func)
+    def wrapper(*args, **kwargs):
+        param, val = args
+        if val >= 10:
+            val = 1
+        elif val >= -10:
+            val = (val + 30) / 40
+        elif val >= -30:
+            val = (val + 50) / 80
+        elif val >= -60:
+            val = (val + 70) / 160
+        elif val >= -90:
+            val = (val + 90) / 480
+        else:
+            val = 0
 
-def _get_level_val(retval):
+        func(param, val, **kwargs)
-    if retval >= 1:
-        return 10
-    elif retval >= 0.5:
-        return round((40 * retval) - 30, 1)
-    elif retval >= 0.25:
-        return round((80 * retval) - 50, 1)
-    elif retval >= 0.0625:
-        return round((160 * retval) - 70, 1)
-    elif retval >= 0:
-        return round((480 * retval) - 90, 1)
-    else:
-        return -90
 
-
+    return wrapper
-def _set_level_val(self, val):
-    if val >= 10:
-        self.setter("level", 1)
-    elif val >= -10:
-        self.setter("level", (val + 30) / 40)
-    elif val >= -30:
-        self.setter("level", (val + 50) / 80)
-    elif val >= -60:
-        self.setter("level", (val + 70) / 160)
-    elif val >= -90:
-        self.setter("level", (val + 90) / 480)
-    else:
-        self.setter("level", 0)

xair_api/xair.py

@@ -1,8 +1,9 @@
 import abc
+import logging
 import threading
 import time
 from pathlib import Path
-from typing import Optional
+from typing import Optional, Union
 
 try:
     import tomllib
@@ -13,32 +14,32 @@ from pythonosc.dispatcher import Dispatcher
 from pythonosc.osc_message_builder import OscMessageBuilder
 from pythonosc.osc_server import BlockingOSCUDPServer
 
-from . import kinds
+from . import adapter, kinds, util
 from .bus import Bus
 from .config import Config
 from .dca import DCA
-from .errors import XAirRemoteError
+from .errors import XAirRemoteConnectionTimeoutError, XAirRemoteError
-from .fx import FXReturn, FXSend
+from .fx import FX, FXSend
+from .headamp import HeadAmp
 from .kinds import KindMap
 from .lr import LR
-from .rtn import Aux, Rtn
+from .rtn import AuxRtn, FxRtn
 from .strip import Strip
 
+logger = logging.getLogger(__name__)
+
 
 class OSCClientServer(BlockingOSCUDPServer):
     def __init__(self, address: str, dispatcher: Dispatcher):
         super().__init__(("", 0), dispatcher)
         self.xr_address = address
 
-    def send_message(self, address: str, value: str):
+    def send_message(self, address: str, vals: Optional[Union[str, list]]):
         builder = OscMessageBuilder(address=address)
-        if value is None:
+        vals = vals if vals is not None else []
-            values = list()
+        if not isinstance(vals, list):
-        elif isinstance(value, list):
+            vals = [vals]
-            values = value
+        for val in vals:
-        else:
-            values = [value]
-        for val in values:
             builder.add_arg(val)
         msg = builder.build()
         self.socket.sendto(msg.dgram, self.xr_address)
@@ -47,21 +48,18 @@ class OSCClientServer(BlockingOSCUDPServer):
 class XAirRemote(abc.ABC):
     """Handles the communication with the mixer via the OSC protocol"""
 
-    _CONNECT_TIMEOUT = 0.5
+    _info_response = []
-    _WAIT_TIME = 0.025
-    _REFRESH_TIMEOUT = 5
-
-    XAIR_PORT = 10024
-
-    info_response = []
 
     def __init__(self, **kwargs):
         dispatcher = Dispatcher()
         dispatcher.set_default_handler(self.msg_handler)
         self.xair_ip = kwargs["ip"] or self._ip_from_toml()
-        self.xair_port = kwargs["port"] or self.XAIR_PORT
+        self.xair_port = kwargs["port"]
-        if not (self.xair_ip and self.xair_port):
+        self._delay = kwargs["delay"]
-            raise XAirRemoteError("No valid ip or password detected")
+        self.connect_timeout = kwargs["connect_timeout"]
+        self.logger = logger.getChild(self.__class__.__name__)
+        if not self.xair_ip:
+            raise XAirRemoteError("No valid ip detected")
         self.server = OSCClientServer((self.xair_ip, self.xair_port), dispatcher)
 
     def __enter__(self):
@@ -76,29 +74,32 @@ class XAirRemote(abc.ABC):
             conn = tomllib.load(f)
         return conn["connection"].get("ip")
 
+    @util.timeout
     def validate_connection(self):
-        self.send("/xinfo")
+        if not self.query("/xinfo"):
-        time.sleep(self._CONNECT_TIMEOUT)
+            raise XAirRemoteConnectionTimeoutError(self.xair_ip, self.xair_port)
-        if len(self.info_response) > 0:
+        self.logger.info(
-            print(f"Successfully connected to {self.info_response[2]}.")
+            f"Successfully connected to {self.info_response[2]} at {self.info_response[0]}."
-        else:
+        )
-            print(
+
-                "Error: Failed to setup OSC connection to mixer. Please check for correct ip address."
+    @property
-            )
+    def info_response(self):
+        return self._info_response
 
     def run_server(self):
         self.server.serve_forever()
 
     def msg_handler(self, addr, *data):
-        self.info_response = data[:]
+        self.logger.debug(f"received: {addr} {data if data else ''}")
+        self._info_response = data[:]
 
-    def send(self, address: str, param: Optional[str] = None):
+    def send(self, addr: str, param: Optional[str] = None):
-        self.server.send_message(address, param)
+        self.logger.debug(f"sending: {addr} {param if param is not None else ''}")
-        time.sleep(self._WAIT_TIME)
+        self.server.send_message(addr, param)
 
-    def _query(self, address):
+    def query(self, address):
         self.send(address)
-        time.sleep(self._WAIT_TIME)
+        time.sleep(self._delay)
         return self.info_response
 
     def __exit__(self, exc_type, exc_value, exc_tr):
@@ -112,8 +113,37 @@ def _make_remote(kind: KindMap) -> XAirRemote:
     The returned class will subclass XAirRemote.
     """
 
-    def init(self, *args, **kwargs):
+    def init_x32(self, *args, **kwargs):
-        defaultkwargs = {"ip": None, "port": None}
+        defaultkwargs = {
+            "ip": None,
+            "port": 10023,
+            "delay": 0.02,
+            "connect_timeout": 2,
+        }
+        kwargs = defaultkwargs | kwargs
+        XAirRemote.__init__(self, *args, **kwargs)
+        self.kind = kind
+        self.mainst = adapter.MainStereo.make(self)
+        self.mainmono = adapter.MainMono.make(self)
+        self.matrix = tuple(
+            adapter.Matrix.make(self, i) for i in range(kind.num_matrix)
+        )
+        self.strip = tuple(Strip.make(self, i) for i in range(kind.num_strip))
+        self.bus = tuple(adapter.Bus.make(self, i) for i in range(kind.num_bus))
+        self.dca = tuple(DCA(self, i) for i in range(kind.num_dca))
+        self.fx = tuple(FX(self, i) for i in range(kind.num_fx))
+        self.fxreturn = tuple(adapter.FxRtn.make(self, i) for i in range(kind.num_fx))
+        self.auxin = tuple(adapter.AuxRtn.make(self, i) for i in range(kind.num_auxrtn))
+        self.config = Config.make(self)
+        self.headamp = tuple(adapter.HeadAmp(self, i) for i in range(kind.num_headamp))
+
+    def init_xair(self, *args, **kwargs):
+        defaultkwargs = {
+            "ip": None,
+            "port": 10024,
+            "delay": 0.02,
+            "connect_timeout": 2,
+        }
         kwargs = defaultkwargs | kwargs
         XAirRemote.__init__(self, *args, **kwargs)
         self.kind = kind
@@ -121,17 +151,26 @@ def _make_remote(kind: KindMap) -> XAirRemote:
         self.strip = tuple(Strip.make(self, i) for i in range(kind.num_strip))
         self.bus = tuple(Bus.make(self, i) for i in range(kind.num_bus))
         self.dca = tuple(DCA(self, i) for i in range(kind.num_dca))
+        self.fx = tuple(FX(self, i) for i in range(kind.num_fx))
         self.fxsend = tuple(FXSend.make(self, i) for i in range(kind.num_fx))
-        self.fxreturn = tuple(FXReturn(self, i) for i in range(kind.num_fx))
+        self.fxreturn = tuple(FxRtn.make(self, i) for i in range(kind.num_fx))
+        self.auxreturn = AuxRtn.make(self)
         self.config = Config.make(self)
-        self.aux = Aux.make(self)
+        self.headamp = tuple(HeadAmp(self, i) for i in range(kind.num_strip))
-        self.rtn = tuple(Rtn.make(self, i) for i in range(kind.num_rtn))
 
+    if kind.id_ == "X32":
+        return type(
+            f"XAirRemote{kind}",
+            (XAirRemote,),
+            {
+                "__init__": init_x32,
+            },
+        )
     return type(
         f"XAirRemote{kind}",
         (XAirRemote,),
         {
-            "__init__": init,
+            "__init__": init_xair,
         },
     )
 
@@ -145,9 +184,10 @@ def request_remote_obj(kind_id: str, *args, **kwargs) -> XAirRemote:
 
     Returns a reference to an XAirRemote class of a kind
     """
+
     XAIRREMOTE_cls = None
     try:
         XAIRREMOTE_cls = _remotes[kind_id]
-    except ValueError as e:
+    except KeyError as e:
-        raise SystemExit(e)
+        raise XAirRemoteError(f"Unknown mixer kind '{kind_id}'") from e
     return XAIRREMOTE_cls(*args, **kwargs)