Merge pull request #20 from onyx-and-iris/dependabot/pip/virtualenv-20.36.1

Bump virtualenv from 20.28.1 to 20.36.1

.github/workflows/publish.yml

@@ -0,0 +1,53 @@
+name: Publish to PyPI
+
+on:
+  release:
+    types: [published]
+  push:
+    tags:
+      - 'v*.*.*'
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: '3.11'
+
+      - name: Install Poetry
+        run: |
+          pip install poetry==2.3.1
+          poetry --version
+
+      - name: Build package
+        run: |
+          poetry install --only-root
+          poetry build
+
+      - uses: actions/upload-artifact@v4
+        with:
+          name: dist
+          path: ./dist
+
+  pypi-publish:
+    needs: build
+    name: Upload release to PyPI
+    runs-on: ubuntu-latest
+    environment:
+      name: pypi
+      url: https://pypi.org/project/voicemeeter-api/
+    permissions:
+      id-token: write
+    steps:
+      - uses: actions/download-artifact@v4
+        with:
+          name: dist
+          path: ./dist
+
+      - name: Publish package distributions to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          packages-dir: ./dist

.github/workflows/ruff.yml

@@ -0,0 +1,19 @@
+name: Ruff
+
+on:
+  push:
+    branches: [main]
+
+  pull_request:
+    branches: [main]
+
+  workflow_dispatch:
+
+jobs:
+  ruff:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v6
+      - uses: astral-sh/ruff-action@v3
+        with:
+          args: 'format --check --diff'

.gitignore

@@ -128,10 +128,12 @@ dmypy.json
 # Pyre type checker
 .pyre/
 
-# test/config
+# test reports
-quick.py
+tests/reports/
-config.toml
+!tests/reports/badge-*.svg
-vm-api.log
-logging.json
 
-.vscode/
+# test/config
+test-*.py
+config.toml
+
+.vscode/

.pre-commit-config.yaml

@@ -0,0 +1,13 @@
+repos:
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v2.3.0
+    hooks:
+      - id: check-yaml
+      - id: end-of-file-fixer
+      - id: trailing-whitespace
+
+  - repo: https://github.com/python-poetry/poetry
+    rev: '2.3.2'
+    hooks:
+      - id: poetry-check
+      - id: poetry-lock

CHANGELOG.md

@@ -11,6 +11,99 @@ Before any major/minor/patch bump all unit tests will be run to verify they pass
 
 -   [x]
 
+## [2.7.1] - 2025-06-15
+
+### Added
+
+-   Strip.EQ Channel Cell commands added, see [Strip.EQ.Channel.Cell](https://github.com/onyx-and-iris/voicemeeter-api-python?tab=readme-ov-file#stripeqchannelcell)
+    - They are only available for potato version.
+
+-   Bus.EQ Channel Cell commands added, see [Bus.EQ.Channel.Cell](https://github.com/onyx-and-iris/voicemeeter-api-python?tab=readme-ov-file#buseqchannelcell).
+    - Added by [PR #16](https://github.com/onyx-and-iris/voicemeeter-api-python/pull/16)
+
+## [2.6.0] - 2024-06-29
+
+### Added
+
+-   bits kwarg for overriding the type of GUI that is launched on startup.
+    -   Defaults to 64, set it to either 32 or 64.
+
+### Fixed
+
+-   {Remote}.run_voicemeeter() now launches x64 bit GUI's for all kinds if Python detects a 64 bit system.
+
+## [2.5.0] - 2023-10-27
+
+### Fixed
+
+-   {Remote}.login() now has a configurable timeout. Use timeout kwarg to set it. Defaults to 2 seconds.
+-   Remote class section in README updated to include timeout kwarg.
+
+## [2.4.8] - 2023-08-13
+
+### Added
+
+-   Error tests added in tests/test_errors.py
+-   fn_name and code set as class attributes for CAPIError
+-   Errors section in README updated.
+
+### Changed
+
+-   InstallError and CAPIError classes now subclass VMError
+
+## [2.3.7] - 2023-08-01
+
+### Changed
+
+-   If the configs loader is passed an invalid config TOML it will log an error but continue to load further configs into memory.
+
+## [2.3.2] - 2023-07-12
+
+### Added
+
+-   vban.{instream,outstream} tuples now contain classes that represent MIDI and TEXT streams.
+
+### Fixed
+
+-   apply_config() now performs a deep merge when extending a config with another.
+
+## [2.3.0] - 2023-07-11
+
+### Added
+
+-   user configs may now extend other user configs. check `config extends` section in README.
+
+## [2.2.0] - 2023-07-10
+
+### Added
+
+-   CAPIError class now stores fn_name, error code and message as class attributes.
+
+### Changed
+
+-   macrobutton capi calls now use error code -9 on AttributeError (using an old version of the API).
+
+### Fixed
+
+-   call to `self.vm_get_midi_message` now wrapped by {CBindings}.call.
+
+## [2.1.1] - 2023-07-01
+
+### Added
+
+-   RecorderMode added to Recorder class. See Recorder section in README for new properties and methods.
+    -   recorder.loop is now a forwarder method for recorder.mode.loop for backwards compatibility
+
+-   RecorderArmStrip, RecorderArmBus mixed into Recorder class.
+
+### Removed
+
+-   Recorder.loop removed from documentation
+
+### Changed
+
+-   When out of bounds values are passed, log warnings instead of raising Errors. See [Issue #6][Issue 6].
+
 ## [2.0.0] - 2023-06-25
 
 Where possible I've attempted to make the changes backwards compatible. The breaking changes affect two higher classes, Strip and Bus, as well as the behaviour of events. All other changes are additive or QOL aimed at giving more options to the developer. For example, every low-level CAPI call is now logged and error raised on Exception, you can now register callback functions as well as observer classes, extra examples to demonstrate different use cases etc.
@@ -363,3 +456,4 @@ I will move this commit to a separate branch in preparation for version 2.0.
 -   project packaged with poetry and added to pypi.
 
 [issue 4]: https://github.com/onyx-and-iris/voicemeeter-api-python/issues/4
+[Issue 6]: https://github.com/onyx-and-iris/voicemeeter-api-python/issues/6

README.md

@@ -1,10 +1,10 @@
 [![PyPI version](https://badge.fury.io/py/voicemeeter-api.svg)](https://badge.fury.io/py/voicemeeter-api)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://github.com/onyx-and-iris/voicemeeter-api-python/blob/dev/LICENSE)
-[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
+[![Poetry](https://img.shields.io/endpoint?url=https://python-poetry.org/badge/v0.json)](https://python-poetry.org/)
-[![Imports: isort](https://img.shields.io/badge/%20imports-isort-%231674b1?style=flat&labelColor=ef8336)](https://pycqa.github.io/isort/)
+[![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)
-![Tests Status](./tests/basic.svg?dummy=8484744)
+![Tests Status](./tests/reports/badge-basic.svg?dummy=8484744)
-![Tests Status](./tests/banana.svg?dummy=8484744)
+![Tests Status](./tests/reports/badge-banana.svg?dummy=8484744)
-![Tests Status](./tests/potato.svg?dummy=8484744)
+![Tests Status](./tests/reports/badge-potato.svg?dummy=8484744)
 
 # Python Wrapper for Voicemeeter API
 
@@ -14,9 +14,9 @@ For an outline of past/future changes refer to: [CHANGELOG](CHANGELOG.md)
 
 ## Tested against
 
--   Basic 1.0.8.8
+-   Basic 1.1.2.2
--   Banana 2.0.6.8
+-   Banana 2.1.2.2
--   Potato 3.0.2.8
+-   Potato 3.1.2.2
 
 ## Requirements
 
@@ -44,24 +44,24 @@ class ManyThings:
         self.vm = vm
 
     def things(self):
-        self.vm.strip[0].label = "podmic"
+        self.vm.strip[0].label = 'podmic'
         self.vm.strip[0].mute = True
         print(
-            f"strip 0 ({self.vm.strip[0].label}) mute has been set to {self.vm.strip[0].mute}"
+            f'strip 0 ({self.vm.strip[0].label}) mute has been set to {self.vm.strip[0].mute}'
         )
 
     def other_things(self):
         self.vm.bus[3].gain = -6.3
         self.vm.bus[4].eq.on = True
         info = (
-            f"bus 3 gain has been set to {self.vm.bus[3].gain}",
+            f'bus 3 gain has been set to {self.vm.bus[3].gain}',
-            f"bus 4 eq has been set to {self.vm.bus[4].eq.on}",
+            f'bus 4 eq has been set to {self.vm.bus[4].eq.on}',
         )
-        print("\n".join(info))
+        print('\n'.join(info))
 
 
 def main():
-    KIND_ID = "banana"
+    KIND_ID = 'banana'
 
     with voicemeeterlib.api(KIND_ID) as vm:
         do = ManyThings(vm)
@@ -71,18 +71,17 @@ def main():
         # set many parameters at once
         vm.apply(
             {
-                "strip-2": {"A1": True, "B1": True, "gain": -6.0},
+                'strip-2': {'A1': True, 'B1': True, 'gain': -6.0},
-                "bus-2": {"mute": True, "eq": {"on": True}},
+                'bus-2': {'mute': True, 'eq': {'on': True}},
-                "button-0": {"state": True},
+                'button-0': {'state': True},
-                "vban-in-0": {"on": True},
+                'vban-in-0': {'on': True},
-                "vban-out-1": {"name": "streamname"},
+                'vban-out-1': {'name': 'streamname'},
             }
         )
 
 
-if __name__ == "__main__":
+if __name__ == '__main__':
     main()
-
 ```
 
 Otherwise you must remember to call `vm.login()`, `vm.logout()` at the start/end of your code.
@@ -149,8 +148,8 @@ Set mute state as value for the app matching name.
 example:
 
 ```python
-vm.strip[5].appmute("Spotify", True)
+vm.strip[5].appmute('Spotify', True)
-vm.strip[5].appgain("Spotify", 0.5)
+vm.strip[5].appgain('Spotify', 0.5)
 ```
 
 #### Strip.Comp
@@ -226,6 +225,24 @@ example:
 vm.strip[0].eq.ab = True
 ```
 
+##### Strip.EQ.Channel.Cell
+
+The following properties are available.
+
+-   `on`: boolean
+-   `type`: int, from 0 up to 6
+-   `f`: float, from 20.0 up to 20_000.0
+-   `gain`: float, from -36.0 up to 18.0
+    -   currently there is a bug with the remote API, only values -12 up to +12 are settable, this will be fixed in an upcoming patch.
+-   `q`: float, from 0.3 up to 100
+
+example:
+
+```python
+vm.strip[0].eq.channel[0].cell[2].on = True
+vm.strip[1].eq.channel[0].cell[2].f = 5000
+```
+
 Strip EQ parameters are defined for PhysicalStrips, potato version only.
 
 ##### Strip.Gainlayers
@@ -260,7 +277,7 @@ Level properties will return -200.0 if no audio detected.
 
 The following properties are available.
 
--   `mono`: boolean
+-   `mono`: int, from 0 up to 2
 -   `mute`: boolean
 -   `sel`: boolean
 -   `gain`: float, from -60.0 to 12.0
@@ -277,7 +294,7 @@ example:
 vm.bus[3].gain = 3.7
 print(vm.bus[0].label)
 
-vm.bus[4].mono = True
+vm.bus[4].mono = 2
 ```
 
 ##### Bus.EQ
@@ -293,6 +310,24 @@ example:
 vm.bus[3].eq.on = True
 ```
 
+##### Bus.EQ.Channel.Cell
+
+The following properties are available.
+
+-   `on`: boolean
+-   `type`: int, from 0 up to 6
+-   `f`: float, from 20.0 up to 20_000.0
+-   `gain`: float, from -36.0 up to 18.0
+    -   currently there is a bug with the remote API, only values -12 up to +12 are settable, this will be fixed in an upcoming patch.
+-   `q`: float, from 0.3 up to 100.0
+
+example:
+
+```python
+vm.bus[3].eq.channel[0].cell[2].on = True
+vm.bus[3].eq.channel[0].cell[2].f = 5000
+```
+
 ##### Bus.Modes
 
 The following properties are available.
@@ -366,7 +401,7 @@ example:
 
 ```python
 print(vm.strip[0].device.name)
-vm.bus[0].device.asio = "Audient USB Audio ASIO Driver"
+vm.bus[0].device.asio = 'Audient USB Audio ASIO Driver'
 ```
 
 strip|bus device parameters are defined for physical channels only.
@@ -398,13 +433,19 @@ The following methods are available
 -   `record()`
 -   `ff()`
 -   `rew()`
--   `load(<filepath>)`: string
+-   `load(filepath)`: raw string
+-   `goto(time_string)`: time string in format `hh:mm:ss`
+-   `filetype(filetype)`: string, ("wav", "aiff", "bwf", "mp3")
 
 The following properties are available
 
--   `loop`: boolean
 -   `A1 - A5`: boolean
--   `B1 - A3`: boolean
+-   `B1 - B3`: boolean
+-   `samplerate`: int, (22050, 24000, 32000, 44100, 48000, 88200, 96000, 176400, 192000)
+-   `bitresolution`: int, (8, 16, 24, 32)
+-   `channel`: int, from 1 to 8
+-   `kbps`: int, (32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320)
+-   `gain`: float, from -60.0 to 12.0
 
 example:
 
@@ -412,17 +453,46 @@ example:
 vm.recorder.play()
 vm.recorder.stop()
 
-# Enable loop play
-vm.recorder.loop = True
-
 # Disable recorder out channel B2
 vm.recorder.B2 = False
 
 # filepath as raw string
 vm.recorder.load(r'C:\music\mytune.mp3')
+
+# set the goto time to 1m 30s
+vm.recorder.goto('00:01:30')
 ```
 
-Recorder properties are defined as write only.
+#### Recorder.Mode
+
+The following properties are available
+
+-   `recbus`: boolean
+-   `playonload`: boolean
+-   `loop`: boolean
+-   `multitrack`: boolean
+
+example:
+
+```python
+# Enable loop play
+vm.recorder.mode.loop = True
+```
+
+#### Recorder.ArmStrip[i]|ArmBus[i]
+
+The following method is available
+
+-   `set(val)`: boolean
+
+example:
+
+```python
+# Arm strip 3
+vm.recorder.armstrip[3].set(True)
+# Arm bus 0
+vm.recorder.armbus[0].set(True)
+```
 
 ### VBAN
 
@@ -594,7 +664,9 @@ vm.option.sr = 48000
 
 The following methods are available:
 
--   `buffer(driver, buffer)` : Set buffer size for particular audio driver.
+-   `buffer(driver, buf)` : Set buffer size for particular audio driver.
+    -   buf: int, from 128 to 2048
+    -   driver:str, ("mme", "wdm", "ks", "asio")
 
 example:
 
@@ -602,10 +674,6 @@ example:
 vm.option.buffer("wdm", 512)
 ```
 
-driver defined as one of ("mme", "wdm", "ks", "asio")
-
-buffer, from 128 to 2048
-
 ##### delay[i]
 
 -   `get()`: int
@@ -646,11 +714,11 @@ get() may return None if no value for requested key in midi cache
 ```python
 vm.apply(
     {
-        "strip-2": {"A1": True, "B1": True, "gain": -6.0},
+        'strip-2': {'A1': True, 'B1': True, 'gain': -6.0},
-        "bus-2": {"mute": True, "eq": {"on": True}},
+        'bus-2': {'mute': True, 'eq': {'on': True}},
-        "button-0": {"state": True},
+        'button-0': {'state': True},
-        "vban-in-0": {"on": True},
+        'vban-in-0': {'on': True},
-        "vban-out-1": {"name": "streamname"},
+        'vban-out-1': {'name': 'streamname'},
     }
 )
 ```
@@ -658,17 +726,17 @@ vm.apply(
 Or for each class you may do:
 
 ```python
-vm.strip[0].apply(mute: True, gain: 3.2, A1: True)
+vm.strip[0].apply({'mute': True, 'gain': 3.2, 'A1': True})
-vm.vban.outstream[0].apply(on: True, name: 'streamname', bit: 24)
+vm.vban.outstream[0].apply({'on': True, 'name': 'streamname', 'bit': 24})
 ```
 
 ## Config Files
 
-`vm.apply_config(<configname>)`
+`vm.apply_config(configname)`
 
 You may load config files in TOML format.
 Three example configs have been included with the package. Remember to save
-current settings before loading a user config. To set one you may do:
+current settings before loading a user config. To load one you may do:
 
 ```python
 import voicemeeterlib
@@ -676,7 +744,26 @@ with voicemeeterlib.api('banana') as vm:
     vm.apply_config('example')
 ```
 
-will load a user config file at configs/banana/example.toml for Voicemeeter Banana.
+Your configs may be located in one of the following paths:
+-   \<current working directory\> / "configs" / kind_id
+-   \<user home directory\> / ".config" / "voicemeeter" / kind_id
+-   \<user home directory\> / "Documents" / "Voicemeeter" / "configs" / kind_id
+
+If a config with the same name is located in multiple locations, only the first one found is loaded into memory, in the above order.
+
+#### `config extends`
+
+You may also load a config that extends another config with overrides or additional parameters.
+
+You just need to define a key `extends` in the config TOML, that names the config to be extended.
+
+Three example 'extender' configs are included with the repo. You may load them with:
+
+```python
+import voicemeeterlib
+with voicemeeterlib.api('banana') as vm:
+    vm.apply_config('extender')
+```
 
 ## Events
 
@@ -688,7 +775,7 @@ example:
 import voicemeeterlib
 # Set event updates to occur every 50ms
 # Listen for level updates only
-with voicemeeterlib.api('banana', ratelimit=0.05, ldirty=True}) as vm:
+with voicemeeterlib.api('banana', ratelimit=0.05, ldirty=True) as vm:
     ...
 ```
 
@@ -741,7 +828,7 @@ The following methods are available:
 example:
 
 ```python
-vm.event.remove(["pdirty", "mdirty", "midi"])
+vm.event.remove(['pdirty', 'mdirty', 'midi'])
 
 # get a list of currently subscribed
 print(vm.event.get())
@@ -759,6 +846,8 @@ You may pass the following optional keyword arguments:
 -   `mdirty`: boolean=False, macrobutton updates
 -   `midi`: boolean=False, midi updates
 -   `ldirty`: boolean=False, level updates
+-   `timeout`: float=2.0, maximum time to wait for a successful login in seconds
+-   `bits`: int=64, (may be one of 32 or 64), overrides the type of Voicemeeter GUI {Remote}.run_voicemeeter() will launch
 
 Access to lower level Getters and Setters are provided with these functions:
 
@@ -775,27 +864,58 @@ vm.set('Strip[0].Gain', -3.6)
 
 Access to lower level polling functions are provided with the following property objects:
 
-#### `vm.pdirty`
+##### `vm.pdirty`
 
 True iff a parameter has been updated.
 
-#### `vm.mdirty`
+##### `vm.mdirty`
 
 True iff a macrobutton has been updated.
 
-#### `vm.ldirty`
+##### `vm.ldirty`
 
 True iff a level has been updated.
 
 
+### Errors
+
+-   `errors.VMError`: Base custom exception class.
+-   `errors.InstallError`: Exception raised when installation errors occur.
+-   `errors.CAPIError`: Exception raised when the C-API returns error values.
+    -   The following attributes are available:
+        -   `fn_name`: C-API function name.
+        -   `code`: error code
+    -   For a full list of error codes check the [VoicemeeterRemote header file][Voicemeeter Remote Header].
+
+
+### Logging
+
+It's possible to see the messages sent by the interface's setters and getters, may be useful for debugging.
+
+example:
+```python
+import voicemeeterlib
+
+logging.basicConfig(level=logging.DEBUG)
+
+with voicemeeterlib.api('banana') as vm:
+    ...
+```
+
+
 ### Run tests
 
-To run all tests:
+Install [poetry](https://python-poetry.org/docs/#installation) and then:
 
-```
+```powershell
-pytest -v
+poetry poe test-basic
+poetry poe test-banana
+poetry poe test-potato
 ```
 
 ### Official Documentation
 
--   [Voicemeeter Remote C API](https://github.com/onyx-and-iris/Voicemeeter-SDK/blob/update-docs/VoicemeeterRemoteAPI.pdf)
+-   [Voicemeeter Remote C API](https://github.com/onyx-and-iris/Voicemeeter-SDK/blob/main/VoicemeeterRemoteAPI.pdf)
+
+
+[Voicemeeter Remote Header]: https://github.com/onyx-and-iris/Voicemeeter-SDK/blob/main/VoicemeeterRemote.h

__main__.py

@@ -6,24 +6,24 @@ class ManyThings:
         self.vm = vm
 
     def things(self):
-        self.vm.strip[0].label = "podmic"
+        self.vm.strip[0].label = 'podmic'
         self.vm.strip[0].mute = True
         print(
-            f"strip 0 ({self.vm.strip[0].label}) mute has been set to {self.vm.strip[0].mute}"
+            f'strip 0 ({self.vm.strip[0].label}) mute has been set to {self.vm.strip[0].mute}'
         )
 
     def other_things(self):
         self.vm.bus[3].gain = -6.3
         self.vm.bus[4].eq.on = True
         info = (
-            f"bus 3 gain has been set to {self.vm.bus[3].gain}",
+            f'bus 3 gain has been set to {self.vm.bus[3].gain}',
-            f"bus 4 eq has been set to {self.vm.bus[4].eq.on}",
+            f'bus 4 eq has been set to {self.vm.bus[4].eq.on}',
         )
-        print("\n".join(info))
+        print('\n'.join(info))
 
 
 def main():
-    KIND_ID = "banana"
+    KIND_ID = 'banana'
 
     with voicemeeterlib.api(KIND_ID) as vm:
         do = ManyThings(vm)
@@ -33,14 +33,14 @@ def main():
         # set many parameters at once
         vm.apply(
             {
-                "strip-2": {"A1": True, "B1": True, "gain": -6.0},
+                'strip-2': {'A1': True, 'B1': True, 'gain': -6.0},
-                "bus-2": {"mute": True, "eq": {"on": True}},
+                'bus-2': {'mute': True, 'eq': {'on': True}},
-                "button-0": {"state": True},
+                'button-0': {'state': True},
-                "vban-in-0": {"on": True},
+                'vban-in-0': {'on': True},
-                "vban-out-1": {"name": "streamname"},
+                'vban-out-1': {'name': 'streamname'},
             }
         )
 
 
-if __name__ == "__main__":
+if __name__ == '__main__':
     main()

configs/banana/extender.toml

@@ -0,0 +1,12 @@
+extends = "example"
+[strip-0]
+label = "strip0_extended"
+A1 = false
+gain = 0.0
+
+[bus-0]
+label = "bus0_extended"
+mute = false
+
+[vban-in-3]
+name = "vban_extended"

configs/basic/extender.toml

@@ -0,0 +1,12 @@
+extends = "example"
+[strip-0]
+label = "strip0_extended"
+A1 = false
+gain = 0.0
+
+[bus-0]
+label = "bus0_extended"
+mute = false
+
+[vban-in-3]
+name = "vban_extended"

configs/potato/extender.toml

@@ -0,0 +1,12 @@
+extends = "example"
+[strip-0]
+label = "strip0_extended"
+A1 = false
+gain = 0.0
+
+[bus-0]
+label = "bus0_extended"
+mute = false
+
+[vban-in-3]
+name = "vban_extended"

examples/dsl/__main__.py

@@ -1,6 +1,8 @@
 import argparse
 import logging
 import time
+from abc import ABC, abstractmethod
+from enum import IntEnum
 
 from pyparsing import (
     Combine,
@@ -10,26 +12,90 @@ from pyparsing import (
     Suppress,
     Word,
     alphanums,
-    alphas,
     nums,
 )
 
 import voicemeeterlib
 
-logging.basicConfig(level=logging.INFO)
+logging.basicConfig(level=logging.DEBUG)
-argparser = argparse.ArgumentParser(description="creates a basic dsl")
+logger = logging.getLogger(__name__)
-argparser.add_argument("-i", action="store_true")
+
+
+argparser = argparse.ArgumentParser(description='creates a basic dsl')
+argparser.add_argument('-i', action='store_true')
 args = argparser.parse_args()
 
 
+ParamKinds = IntEnum(
+    'ParamKinds',
+    'bool float string',
+)
+
+
+class Strategy(ABC):
+    def __init__(self, target, param, val):
+        self.target = target
+        self.param = param
+        self.val = val
+
+    @abstractmethod
+    def run(self):
+        pass
+
+
+class BoolStrategy(Strategy):
+    def run(self):
+        setattr(self.target, self.param, self.strtobool(self.val))
+
+    def strtobool(self, val):
+        """Convert a string representation of truth to it's numeric form."""
+
+        val = val.lower()
+        if val in ('y', 'yes', 't', 'true', 'on', '1'):
+            return 1
+        elif val in ('n', 'no', 'f', 'false', 'off', '0'):
+            return 0
+        else:
+            raise ValueError('invalid truth value %r' % (val,))
+
+
+class FloatStrategy(Strategy):
+    def run(self):
+        setattr(self.target, self.param, float(self.val))
+
+
+class StringStrategy(Strategy):
+    def run(self):
+        setattr(self.target, self.param, ' '.join(self.val))
+
+
+class Context:
+    def __init__(self, strategy: Strategy) -> None:
+        self._strategy = strategy
+
+    @property
+    def strategy(self) -> Strategy:
+        return self._strategy
+
+    @strategy.setter
+    def strategy(self, strategy: Strategy) -> None:
+        self._strategy = strategy
+
+    def run(self):
+        self.strategy.run()
+
+
 class Parser:
+    IS_STRING = ('label',)
+
     def __init__(self, vm):
+        self.logger = logger.getChild(self.__class__.__name__)
         self.vm = vm
         self.kls = Group(OneOrMore(Word(alphanums)))
-        self.token = Suppress("->")
+        self.token = Suppress('->')
-        self.param = Word(alphanums)
+        self.param = Group(OneOrMore(Word(alphanums)))
         self.value = Combine(
-            Optional("-") + Word(nums) + Optional(".") + Optional(Word(nums))
+            Optional('-') + Word(nums) + Optional('.') + Optional(Word(nums))
         ) | Group(OneOrMore(Word(alphanums)))
         self.event = (
             self.kls
@@ -39,32 +105,68 @@ class Parser:
             + Optional(self.value)
         )
 
-    def parse(self, cmds):
+    def converter(self, cmds):
+        """determines the kind of parameter from the parsed string"""
+
         res = list()
-
         for cmd in cmds:
-            if len(self.event.parseString(cmd)) == 2:
+            self.logger.debug(f'running command: {cmd}')
-                kls, param = self.event.parseString(cmd)
+            match cmd_parsed := self.event.parseString(cmd):
-                target = getattr(self.vm, kls[0])[int(kls[-1])]
+                case [[kls, index], [param]]:
-                res.append(getattr(target, param))
+                    target = getattr(self.vm, kls)[int(index)]
-            elif len(self.event.parseString(cmd)) == 3:
+                    res.append(getattr(target, param))
-                kls, param, val = self.event.parseString(cmd)
+                case [[kls, index], [param], val] if param in self.IS_STRING:
-                target = getattr(self.vm, kls[0])[int(kls[-1])]
+                    target = getattr(self.vm, kls)[int(index)]
-                if "".join(val) in ["off", "on"]:
+                    context = self._get_context(ParamKinds.string, target, param, val)
-                    setattr(target, param, bool(["off", "on"].index("".join(val))))
+                    context.run()
-                elif param in ["gain", "comp", "gate", "limit", "audibility"]:
+                case [[kls, index], [param], [val] | val]:
-                    setattr(target, param, float("".join(val)))
+                    target = getattr(self.vm, kls)[int(index)]
-                elif param in ["label"]:
+                    try:
-                    setattr(target, param, " ".join(val))
+                        context = self._get_context(ParamKinds.bool, target, param, val)
-
+                        context.run()
+                    except ValueError as e:
+                        self.logger.error(f'{e}... switching to float strategy')
+                        context.strategy = FloatStrategy(target, param, val)
+                        context.run()
+                case [
+                    [kls, index],
+                    [secondary, param],
+                    [val]
+                    | val,
+                ]:
+                    primary = getattr(self.vm, kls)[int(index)]
+                    target = getattr(primary, secondary)
+                    try:
+                        context = self._get_context(ParamKinds.bool, target, param, val)
+                        context.run()
+                    except ValueError as e:
+                        self.logger.error(f'{e}... switching to float strategy')
+                        context.strategy = FloatStrategy(target, param, val)
+                        context.run()
+                case _:
+                    self.logger.error(
+                        f'unable to determine the kind of parameter from {cmd_parsed}'
+                    )
             time.sleep(0.05)
         return res
 
+    def _get_context(self, kind, *args):
+        """
+        determines a strategy for a kind of parameter and passes it to the context.
+        """
+
+        match kind:
+            case ParamKinds.bool:
+                context = Context(BoolStrategy(*args))
+            case ParamKinds.float:
+                context = Context(FloatStrategy(*args))
+            case ParamKinds.string:
+                context = Context(StringStrategy(*args))
+        return context
+
 
 def interactive_mode(parser):
-    while cmd := input("Please enter command (Press <Enter> to exit)\n"):
+    while cmd := input('Please enter command (Press <Enter> to exit)\n'):
-        if not cmd:
-            break
         if res := parser.parse((cmd,)):
             print(res)
 
@@ -72,27 +174,25 @@ def interactive_mode(parser):
 def main():
     # fmt: off
     cmds = (
-        "strip 0 -> mute -> on", "strip 0 -> mute", "bus 0 -> mute -> on",
+        "strip 0 -> mute -> true", "strip 0 -> mute", "bus 0 -> mute -> true",
-        "strip 0 -> mute -> off", "bus 0 -> mute -> on", "strip 3 -> solo -> on",
+        "strip 0 -> mute -> false", "bus 0 -> mute -> true", "strip 3 -> solo -> true",
-        "strip 3 -> solo -> off", "strip 1 -> A1 -> on", "strip 1 -> A1",
+        "strip 3 -> solo -> false", "strip 1 -> A1 -> true", "strip 1 -> A1",
-        "strip 1 -> A1 -> off", "strip 1 -> A1", "bus 3 -> eq -> on",
+        "strip 1 -> A1 -> false", "strip 1 -> A1", "strip 3 -> eq on -> true",
-        "bus 3 -> eq -> off", "strip 4 -> gain -> 1.2", "strip 0 -> gain -> -8.2",
+        "bus 3 -> eq on -> false", "strip 4 -> gain -> 1.2", "strip 0 -> gain -> -8.2",
         "strip 0 -> gain", "strip 1 -> label -> rode podmic", "strip 2 -> limit -> -28",
-        "strip 2 -> limit",
+        "strip 2 -> limit", "strip 3 -> comp knob -> 3.8"
     )
     # fmt: on
 
-    KIND_ID = "banana"
+    with voicemeeterlib.api('potato') as vm:
-
-    with voicemeeterlib.api(KIND_ID) as vm:
         parser = Parser(vm)
         if args.i:
             interactive_mode(parser)
             return
 
-        if res := parser.parse(cmds):
+        if res := parser.converter(cmds):
             print(res)
 
 
-if __name__ == "__main__":
+if __name__ == '__main__':
     main()

examples/eq_edit/README.md

@@ -0,0 +1,9 @@
+## About
+
+The purpose of this script is to demonstratehow to utilize the channels and cells that are available as part of the EQ. It should take audio playing in the second virtual strip and then apply a LGF on the first physical at 500 Hz.
+
+## Use
+
+Configured for banana version.
+
+Make sure you are playing audio into the second virtual strip and out of the first physical bus, both channels are unmuted and that you aren't monitoring another mixbus. Then run the script.

examples/eq_edit/__main__.py

@@ -0,0 +1,50 @@
+import time
+
+import voicemeeterlib
+
+
+def main():
+    KIND_ID = 'banana'
+    BUS_INDEX = 0  # Index of the bus to edit, can be changed as needed
+    CHANNEL_INDEX = 0  # Index of the channel to edit, can be changed as needed
+
+    with voicemeeterlib.api(KIND_ID) as vm:
+        print(f'Bus[{BUS_INDEX}].EQ.on: {vm.bus[BUS_INDEX].eq.on}')
+        print(
+            f'Bus[{BUS_INDEX}].EQ.channel[{CHANNEL_INDEX}].cell[0].on: {vm.bus[BUS_INDEX].eq.channel[CHANNEL_INDEX].cell[0].on}'
+        )
+
+        print('Check sending commands (should affect your VM Banana window)')
+
+        vm.bus[BUS_INDEX].eq.on = True
+        vm.bus[BUS_INDEX].eq.ab = 0  # corresponds to A EQ memory slot
+        vm.bus[BUS_INDEX].mute = False
+
+        for j, cell in enumerate(vm.bus[BUS_INDEX].eq.channel[CHANNEL_INDEX].cell):
+            cell.on = True
+            cell.f = 500
+            cell.gain = -10
+            cell.type = 3  # Should correspond to LPF
+            cell.q = 10
+
+            print(
+                f'Channel {CHANNEL_INDEX}, Cell {j}: on={cell.on}, f={cell.f}, type={cell.type}, gain={cell.gain}, q={cell.q}'
+            )
+
+            time.sleep(1)  # Sleep to simulate processing time
+
+            cell.on = False
+            cell.f = 50
+            cell.gain = 0
+            cell.type = 0
+            cell.q = 3
+
+            print(
+                f'Channel {CHANNEL_INDEX}, Cell {j}: on={cell.on}, f={cell.f}, type={cell.type} , gain={cell.gain}, q={cell.q}'
+            )
+
+        vm.bus[BUS_INDEX].eq.on = False
+
+
+if __name__ == '__main__':
+    main()

examples/events/README.md

@@ -1,33 +1,8 @@
-## About
+# Events
 
-This script demonstrates how to interact with the event thread/event object. It also demonstrates how to register event specific callbacks.
+If you want to receive updates on certain events there are two routes you can take:
 
-By default the interface does not broadcast any events. So even though our callbacks are registered, and the event thread has been initiated, we won't receive updates.
+-   Register a class that implements an `on_update(self, event) -> None` method on the `{Remote}.subject` class.
+-   Register callback functions/methods on the `{Remote}.subject` class, one for each type of update.
 
-After five seconds the event object is used to subscribe to all events for a total of thirty seconds.
+Included are examples of both approaches.
-
-Remember that events can also be unsubscribed to with `vm.event.remove()`. Callbacks can also be deregistered using vm.observer.remove().
-
-The same can be done without a context manager:
-
-```python
-    vm = voicemeeterlib.api(KIND_ID)
-    vm.login()
-    vm.observer.add(on_midi)    # register an `on_midi` callback function
-    vm.init_thread()
-    vm.event.add("midi")    # in this case we only subscribe to midi events.
-    ...
-    vm.end_thread()
-    vm.logout()
-```
-
-Once initialized, the event thread will continously run until end_thread() is called. Even if all events are unsubscribed to.
-
-## Use
-
-Simply run the script and trigger events and you should see the output after 5 seconds. To trigger events do the following:
-
--   change GUI parameters to trigger pdirty
--   press any macrobutton to trigger mdirty
--   play audio through any bus to trigger ldirty
--   any midi input to trigger midi

examples/events/callbacks/README.md

@@ -0,0 +1,33 @@
+## About
+
+This script demonstrates how to interact with the event thread/event object. It also demonstrates how to register event specific callbacks.
+
+By default the interface does not broadcast any events. So even though our callbacks are registered, and the event thread has been initiated, we won't receive updates.
+
+After five seconds the event object is used to subscribe to all events for a total of thirty seconds.
+
+Remember that events can also be unsubscribed to with `vm.event.remove()`. Callbacks can also be deregistered using vm.observer.remove().
+
+The same can be done without a context manager:
+
+```python
+    vm = voicemeeterlib.api(KIND_ID)
+    vm.login()
+    vm.observer.add(on_midi)    # register an `on_midi` callback function
+    vm.init_thread()
+    vm.event.add("midi")    # in this case we only subscribe to midi events.
+    ...
+    vm.end_thread()
+    vm.logout()
+```
+
+Once initialized, the event thread will continously run until end_thread() is called. Even if all events are unsubscribed to.
+
+## Use
+
+Simply run the script and trigger events and you should see the output after 5 seconds. To trigger events do the following:
+
+-   change GUI parameters to trigger pdirty
+-   press any macrobutton to trigger mdirty
+-   play audio through any bus to trigger ldirty
+-   any midi input to trigger midi

examples/events/callbacks/__main__.py

@@ -1,7 +1,5 @@
-import json
 import logging
 import time
-from logging import config
 
 import voicemeeterlib
 
@@ -10,45 +8,46 @@ logging.basicConfig(level=logging.INFO)
 
 class App:
     def __init__(self, vm):
-        self.vm = vm
+        self._vm = vm
         # register the callbacks for each event
-        self.vm.observer.add(
+        self._vm.observer.add(
             [self.on_pdirty, self.on_mdirty, self.on_ldirty, self.on_midi]
         )
 
     def __enter__(self):
-        self.vm.init_thread()
+        self._vm.init_thread()
+        return self
 
     def __exit__(self, exc_type, exc_value, traceback):
-        self.vm.end_thread()
+        self._vm.end_thread()
 
     def on_pdirty(self):
-        print("pdirty!")
+        print('pdirty!')
 
     def on_mdirty(self):
-        print("mdirty!")
+        print('mdirty!')
 
     def on_ldirty(self):
-        for bus in self.vm.bus:
+        for bus in self._vm.bus:
             if bus.levels.isdirty:
                 print(bus, bus.levels.all)
 
     def on_midi(self):
-        current = self.vm.midi.current
+        current = self._vm.midi.current
-        print(f"Value of midi button {current} is {self.vm.midi.get(current)}")
+        print(f'Value of midi button {current} is {self._vm.midi.get(current)}')
 
 
 def main():
-    KIND_ID = "banana"
+    KIND_ID = 'banana'
 
     with voicemeeterlib.api(KIND_ID) as vm:
-        with App(vm) as app:
+        with App(vm):
             for i in range(5, 0, -1):
-                print(f"events start in {i} seconds")
+                print(f'events start in {i} seconds')
                 time.sleep(1)
-            vm.event.add(["pdirty", "ldirty", "midi", "mdirty"])
+            vm.event.add(['pdirty', 'ldirty', 'midi', 'mdirty'])
             time.sleep(30)
 
 
-if __name__ == "__main__":
+if __name__ == '__main__':
     main()

examples/events/observer/__main__.py

@@ -0,0 +1,45 @@
+import logging
+
+import voicemeeterlib
+
+logging.basicConfig(level=logging.INFO)
+
+
+class App:
+    def __init__(self, vm):
+        self._vm = vm
+        # register your app as event observer
+        self._vm.observer.add(self)
+
+    def __str__(self):
+        return type(self).__name__
+
+    # define an 'on_update' callback function to receive event updates
+    def on_update(self, event):
+        if event == 'pdirty':
+            print('pdirty!')
+        elif event == 'mdirty':
+            print('mdirty!')
+        elif event == 'ldirty':
+            for bus in self._vm.bus:
+                if bus.levels.isdirty:
+                    print(bus, bus.levels.all)
+        elif event == 'midi':
+            current = self._vm.midi.current
+            print(f'Value of midi button {current} is {self._vm.midi.get(current)}')
+
+
+def main():
+    KIND_ID = 'banana'
+
+    with voicemeeterlib.api(
+        KIND_ID, **{k: True for k in ('pdirty', 'mdirty', 'ldirty', 'midi')}
+    ) as vm:
+        App(vm)
+
+        while _ := input('Press <Enter> to exit\n'):
+            pass
+
+
+if __name__ == '__main__':
+    main()

examples/gui/__main__.py

@@ -1,10 +1,10 @@
 import logging
+import tkinter as tk
+from tkinter import ttk
 
 import voicemeeterlib
 
 logging.basicConfig(level=logging.DEBUG)
-import tkinter as tk
-from tkinter import ttk
 
 
 class App(tk.Tk):
@@ -12,9 +12,9 @@ class App(tk.Tk):
 
     def __init__(self, vm):
         super().__init__()
-        self.vm = vm
+        self._vm = vm
-        self.title(f"{vm} - version {vm.version}")
+        self.title(f'{vm} - version {vm.version}')
-        self.vm.observer.add(self.on_ldirty)
+        self._vm.observer.add(self.on_ldirty)
 
         # create widget variables
         self.button_var = tk.BooleanVar(value=vm.strip[self.INDEX].mute)
@@ -24,14 +24,14 @@ class App(tk.Tk):
 
         # initialize style table
         self.style = ttk.Style()
-        self.style.theme_use("clam")
+        self.style.theme_use('clam')
         self.style.configure(
-            "Mute.TButton",
+            'Mute.TButton',
-            foreground="#cd5c5c" if vm.strip[self.INDEX].mute else "#5a5a5a",
+            foreground='#cd5c5c' if vm.strip[self.INDEX].mute else '#5a5a5a',
         )
 
         # create labelframe and grid it onto the mainframe
-        self.labelframe = tk.LabelFrame(self, text=self.vm.strip[self.INDEX].label)
+        self.labelframe = tk.LabelFrame(self, text=self._vm.strip[self.INDEX].label)
         self.labelframe.grid(padx=1)
 
         # create slider and grid it onto the labelframe
@@ -39,7 +39,7 @@ class App(tk.Tk):
             self.labelframe,
             from_=12,
             to_=-60,
-            orient="vertical",
+            orient='vertical',
             variable=self.slider_var,
             command=lambda arg: self.on_slider_move(arg),
         )
@@ -47,15 +47,15 @@ class App(tk.Tk):
             column=0,
             row=0,
         )
-        slider.bind("<Double-Button-1>", self.on_button_double_click)
+        slider.bind('<Double-Button-1>', self.on_button_double_click)
 
         # create level meter and grid it onto the labelframe
         level_meter = ttk.Progressbar(
             self.labelframe,
-            orient="vertical",
+            orient='vertical',
             variable=self.meter_var,
             maximum=72,
-            mode="determinate",
+            mode='determinate',
         )
         level_meter.grid(column=1, row=0)
 
@@ -66,8 +66,8 @@ class App(tk.Tk):
         # create button and grid it onto the labelframe
         button = ttk.Button(
             self.labelframe,
-            text="Mute",
+            text='Mute',
-            style="Mute.TButton",
+            style='Mute.TButton',
             command=lambda: self.on_button_press(),
         )
         button.grid(column=0, row=2, columnspan=2, padx=1, pady=2)
@@ -76,23 +76,23 @@ class App(tk.Tk):
 
     def on_slider_move(self, *args):
         val = round(self.slider_var.get(), 1)
-        self.vm.strip[self.INDEX].gain = val
+        self._vm.strip[self.INDEX].gain = val
         self.gainlabel_var.set(val)
 
     def on_button_press(self):
         self.button_var.set(not self.button_var.get())
-        self.vm.strip[self.INDEX].mute = self.button_var.get()
+        self._vm.strip[self.INDEX].mute = self.button_var.get()
         self.style.configure(
-            "Mute.TButton", foreground="#cd5c5c" if self.button_var.get() else "#5a5a5a"
+            'Mute.TButton', foreground='#cd5c5c' if self.button_var.get() else '#5a5a5a'
         )
 
     def on_button_double_click(self, e):
         self.slider_var.set(0)
         self.gainlabel_var.set(0)
-        self.vm.strip[self.INDEX].gain = 0
+        self._vm.strip[self.INDEX].gain = 0
 
     def _get_level(self):
-        val = max(self.vm.strip[self.INDEX].levels.postfader)
+        val = max(self._vm.strip[self.INDEX].levels.postfader)
         return 0 if self.button_var.get() else 72 + val - 12
 
     def on_ldirty(self):
@@ -100,10 +100,10 @@ class App(tk.Tk):
 
 
 def main():
-    with voicemeeterlib.api("banana", ldirty=True) as vm:
+    with voicemeeterlib.api('banana', ldirty=True) as vm:
         app = App(vm)
         app.mainloop()
 
 
-if __name__ == "__main__":
+if __name__ == '__main__':
     main()

examples/levels/__main__.py

@@ -7,16 +7,16 @@ logging.basicConfig(level=logging.INFO)
 
 
 def main():
-    KIND_ID = "potato"
+    KIND_ID = 'potato'
 
     vm = voicemeeterlib.api(KIND_ID)
     vm.login()
     for _ in range(500):
         print(
-            "\n".join(
+            '\n'.join(
                 [
-                    f"{vm.strip[5]}: {vm.strip[5].levels.postmute}",
+                    f'{vm.strip[5]}: {vm.strip[5].levels.postmute}',
-                    f"{vm.bus[0]}: {vm.bus[0].levels.all}",
+                    f'{vm.bus[0]}: {vm.bus[0].levels.all}',
                 ]
             )
         )
@@ -24,5 +24,5 @@ def main():
     vm.logout()
 
 
-if __name__ == "__main__":
+if __name__ == '__main__':
     main()

examples/midi/__main__.py

@@ -10,41 +10,42 @@ class App:
     MACROBUTTON = 0
 
     def __init__(self, vm):
-        self.vm = vm
+        self._vm = vm
-        self.vm.observer.add(self.on_midi)
+        self._vm.observer.add(self.on_midi)
 
     def on_midi(self):
-        self.get_info()
+        if self.get_info() == self.MIDI_BUTTON:
-        self.on_midi_press()
+            self.on_midi_press()
 
     def get_info(self):
-        current = self.vm.midi.current
+        current = self._vm.midi.current
-        print(f"Value of midi button {current} is {self.vm.midi.get(current)}")
+        print(f'Value of midi button {current} is {self._vm.midi.get(current)}')
+        return current
 
     def on_midi_press(self):
-        """if strip 3 level max > -40 and midi button 48 is pressed, then set trigger for macrobutton 0"""
+        """if midi button 48 is pressed and strip 3 level max > -40, then set trigger for macrobutton 0"""
 
         if (
-            max(self.vm.strip[3].levels.postfader) > -40
+            self._vm.midi.get(self.MIDI_BUTTON) == 127
-            and self.vm.midi.get(self.MIDI_BUTTON) == 127
+            and max(self._vm.strip[3].levels.postfader) > -40
         ):
             print(
-                f"Strip 3 level max is greater than -40 and midi button {self.MIDI_BUTTON} is pressed"
+                f'Strip 3 level max is greater than -40 and midi button {self.MIDI_BUTTON} is pressed'
             )
-            self.vm.button[self.MACROBUTTON].trigger = True
+            self._vm.button[self.MACROBUTTON].trigger = True
         else:
-            self.vm.button[self.MACROBUTTON].trigger = False
+            self._vm.button[self.MACROBUTTON].trigger = False
 
 
 def main():
-    KIND_ID = "banana"
+    KIND_ID = 'banana'
 
     with voicemeeterlib.api(KIND_ID, midi=True) as vm:
         App(vm)
 
-        while cmd := input("Press <Enter> to exit\n"):
+        while _ := input('Press <Enter> to exit\n'):
             pass
 
 
-if __name__ == "__main__":
+if __name__ == '__main__':
     main()

examples/obs/__main__.py

@@ -1,4 +1,4 @@
-import time
+import threading
 from logging import config
 
 import obsws_python as obsws
@@ -7,91 +7,100 @@ import voicemeeterlib
 
 config.dictConfig(
     {
-        "version": 1,
+        'version': 1,
-        "formatters": {
+        'formatters': {
-            "standard": {
+            'standard': {
-                "format": "%(asctime)s,%(msecs)d %(name)s %(levelname)s %(message)s"
+                'format': '%(asctime)s,%(msecs)d %(name)s %(levelname)s %(message)s'
             }
         },
-        "handlers": {
+        'handlers': {
-            "stream": {
+            'stream': {
-                "level": "DEBUG",
+                'level': 'DEBUG',
-                "class": "logging.StreamHandler",
+                'class': 'logging.StreamHandler',
-                "formatter": "standard",
+                'formatter': 'standard',
             }
         },
-        "loggers": {
+        'loggers': {
-            "voicemeeterlib.iremote": {"handlers": ["stream"], "level": "DEBUG"}
+            'voicemeeterlib.iremote': {
+                'handlers': ['stream'],
+                'level': 'DEBUG',
+                'propagate': False,
+            }
         },
+        'root': {'handlers': ['stream'], 'level': 'WARNING'},
     }
 )
 
 
 class MyClient:
-    def __init__(self, vm):
+    def __init__(self, vm, stop_event):
-        self.vm = vm
+        self._vm = vm
-        self.client = obsws.EventClient()
+        self._stop_event = stop_event
-        self.client.callback.register(
+        self._client = obsws.EventClient()
+        self._client.callback.register(
             (
                 self.on_current_program_scene_changed,
                 self.on_exit_started,
             )
         )
-        self.is_running = True
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_value, exc_traceback):
+        self._client.disconnect()
 
     def on_start(self):
-        self.vm.strip[0].mute = True
+        self._vm.strip[0].mute = True
-        self.vm.strip[1].B1 = True
+        self._vm.strip[1].B1 = True
-        self.vm.strip[2].B2 = True
+        self._vm.strip[2].B2 = True
 
     def on_brb(self):
-        self.vm.strip[7].fadeto(0, 500)
+        self._vm.strip[7].fadeto(0, 500)
-        self.vm.bus[0].mute = True
+        self._vm.bus[0].mute = True
 
     def on_end(self):
-        self.vm.apply(
+        self._vm.apply(
             {
-                "strip-0": {"mute": True, "comp": {"ratio": 4.3}},
+                'strip-0': {'mute': True, 'comp': {'ratio': 4.3}},
-                "strip-1": {"mute": True, "B1": False, "gate": {"attack": 2.3}},
+                'strip-1': {'mute': True, 'B1': False, 'gate': {'attack': 2.3}},
-                "strip-2": {"mute": True, "B1": False},
+                'strip-2': {'mute': True, 'B1': False},
-                "vban-in-0": {"on": False},
+                'vban-in-0': {'on': False},
             }
         )
 
     def on_live(self):
-        self.vm.strip[0].mute = False
+        self._vm.strip[0].mute = False
-        self.vm.strip[7].fadeto(-6, 500)
+        self._vm.strip[7].fadeto(-6, 500)
-        self.vm.strip[7].A3 = True
+        self._vm.strip[7].A3 = True
-        self.vm.vban.instream[0].on = True
+        self._vm.vban.instream[0].on = True
 
     def on_current_program_scene_changed(self, data):
-        def fget(scene):
-            run = {
-                "START": self.on_start,
-                "BRB": self.on_brb,
-                "END": self.on_end,
-                "LIVE": self.on_live,
-            }
-            return run.get(scene)
-
         scene = data.scene_name
-        print(f"Switched to scene {scene}")
+        print(f'Switched to scene {scene}')
-        if fn := fget(scene):
+        match scene:
-            fn()
+            case 'START':
+                self.on_start()
+            case 'BRB':
+                self.on_brb()
+            case 'END':
+                self.on_end()
+            case 'LIVE':
+                self.on_live()
 
     def on_exit_started(self, _):
-        self.client.unsubscribe()
+        self._stop_event.set()
-        self.is_running = False
 
 
 def main():
-    KIND_ID = "potato"
+    KIND_ID = 'potato'
 
     with voicemeeterlib.api(KIND_ID) as vm:
-        client = MyClient(vm)
+        stop_event = threading.Event()
-        while client.is_running:
+
-            time.sleep(0.1)
+        with MyClient(vm, stop_event):
+            stop_event.wait()
 
 
-if __name__ == "__main__":
+if __name__ == '__main__':
     main()

examples/observer/__main__.py

@@ -1,45 +0,0 @@
-import logging
-
-import voicemeeterlib
-
-logging.basicConfig(level=logging.INFO)
-
-
-class App:
-    def __init__(self, vm):
-        self.vm = vm
-        # register your app as event observer
-        self.vm.observer.add(self)
-
-    def __str__(self):
-        return type(self).__name__
-
-    # define an 'on_update' callback function to receive event updates
-    def on_update(self, event):
-        if event == "pdirty":
-            print("pdirty!")
-        elif event == "mdirty":
-            print("mdirty!")
-        elif event == "ldirty":
-            for bus in self.vm.bus:
-                if bus.levels.isdirty:
-                    print(bus, bus.levels.all)
-        elif event == "midi":
-            current = self.vm.midi.current
-            print(f"Value of midi button {current} is {self.vm.midi.get(current)}")
-
-
-def main():
-    KIND_ID = "banana"
-
-    with voicemeeterlib.api(
-        KIND_ID, **{k: True for k in ("pdirty", "mdirty", "ldirty", "midi")}
-    ) as vm:
-        App(vm)
-
-        while cmd := input("Press <Enter> to exit\n"):
-            pass
-
-
-if __name__ == "__main__":
-    main()

poetry.lock

@@ -1,291 +1,359 @@
-[[package]]
+# This file is automatically @generated by Poetry 2.2.1 and should not be changed by hand.
-name = "black"
-version = "22.12.0"
-description = "The uncompromising code formatter."
-category = "dev"
-optional = false
-python-versions = ">=3.7"
-
-[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 = "cachetools"
-version = "5.3.1"
+version = "5.5.0"
 description = "Extensible memoizing collections and decorators"
-category = "dev"
 optional = false
 python-versions = ">=3.7"
+groups = ["dev"]
+files = [
+    {file = "cachetools-5.5.0-py3-none-any.whl", hash = "sha256:02134e8439cdc2ffb62023ce1debca2944c3f289d66bb17ead3ab3dede74b292"},
+    {file = "cachetools-5.5.0.tar.gz", hash = "sha256:2cc24fb4cbe39633fb7badd9db9ca6295d766d9c2995f245725a46715d050f2a"},
+]
 
 [[package]]
 name = "chardet"
-version = "5.1.0"
+version = "5.2.0"
 description = "Universal encoding detector for Python 3"
-category = "dev"
 optional = false
 python-versions = ">=3.7"
-
+groups = ["dev"]
-[[package]]
+files = [
-name = "click"
+    {file = "chardet-5.2.0-py3-none-any.whl", hash = "sha256:e1cf59446890a00105fe7b7912492ea04b6e6f06d4b742b2c788469e34c82970"},
-version = "8.1.3"
+    {file = "chardet-5.2.0.tar.gz", hash = "sha256:1b3b6ff479a8c414bc3fa2c0852995695c4a026dcd6d0633b2dd092ca39c1cf7"},
-description = "Composable command line interface toolkit"
+]
-category = "dev"
-optional = false
-python-versions = ">=3.7"
-
-[package.dependencies]
-colorama = {version = "*", markers = "platform_system == \"Windows\""}
 
 [[package]]
 name = "colorama"
 version = "0.4.6"
 description = "Cross-platform colored terminal text."
-category = "dev"
 optional = false
 python-versions = "!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,!=3.6.*,>=2.7"
+groups = ["dev"]
+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.6"
+version = "0.3.9"
 description = "Distribution utilities"
-category = "dev"
 optional = false
 python-versions = "*"
+groups = ["dev"]
+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.1.1"
+version = "1.2.2"
 description = "Backport of PEP 654 (exception groups)"
-category = "dev"
 optional = false
 python-versions = ">=3.7"
+groups = ["dev"]
+markers = "python_version == \"3.10\""
+files = [
+    {file = "exceptiongroup-1.2.2-py3-none-any.whl", hash = "sha256:3111b9d131c238bec2f8f516e123e14ba243563fb135d3fe885990585aa7795b"},
+    {file = "exceptiongroup-1.2.2.tar.gz", hash = "sha256:47c2edf7c6738fafb49fd34290706d1a1a2f4d1c6df275526b62cbb4aa5393cc"},
+]
 
 [package.extras]
 test = ["pytest (>=6)"]
 
 [[package]]
 name = "filelock"
-version = "3.12.2"
+version = "3.20.3"
 description = "A platform independent file lock."
-category = "dev"
 optional = false
-python-versions = ">=3.7"
+python-versions = ">=3.10"
-
+groups = ["dev"]
-[package.extras]
+files = [
-docs = ["furo (>=2023.5.20)", "sphinx-autodoc-typehints (>=1.23,!=1.23.4)", "sphinx (>=7.0.1)"]
+    {file = "filelock-3.20.3-py3-none-any.whl", hash = "sha256:4b0dda527ee31078689fc205ec4f1c1bf7d56cf88b6dc9426c4f230e46c2dce1"},
-testing = ["covdefaults (>=2.3)", "coverage (>=7.2.7)", "diff-cover (>=7.5)", "pytest-cov (>=4.1)", "pytest-mock (>=3.10)", "pytest-timeout (>=2.1)", "pytest (>=7.3.1)"]
+    {file = "filelock-3.20.3.tar.gz", hash = "sha256:18c57ee915c7ec61cff0ecf7f0f869936c7c30191bb0cf406f1341778d0834e1"},
+]
 
 [[package]]
 name = "iniconfig"
 version = "2.0.0"
 description = "brain-dead simple config-ini parsing"
-category = "dev"
 optional = false
 python-versions = ">=3.7"
-
+groups = ["dev"]
-[[package]]
+files = [
-name = "isort"
+    {file = "iniconfig-2.0.0-py3-none-any.whl", hash = "sha256:b6a85871a79d2e3b22d2d1b94ac2824226a63c6b741c88f7ae975f18b6778374"},
-version = "5.12.0"
+    {file = "iniconfig-2.0.0.tar.gz", hash = "sha256:2d91e135bf72d31a410b17c16da610a82cb55f6b0477d1a902134b24a455b8b3"},
-description = "A Python utility / library to sort Python imports."
+]
-category = "dev"
-optional = false
-python-versions = ">=3.8.0"
-
-[package.extras]
-colors = ["colorama (>=0.4.3)"]
-requirements-deprecated-finder = ["pip-api", "pipreqs"]
-pipfile-deprecated-finder = ["pip-shims (>=0.5.2)", "pipreqs", "requirementslib"]
-plugins = ["setuptools"]
-
-[[package]]
-name = "mypy-extensions"
-version = "1.0.0"
-description = "Type system extensions for programs checked with the mypy type checker."
-category = "dev"
-optional = false
-python-versions = ">=3.5"
 
 [[package]]
 name = "packaging"
-version = "23.1"
+version = "24.2"
 description = "Core utilities for Python packages"
-category = "dev"
 optional = false
-python-versions = ">=3.7"
+python-versions = ">=3.8"
-
+groups = ["dev"]
-[[package]]
+files = [
-name = "pathspec"
+    {file = "packaging-24.2-py3-none-any.whl", hash = "sha256:09abb1bccd265c01f4a3aa3f7a7db064b36514d2cba19a2f694fe6150451a759"},
-version = "0.11.1"
+    {file = "packaging-24.2.tar.gz", hash = "sha256:c228a6dc5e932d346bc5739379109d49e8853dd8223571c7c5b55260edc0b97f"},
-description = "Utility library for gitignore style pattern matching of file paths."
+]
-category = "dev"
-optional = false
-python-versions = ">=3.7"
 
 [[package]]
 name = "platformdirs"
-version = "3.6.0"
+version = "4.3.6"
-description = "A small Python package 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"
+groups = ["dev"]
+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 (>=2023.5.20)", "proselint (>=0.13)", "sphinx-autodoc-typehints (>=1.23,!=1.23.4)", "sphinx (>=7.0.1)"]
+docs = ["furo (>=2024.8.6)", "proselint (>=0.14)", "sphinx (>=8.0.2)", "sphinx-autodoc-typehints (>=2.4)"]
-test = ["appdirs (==1.4.4)", "covdefaults (>=2.3)", "pytest-cov (>=4.1)", "pytest-mock (>=3.10)", "pytest (>=7.3.1)"]
+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.1.0"
+version = "1.5.0"
 description = "plugin and hook calling mechanisms for python"
-category = "dev"
 optional = false
-python-versions = ">=3.7"
+python-versions = ">=3.8"
+groups = ["dev"]
+files = [
+    {file = "pluggy-1.5.0-py3-none-any.whl", hash = "sha256:44e1ad92c8ca002de6377e165f3e0f1be63266ab4d554740532335b9d75ea669"},
+    {file = "pluggy-1.5.0.tar.gz", hash = "sha256:2cffa88e94fdc978c4c574f15f9e59b7f4201d439195c3715ca9e2486f1d0cf1"},
+]
 
 [package.extras]
 dev = ["pre-commit", "tox"]
 testing = ["pytest", "pytest-benchmark"]
 
 [[package]]
-name = "pyproject-api"
+name = "pyenv-inspect"
-version = "1.5.2"
+version = "0.4.0"
-description = "API to interact with the python pyproject.toml based projects"
+description = "An auxiliary library for the virtualenv-pyenv and tox-pyenv-redux plugins"
-category = "dev"
 optional = false
-python-versions = ">=3.7"
+python-versions = ">=3.8"
+groups = ["dev"]
+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 = "pyproject-api"
+version = "1.8.0"
+description = "API to interact with the python pyproject.toml based projects"
+optional = false
+python-versions = ">=3.8"
+groups = ["dev"]
+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 = ">=23.1"
+packaging = ">=24.1"
 tomli = {version = ">=2.0.1", markers = "python_version < \"3.11\""}
 
 [package.extras]
-docs = ["furo (>=2023.5.20)", "sphinx-autodoc-typehints (>=1.23,!=1.23.4)", "sphinx (>=7.0.1)"]
+docs = ["furo (>=2024.8.6)", "sphinx-autodoc-typehints (>=2.4.1)"]
-testing = ["covdefaults (>=2.3)", "importlib-metadata (>=6.6)", "pytest-cov (>=4.1)", "pytest-mock (>=3.10)", "pytest (>=7.3.1)", "setuptools (>=67.8)", "wheel (>=0.40)"]
+testing = ["covdefaults (>=2.3)", "pytest (>=8.3.3)", "pytest-cov (>=5)", "pytest-mock (>=3.14)", "setuptools (>=75.1)"]
 
 [[package]]
 name = "pytest"
-version = "7.3.2"
+version = "8.3.4"
 description = "pytest: simple powerful testing with Python"
-category = "dev"
 optional = false
-python-versions = ">=3.7"
+python-versions = ">=3.8"
+groups = ["dev"]
+files = [
+    {file = "pytest-8.3.4-py3-none-any.whl", hash = "sha256:50e16d954148559c9a74109af1eaf0c945ba2d8f30f0a3d3335edde19788b6f6"},
+    {file = "pytest-8.3.4.tar.gz", hash = "sha256:965370d062bce11e73868e0335abac31b4d3de0e82f4007408d242b4f8610761"},
+]
 
 [package.dependencies]
 colorama = {version = "*", markers = "sys_platform == \"win32\""}
 exceptiongroup = {version = ">=1.0.0rc8", markers = "python_version < \"3.11\""}
 iniconfig = "*"
 packaging = "*"
-pluggy = ">=0.12,<2.0"
+pluggy = ">=1.5,<2"
-tomli = {version = ">=1.0.0", markers = "python_version < \"3.11\""}
+tomli = {version = ">=1", markers = "python_version < \"3.11\""}
 
 [package.extras]
-testing = ["argcomplete", "attrs (>=19.2.0)", "hypothesis (>=3.56)", "mock", "nose", "pygments (>=2.7.2)", "requests", "setuptools", "xmlschema"]
+dev = ["argcomplete", "attrs (>=19.2)", "hypothesis (>=3.56)", "mock", "pygments (>=2.7.2)", "requests", "setuptools", "xmlschema"]
 
 [[package]]
 name = "pytest-randomly"
-version = "3.12.0"
+version = "3.16.0"
 description = "Pytest plugin to randomly order tests and control random.seed."
-category = "dev"
 optional = false
-python-versions = ">=3.7"
+python-versions = ">=3.9"
+groups = ["dev"]
+files = [
+    {file = "pytest_randomly-3.16.0-py3-none-any.whl", hash = "sha256:8633d332635a1a0983d3bba19342196807f6afb17c3eef78e02c2f85dade45d6"},
+    {file = "pytest_randomly-3.16.0.tar.gz", hash = "sha256:11bf4d23a26484de7860d82f726c0629837cf4064b79157bd18ec9d41d7feb26"},
+]
 
 [package.dependencies]
 pytest = "*"
 
 [[package]]
-name = "pytest-repeat"
+name = "ruff"
-version = "0.9.1"
+version = "0.8.6"
-description = "pytest plugin for repeating tests"
+description = "An extremely fast Python linter and code formatter, written in Rust."
-category = "dev"
 optional = false
-python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*"
+python-versions = ">=3.7"
-
+groups = ["dev"]
-[package.dependencies]
+files = [
-pytest = ">=3.6"
+    {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"
+version = "2.2.1"
 description = "A lil' TOML parser"
-category = "main"
 optional = false
-python-versions = ">=3.7"
+python-versions = ">=3.8"
+groups = ["main", "dev"]
+markers = "python_version == \"3.10\""
+files = [
+    {file = "tomli-2.2.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:678e4fa69e4575eb77d103de3df8a895e1591b48e740211bd1067378c69e8249"},
+    {file = "tomli-2.2.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:023aa114dd824ade0100497eb2318602af309e5a55595f76b626d6d9f3b7b0a6"},
+    {file = "tomli-2.2.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ece47d672db52ac607a3d9599a9d48dcb2f2f735c6c2d1f34130085bb12b112a"},
+    {file = "tomli-2.2.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6972ca9c9cc9f0acaa56a8ca1ff51e7af152a9f87fb64623e31d5c83700080ee"},
+    {file = "tomli-2.2.1-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:c954d2250168d28797dd4e3ac5cf812a406cd5a92674ee4c8f123c889786aa8e"},
+    {file = "tomli-2.2.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:8dd28b3e155b80f4d54beb40a441d366adcfe740969820caf156c019fb5c7ec4"},
+    {file = "tomli-2.2.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:e59e304978767a54663af13c07b3d1af22ddee3bb2fb0618ca1593e4f593a106"},
+    {file = "tomli-2.2.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:33580bccab0338d00994d7f16f4c4ec25b776af3ffaac1ed74e0b3fc95e885a8"},
+    {file = "tomli-2.2.1-cp311-cp311-win32.whl", hash = "sha256:465af0e0875402f1d226519c9904f37254b3045fc5084697cefb9bdde1ff99ff"},
+    {file = "tomli-2.2.1-cp311-cp311-win_amd64.whl", hash = "sha256:2d0f2fdd22b02c6d81637a3c95f8cd77f995846af7414c5c4b8d0545afa1bc4b"},
+    {file = "tomli-2.2.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:4a8f6e44de52d5e6c657c9fe83b562f5f4256d8ebbfe4ff922c495620a7f6cea"},
+    {file = "tomli-2.2.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:8d57ca8095a641b8237d5b079147646153d22552f1c637fd3ba7f4b0b29167a8"},
+    {file = "tomli-2.2.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4e340144ad7ae1533cb897d406382b4b6fede8890a03738ff1683af800d54192"},
+    {file = "tomli-2.2.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:db2b95f9de79181805df90bedc5a5ab4c165e6ec3fe99f970d0e302f384ad222"},
+    {file = "tomli-2.2.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:40741994320b232529c802f8bc86da4e1aa9f413db394617b9a256ae0f9a7f77"},
+    {file = "tomli-2.2.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:400e720fe168c0f8521520190686ef8ef033fb19fc493da09779e592861b78c6"},
+    {file = "tomli-2.2.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:02abe224de6ae62c19f090f68da4e27b10af2b93213d36cf44e6e1c5abd19fdd"},
+    {file = "tomli-2.2.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:b82ebccc8c8a36f2094e969560a1b836758481f3dc360ce9a3277c65f374285e"},
+    {file = "tomli-2.2.1-cp312-cp312-win32.whl", hash = "sha256:889f80ef92701b9dbb224e49ec87c645ce5df3fa2cc548664eb8a25e03127a98"},
+    {file = "tomli-2.2.1-cp312-cp312-win_amd64.whl", hash = "sha256:7fc04e92e1d624a4a63c76474610238576942d6b8950a2d7f908a340494e67e4"},
+    {file = "tomli-2.2.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:f4039b9cbc3048b2416cc57ab3bda989a6fcf9b36cf8937f01a6e731b64f80d7"},
+    {file = "tomli-2.2.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:286f0ca2ffeeb5b9bd4fcc8d6c330534323ec51b2f52da063b11c502da16f30c"},
+    {file = "tomli-2.2.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a92ef1a44547e894e2a17d24e7557a5e85a9e1d0048b0b5e7541f76c5032cb13"},
+    {file = "tomli-2.2.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9316dc65bed1684c9a98ee68759ceaed29d229e985297003e494aa825ebb0281"},
+    {file = "tomli-2.2.1-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e85e99945e688e32d5a35c1ff38ed0b3f41f43fad8df0bdf79f72b2ba7bc5272"},
+    {file = "tomli-2.2.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:ac065718db92ca818f8d6141b5f66369833d4a80a9d74435a268c52bdfa73140"},
+    {file = "tomli-2.2.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:d920f33822747519673ee656a4b6ac33e382eca9d331c87770faa3eef562aeb2"},
+    {file = "tomli-2.2.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:a198f10c4d1b1375d7687bc25294306e551bf1abfa4eace6650070a5c1ae2744"},
+    {file = "tomli-2.2.1-cp313-cp313-win32.whl", hash = "sha256:d3f5614314d758649ab2ab3a62d4f2004c825922f9e370b29416484086b264ec"},
+    {file = "tomli-2.2.1-cp313-cp313-win_amd64.whl", hash = "sha256:a38aa0308e754b0e3c67e344754dff64999ff9b513e691d0e786265c93583c69"},
+    {file = "tomli-2.2.1-py3-none-any.whl", hash = "sha256:cb55c73c5f4408779d0cf3eef9f762b9c9f147a77de7b258bef0a5628adc85cc"},
+    {file = "tomli-2.2.1.tar.gz", hash = "sha256:cd45e1dc79c835ce60f7404ec8119f2eb06d38b1deba146f07ced3bbc44505ff"},
+]
 
 [[package]]
 name = "tox"
-version = "4.6.3"
+version = "4.23.2"
 description = "tox is a generic virtualenv management and test command line tool"
-category = "dev"
 optional = false
-python-versions = ">=3.7"
+python-versions = ">=3.8"
+groups = ["dev"]
+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.3.1"
+cachetools = ">=5.5"
-chardet = ">=5.1"
+chardet = ">=5.2"
 colorama = ">=0.4.6"
-filelock = ">=3.12.2"
+filelock = ">=3.16.1"
-packaging = ">=23.1"
+packaging = ">=24.1"
-platformdirs = ">=3.5.3"
+platformdirs = ">=4.3.6"
-pluggy = ">=1"
+pluggy = ">=1.5"
-pyproject-api = ">=1.5.2"
+pyproject-api = ">=1.8"
 tomli = {version = ">=2.0.1", markers = "python_version < \"3.11\""}
-virtualenv = ">=20.23.1"
+typing-extensions = {version = ">=4.12.2", markers = "python_version < \"3.11\""}
+virtualenv = ">=20.26.6"
 
 [package.extras]
-docs = ["furo (>=2023.5.20)", "sphinx-argparse-cli (>=1.11.1)", "sphinx-autodoc-typehints (>=1.23.2,!=1.23.4)", "sphinx-copybutton (>=0.5.2)", "sphinx-inline-tabs (>=2023.4.21)", "sphinx (>=7.0.1)", "sphinxcontrib-towncrier (>=0.2.1a0)", "towncrier (>=23.6)"]
+test = ["devpi-process (>=1.0.2)", "pytest (>=8.3.3)", "pytest-mock (>=3.14)"]
-testing = ["build[virtualenv] (>=0.10)", "covdefaults (>=2.3)", "detect-test-pollution (>=1.1.1)", "devpi-process (>=0.3.1)", "diff-cover (>=7.6)", "distlib (>=0.3.6)", "flaky (>=3.7)", "hatch-vcs (>=0.3)", "hatchling (>=1.17.1)", "psutil (>=5.9.5)", "pytest-cov (>=4.1)", "pytest-mock (>=3.11.1)", "pytest-xdist (>=3.3.1)", "pytest (>=7.3.2)", "re-assert (>=1.1)", "time-machine (>=2.10)", "wheel (>=0.40)"]
+
+[[package]]
+name = "typing-extensions"
+version = "4.15.0"
+description = "Backported and Experimental Type Hints for Python 3.9+"
+optional = false
+python-versions = ">=3.9"
+groups = ["dev"]
+markers = "python_version == \"3.10\""
+files = [
+    {file = "typing_extensions-4.15.0-py3-none-any.whl", hash = "sha256:f0fa19c6845758ab08074a0cfa8b7aecb71c999ca73d62883bc25cc018c4e548"},
+    {file = "typing_extensions-4.15.0.tar.gz", hash = "sha256:0cea48d173cc12fa28ecabc3b837ea3cf6f38c6d1136f85cbaaf598984861466"},
+]
 
 [[package]]
 name = "virtualenv"
-version = "20.23.1"
+version = "20.36.1"
 description = "Virtual Python Environment builder"
-category = "dev"
 optional = false
-python-versions = ">=3.7"
+python-versions = ">=3.8"
+groups = ["dev"]
+files = [
+    {file = "virtualenv-20.36.1-py3-none-any.whl", hash = "sha256:575a8d6b124ef88f6f51d56d656132389f961062a9177016a50e4f507bbcc19f"},
+    {file = "virtualenv-20.36.1.tar.gz", hash = "sha256:8befb5c81842c641f8ee658481e42641c68b5eab3521d8e092d18320902466ba"},
+]
 
 [package.dependencies]
-distlib = ">=0.3.6,<1"
+distlib = ">=0.3.7,<1"
-filelock = ">=3.12,<4"
+filelock = {version = ">=3.20.1,<4", markers = "python_version >= \"3.10\""}
-platformdirs = ">=3.5.1,<4"
+platformdirs = ">=3.9.1,<5"
+typing-extensions = {version = ">=4.13.2", markers = "python_version < \"3.11\""}
 
 [package.extras]
-docs = ["furo (>=2023.5.20)", "proselint (>=0.13)", "sphinx-argparse (>=0.4)", "sphinx (>=7.0.1)", "sphinxcontrib-towncrier (>=0.2.1a0)", "towncrier (>=23.6)"]
+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-enable-subprocess (>=1)", "coverage (>=7.2.7)", "flaky (>=3.7)", "packaging (>=23.1)", "pytest-env (>=0.8.1)", "pytest-freezer (>=0.4.6)", "pytest-mock (>=3.10)", "pytest-randomly (>=3.12)", "pytest-timeout (>=2.1)", "pytest (>=7.3.1)", "setuptools (>=67.8)", "time-machine (>=2.9)"]
+test = ["covdefaults (>=2.3)", "coverage (>=7.2.7)", "coverage-enable-subprocess (>=1)", "flaky (>=3.7)", "packaging (>=23.1)", "pytest (>=7.4)", "pytest-env (>=0.8.2)", "pytest-freezer (>=0.4.8) ; platform_python_implementation == \"PyPy\" or platform_python_implementation == \"GraalVM\" or platform_python_implementation == \"CPython\" and sys_platform == \"win32\" and python_version >= \"3.13\"", "pytest-mock (>=3.11.1)", "pytest-randomly (>=3.12)", "pytest-timeout (>=2.1)", "setuptools (>=68)", "time-machine (>=2.10) ; platform_python_implementation == \"CPython\""]
+
+[[package]]
+name = "virtualenv-pyenv"
+version = "0.5.0"
+description = "A virtualenv Python discovery plugin for pyenv-installed interpreters"
+optional = false
+python-versions = ">=3.8"
+groups = ["dev"]
+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 = "1.1"
+lock-version = "2.1"
-python-versions = "^3.10"
+python-versions = ">=3.10"
-content-hash = "5d0edd070ea010edb4e2ade88dc37324b8b4b04f22db78e49db161185365849b"
+content-hash = "6339967c3f6cad8e4db7047ef3d12a5b059a279d0f7c98515c961477680bab8f"
-
-[metadata.files]
-black = []
-cachetools = []
-chardet = []
-click = []
-colorama = []
-distlib = []
-exceptiongroup = []
-filelock = []
-iniconfig = []
-isort = []
-mypy-extensions = []
-packaging = []
-pathspec = []
-platformdirs = []
-pluggy = []
-pyproject-api = []
-pytest = []
-pytest-randomly = []
-pytest-repeat = []
-tomli = []
-tox = []
-virtualenv = []

pyproject.toml

@@ -1,50 +1,124 @@
-[tool.poetry]
+[project]
 name = "voicemeeter-api"
-version = "2.0.2"
+version = "2.7.2"
 description = "A Python wrapper for the Voiceemeter API"
-authors = ["onyx-and-iris <code@onyxandiris.online>"]
+authors = [{ name = "Onyx and Iris", email = "code@onyxandiris.online" }]
-license = "MIT"
+license = { text = "MIT" }
 readme = "README.md"
-repository = "https://github.com/onyx-and-iris/voicemeeter-api-python"
+requires-python = ">=3.10"
+dependencies = ["tomli (>=2.0.1,<3.0) ; python_version < '3.11'"]
 
-packages = [
+[tool.poetry]
-    { include = "voicemeeterlib" },
+packages = [{ include = "voicemeeterlib" }]
-]
 
-[tool.poetry.dependencies]
+[tool.poetry.requires-plugins]
-python = "^3.10"
+poethepoet = ">=0.42.0"
-tomli = { version = "^2.0.1", python = "<3.11" }
 
-[tool.poetry.dev-dependencies]
+[tool.poetry.group.dev.dependencies]
-pytest = "^7.1.2"
+pytest = "^8.3.4"
-pytest-randomly = "^3.12.0"
+pytest-randomly = "^3.16.0"
-pytest-repeat = "^0.9.1"
+ruff = "^0.8.6"
-black = "^22.3.0"
+tox = "^4.23.2"
-isort = "^5.10.1"
+virtualenv-pyenv = "^0.5.0"
-tox = "^4.6.3"
 
 [build-system]
-requires = ["poetry-core>=1.0.0"]
+requires = ["poetry-core>=2.0.0,<3.0.0"]
 build-backend = "poetry.core.masonry.api"
 
-[tool.poetry.scripts]
+[tool.poe.tasks]
-dsl = "scripts:ex_dsl"
+dsl.script = "scripts:ex_dsl"
-events = "scripts:ex_events"
+callbacks.script = "scripts:ex_callbacks"
-gui = "scripts:ex_gui"
+gui.script = "scripts:ex_gui"
-levels = "scripts:ex_levels"
+levels.script = "scripts:ex_levels"
-midi = "scripts:ex_midi"
+midi.script = "scripts:ex_midi"
-obs = "scripts:ex_obs"
+obs.script = "scripts:ex_obs"
-observer = "scripts:ex_observer"
+observer.script = "scripts:ex_observer"
-test = "scripts:test"
+eqedit.script = "scripts:ex_eqedit"
+test-basic.script = "scripts:test_basic"
+test-banana.script = "scripts:test_banana"
+test-potato.script = "scripts:test_potato"
+test-all.script = "scripts:test_all"
+generate-badges.script = "scripts:generate_badges"
 
-[tool.tox]
-legacy_tox_ini = """
-[tox]
-envlist = py310,py311
 
-[testenv]
+[tool.ruff]
-allowlist_externals = poetry
+exclude = [
-commands =
+    ".bzr",
-  poetry install -v
+    ".direnv",
-  poetry run pytest tests/
+    ".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",
+]
+
+# Same as Black.
+line-length = 88
+indent-width = 4
+
+# Assume Python 3.10
+target-version = "py310"
+
+[tool.ruff.lint]
+# Enable Pyflakes (`F`) and a subset of the pycodestyle (`E`)  codes by default.
+# Enable flake8-errmsg (EM) warnings.
+# Enable flake8-bugbear (B) warnings.
+# Unlike Flake8, Ruff doesn't enable pycodestyle warnings (`W`) or
+# McCabe complexity (`C901`) by default.
+select = ["E4", "E7", "E9", "EM", "F", "B"]
+ignore = []
+
+# Allow fix for all enabled rules (when `--fix`) is provided.
+fixable = ["ALL"]
+unfixable = ["B"]
+
+# Allow unused variables when underscore-prefixed.
+dummy-variable-rgx = "^(_+|(_+[a-zA-Z0-9_]*[a-zA-Z0-9]+?))$"
+
+
+[tool.ruff.format]
+# Unlike Black, use single quotes for strings.
+quote-style = "single"
+
+# Like Black, indent with spaces, rather than tabs.
+indent-style = "space"
+
+# Like Black, respect magic trailing commas.
+skip-magic-trailing-comma = false
+
+# Like Black, automatically detect the appropriate line ending.
+line-ending = "auto"
+
+# Enable auto-formatting of code examples in docstrings. Markdown,
+# reStructuredText code/literal blocks and doctests are all supported.
+#
+# This is currently disabled by default, but it is planned for this
+# to be opt-out in the future.
+docstring-code-format = false
+
+# Set the line length limit used when formatting code snippets in
+# docstrings.
+#
+# This only has an effect when the `docstring-code-format` setting is
+# enabled.
+docstring-code-line-length = "dynamic"
+
+[tool.ruff.lint.mccabe]
+max-complexity = 10
+
+[tool.ruff.lint.per-file-ignores]
+"__init__.py" = ["E402", "F401"]

scripts.py

@@ -1,41 +1,67 @@
+import os
 import subprocess
+import sys
 from pathlib import Path
 
 
 def ex_dsl():
-    path = Path.cwd() / "examples" / "dsl" / "."
+    subprocess.run(['tox', 'r', '-e', 'dsl'])
-    subprocess.run(["py", str(path)])
 
 
-def ex_events():
+def ex_callbacks():
-    path = Path.cwd() / "examples" / "events" / "."
+    scriptpath = Path.cwd() / 'examples' / 'events' / 'callbacks' / '.'
-    subprocess.run(["py", str(path)])
+    subprocess.run([sys.executable, str(scriptpath)])
 
 
 def ex_gui():
-    path = Path.cwd() / "examples" / "gui" / "."
+    scriptpath = Path.cwd() / 'examples' / 'gui' / '.'
-    subprocess.run(["py", str(path)])
+    subprocess.run([sys.executable, str(scriptpath)])
 
 
 def ex_levels():
-    path = Path.cwd() / "examples" / "levels" / "."
+    scriptpath = Path.cwd() / 'examples' / 'levels' / '.'
-    subprocess.run(["py", str(path)])
+    subprocess.run([sys.executable, str(scriptpath)])
 
 
 def ex_midi():
-    path = Path.cwd() / "examples" / "midi" / "."
+    scriptpath = Path.cwd() / 'examples' / 'midi' / '.'
-    subprocess.run(["py", str(path)])
+    subprocess.run([sys.executable, str(scriptpath)])
 
 
 def ex_obs():
-    path = Path.cwd() / "examples" / "obs" / "."
+    subprocess.run(['tox', 'r', '-e', 'obs'])
-    subprocess.run(["py", str(path)])
 
 
 def ex_observer():
-    path = Path.cwd() / "examples" / "observer" / "."
+    scriptpath = Path.cwd() / 'examples' / 'events' / 'observer' / '.'
-    subprocess.run(["py", str(path)])
+    subprocess.run([sys.executable, str(scriptpath)])
 
 
-def test():
+def ex_eqedit():
-    subprocess.run(["tox"])
+    scriptpath = Path.cwd() / 'examples' / 'eq_edit' / '.'
+    subprocess.run([sys.executable, str(scriptpath)])
+
+
+def test_basic():
+    subprocess.run(['tox'], env=os.environ.copy() | {'KIND': 'basic'})
+
+
+def test_banana():
+    subprocess.run(['tox'], env=os.environ.copy() | {'KIND': 'banana'})
+
+
+def test_potato():
+    subprocess.run(['tox'], env=os.environ.copy() | {'KIND': 'potato'})
+
+
+def test_all():
+    steps = [test_basic, test_banana, test_potato]
+    for step in steps:
+        step()
+
+
+def generate_badges():
+    for kind in ['basic', 'banana', 'potato']:
+        subprocess.run(
+            ['tox', 'r', '-e', 'genbadge'], env=os.environ.copy() | {'KIND': kind}
+        )

tests/__init__.py

@@ -1,3 +1,4 @@
+import os
 import random
 import sys
 from dataclasses import dataclass
@@ -6,40 +7,54 @@ import voicemeeterlib
 from voicemeeterlib.kinds import KindId
 from voicemeeterlib.kinds import request_kind_map as kindmap
 
-# let's keep things random
-KIND_ID = random.choice(tuple(kind_id.name.lower() for kind_id in KindId))
-vm = voicemeeterlib.api(KIND_ID)
-kind = kindmap(KIND_ID)
-
 
 @dataclass
 class Data:
     """bounds data to map tests to a kind"""
 
-    name: str = kind.name
+    name: str
-    phys_in: int = kind.ins[0] - 1
+    phys_in: int
-    virt_in: int = kind.ins[0] + kind.ins[-1] - 1
+    virt_in: int
-    phys_out: int = kind.outs[0] - 1
+    phys_out: int
-    virt_out: int = kind.outs[0] + kind.outs[-1] - 1
+    virt_out: int
-    vban_in: int = kind.vban[0] - 1
+    vban_in: int
-    vban_out: int = kind.vban[-1] - 1
+    vban_out: int
-    button_lower: int = 0
+    button_lower: int
-    button_upper: int = 79
+    button_upper: int
-    asio_in: int = kind.asio[0] - 1
+    asio_in: int
-    asio_out: int = kind.asio[-1] - 1
+    asio_out: int
-    insert_lower: int = 0
+    insert_lower: int
-    insert_higher: int = kind.insert - 1
+    insert_higher: int
 
     @property
     def channels(self):
         return (2 * self.phys_in) + (8 * self.virt_in)
 
 
-data = Data()
+# get KIND from environment, if not set default to potato
+KIND_ID = os.environ.get('KIND', 'potato')
+vm = voicemeeterlib.api(KIND_ID)
+kind = kindmap(KIND_ID)
+
+data = Data(
+    name=kind.name,
+    phys_in=kind.ins[0] - 1,
+    virt_in=kind.ins[0] + kind.ins[-1] - 1,
+    phys_out=kind.outs[0] - 1,
+    virt_out=kind.outs[0] + kind.outs[-1] - 1,
+    vban_in=kind.vban[0] - 1,
+    vban_out=kind.vban[-1] - 1,
+    button_lower=0,
+    button_upper=79,
+    asio_in=kind.asio[0] - 1,
+    asio_out=kind.asio[-1] - 1,
+    insert_lower=0,
+    insert_higher=kind.insert - 1,
+)
 
 
 def setup_module():
-    print(f"\nRunning tests for kind [{data.name}]\n", file=sys.stdout)
+    print(f'\nRunning tests for kind [{data.name}]\n', file=sys.stdout)
     vm.login()
     vm.command.reset()
 

tests/conftest.py

@@ -1,7 +1,7 @@
 def pytest_addoption(parser):
     parser.addoption(
-        "--run-slow",
+        '--run-slow',
-        action="store_true",
+        action='store_true',
         default=False,
-        help="Run slow tests",
+        help='Run slow tests',
     )

tests/pre-commit.ps1

@@ -1,31 +0,0 @@
-Function RunTests {
-    $coverage = "./tests/pytest_coverage.log"
-    $run_tests = "pytest --run-slow -v --capture=tee-sys --junitxml=./tests/.coverage.xml"
-    $match_pattern = "^=|^\s*$|^Running|^Using|^plugins|^collecting|^tests"
-
-    if ( Test-Path $coverage ) { Clear-Content $coverage }
-
-    ForEach ($line in $(Invoke-Expression $run_tests)) {
-        If ( $line -Match $match_pattern ) {
-            if ( $line -Match "^Running tests for kind \[(\w+)\]" ) { $kind = $Matches[1] }
-            $line | Tee-Object -FilePath $coverage -Append
-        }
-    }
-    Write-Output "$(Get-TimeStamp)" | Out-File $coverage -Append
-
-    Invoke-Expression "genbadge tests -t 90 -i ./tests/.coverage.xml -o ./tests/$kind.svg"
-}
-
-Function Get-TimeStamp {
-
-    return "[{0:MM/dd/yy} {0:HH:mm:ss}]" -f (Get-Date)
-
-}
-
-if ($MyInvocation.InvocationName -ne ".") {
-    Invoke-Expression ".\.venv\Scripts\Activate.ps1"
-
-    RunTests
-
-    Invoke-Expression "deactivate"
-}

tests/reports/badge-banana.svg

@@ -1 +1 @@
-<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="68" height="20" role="img" aria-label="tests: 164"><title>tests: 164</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="68" height="20" rx="3" fill="#fff"/></clipPath><g clip-path="url(#r)"><rect width="37" height="20" fill="#555"/><rect x="37" width="31" height="20" fill="#4c1"/><rect width="68" 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="515" y="150" fill="#010101" fill-opacity=".3" transform="scale(.1)" textLength="210">164</text><text x="515" y="140" transform="scale(.1)" fill="#fff" textLength="210">164</text></g></svg>
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="68" height="20" role="img" aria-label="tests: 158"><title>tests: 158</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="68" height="20" rx="3" fill="#fff"/></clipPath><g clip-path="url(#r)"><rect width="37" height="20" fill="#555"/><rect x="37" width="31" height="20" fill="#4c1"/><rect width="68" 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="515" y="150" fill="#010101" fill-opacity=".3" transform="scale(.1)" textLength="210">158</text><text x="515" y="140" transform="scale(.1)" fill="#fff" textLength="210">158</text></g></svg>

tests/reports/badge-basic.svg

@@ -1 +1 @@
-<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="68" height="20" role="img" aria-label="tests: 139"><title>tests: 139</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="68" height="20" rx="3" fill="#fff"/></clipPath><g clip-path="url(#r)"><rect width="37" height="20" fill="#555"/><rect x="37" width="31" height="20" fill="#4c1"/><rect width="68" 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="515" y="150" fill="#010101" fill-opacity=".3" transform="scale(.1)" textLength="210">139</text><text x="515" y="140" transform="scale(.1)" fill="#fff" textLength="210">139</text></g></svg>
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="68" height="20" role="img" aria-label="tests: 115"><title>tests: 115</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="68" height="20" rx="3" fill="#fff"/></clipPath><g clip-path="url(#r)"><rect width="37" height="20" fill="#555"/><rect x="37" width="31" height="20" fill="#4c1"/><rect width="68" 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="515" y="150" fill="#010101" fill-opacity=".3" transform="scale(.1)" textLength="210">115</text><text x="515" y="140" transform="scale(.1)" fill="#fff" textLength="210">115</text></g></svg>

tests/reports/badge-potato.svg

@@ -1 +1 @@
-<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="68" height="20" role="img" aria-label="tests: 112"><title>tests: 112</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="68" height="20" rx="3" fill="#fff"/></clipPath><g clip-path="url(#r)"><rect width="37" height="20" fill="#555"/><rect x="37" width="31" height="20" fill="#4c1"/><rect width="68" 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="515" y="150" fill="#010101" fill-opacity=".3" transform="scale(.1)" textLength="210">112</text><text x="515" y="140" transform="scale(.1)" fill="#fff" textLength="210">112</text></g></svg>
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="68" height="20" role="img" aria-label="tests: 183"><title>tests: 183</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="68" height="20" rx="3" fill="#fff"/></clipPath><g clip-path="url(#r)"><rect width="37" height="20" fill="#555"/><rect x="37" width="31" height="20" fill="#4c1"/><rect width="68" 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="515" y="150" fill="#010101" fill-opacity=".3" transform="scale(.1)" textLength="210">183</text><text x="515" y="140" transform="scale(.1)" fill="#fff" textLength="210">183</text></g></svg>

tests/test_configs.py

@@ -10,39 +10,39 @@ class TestUserConfigs:
 
     @classmethod
     def setup_class(cls):
-        vm.apply_config("example")
+        vm.apply_config('example')
 
-    def test_it_vm_config_string(self):
+    def test_it_tests_vm_config_string(self):
-        assert "PhysStrip" in vm.strip[data.phys_in].label
+        assert 'PhysStrip' in vm.strip[data.phys_in].label
-        assert "VirtStrip" in vm.strip[data.virt_in].label
+        assert 'VirtStrip' in vm.strip[data.virt_in].label
-        assert "PhysBus" in vm.bus[data.phys_out].label
+        assert 'PhysBus' in vm.bus[data.phys_out].label
-        assert "VirtBus" in vm.bus[data.virt_out].label
+        assert 'VirtBus' in vm.bus[data.virt_out].label
 
-    def test_it_vm_config_bool(self):
+    def test_it_tests_vm_config_bool(self):
         assert vm.strip[0].A1 == True
 
     @pytest.mark.skipif(
-        data.name != "potato",
+        data.name != 'potato',
-        reason="Skip test if kind is not potato",
+        reason='Skip test if kind is not potato',
     )
-    def test_it_vm_config_bool_strip_eq_on(self):
+    def test_it_tests_vm_config_bool_strip_eq_on(self):
         assert vm.strip[data.phys_in].eq.on == True
 
     @pytest.mark.skipif(
-        data.name != "banana",
+        data.name != 'banana',
-        reason="Skip test if kind is not banana",
+        reason='Skip test if kind is not banana',
     )
-    def test_it_vm_config_bool_bus_eq_ab(self):
+    def test_it_tests_vm_config_bool_bus_eq_ab(self):
         assert vm.bus[data.phys_out].eq.ab == True
 
     @pytest.mark.skipif(
         "not config.getoption('--run-slow')",
-        reason="Only run when --run-slow is given",
+        reason='Only run when --run-slow is given',
     )
-    def test_it_vm_config_busmode(self):
+    def test_it_tests_vm_config_busmode(self):
-        assert vm.bus[data.phys_out].mode.get() == "composite"
+        assert vm.bus[data.phys_out].mode.get() == 'composite'
 
-    def test_it_vm_config_bass_med_high(self):
+    def test_it_tests_vm_config_bass_med_high(self):
         assert vm.strip[data.virt_in].bass == -3.2
         assert vm.strip[data.virt_in].mid == 1.5
         assert vm.strip[data.virt_in].high == 2.1

tests/test_errors.py

@@ -0,0 +1,49 @@
+import re
+
+import pytest
+
+import voicemeeterlib
+from tests import vm
+
+
+class TestErrors:
+    __test__ = True
+
+    def test_it_tests_an_unknown_kind(self):
+        with pytest.raises(
+            voicemeeterlib.error.VMError,
+            match="Unknown Voicemeeter kind 'unknown_kind'",
+        ):
+            voicemeeterlib.api('unknown_kind')
+
+    def test_it_tests_an_unknown_parameter(self):
+        with pytest.raises(
+            voicemeeterlib.error.CAPIError,
+            match='VBVMR_SetParameterFloat returned -3',
+        ) as exc_info:
+            vm.set('unknown.parameter', 1)
+
+        e = exc_info.value
+        assert e.code == -3
+        assert e.fn_name == 'VBVMR_SetParameterFloat'
+
+    def test_it_tests_an_unknown_config_name(self):
+        EXPECTED_MSG = (
+            "No config with name 'unknown' is loaded into memory",
+            f'Known configs: {list(vm.configs.keys())}',
+        )
+
+        with pytest.raises(
+            voicemeeterlib.error.VMError, match=re.escape('\n'.join(EXPECTED_MSG))
+        ):
+            vm.apply_config('unknown')
+
+    def test_it_tests_an_invalid_config_key(self):
+        CONFIG = {
+            'strip-0': {'A1': True, 'B1': True, 'gain': -6.0},
+            'bus-0': {'mute': True, 'eq': {'on': True}},
+            'unknown-0': {'state': True},
+            'vban-out-1': {'name': 'streamname'},
+        }
+        with pytest.raises(ValueError, match="invalid config key 'unknown-0'"):
+            vm.apply(CONFIG)

tests/test_factory.py

@@ -7,60 +7,60 @@ class TestRemoteFactories:
     __test__ = True
 
     @pytest.mark.skipif(
-        data.name != "basic",
+        data.name != 'basic',
-        reason="Skip test if kind is not basic",
+        reason='Skip test if kind is not basic',
     )
-    def test_it_vm_remote_attrs_for_basic(self):
+    def test_it_tests_vm_remote_attrs_for_basic(self):
-        assert hasattr(vm, "strip")
+        assert hasattr(vm, 'strip')
-        assert hasattr(vm, "bus")
+        assert hasattr(vm, 'bus')
-        assert hasattr(vm, "command")
+        assert hasattr(vm, 'command')
-        assert hasattr(vm, "button")
+        assert hasattr(vm, 'button')
-        assert hasattr(vm, "vban")
+        assert hasattr(vm, 'vban')
-        assert hasattr(vm, "device")
+        assert hasattr(vm, 'device')
-        assert hasattr(vm, "option")
+        assert hasattr(vm, 'option')
 
         assert len(vm.strip) == 3
         assert len(vm.bus) == 2
         assert len(vm.button) == 80
-        assert len(vm.vban.instream) == 4 and len(vm.vban.outstream) == 4
+        assert len(vm.vban.instream) == 6 and len(vm.vban.outstream) == 5
 
     @pytest.mark.skipif(
-        data.name != "banana",
+        data.name != 'banana',
-        reason="Skip test if kind is not banana",
+        reason='Skip test if kind is not banana',
     )
-    def test_it_vm_remote_attrs_for_banana(self):
+    def test_it_tests_vm_remote_attrs_for_banana(self):
-        assert hasattr(vm, "strip")
+        assert hasattr(vm, 'strip')
-        assert hasattr(vm, "bus")
+        assert hasattr(vm, 'bus')
-        assert hasattr(vm, "command")
+        assert hasattr(vm, 'command')
-        assert hasattr(vm, "button")
+        assert hasattr(vm, 'button')
-        assert hasattr(vm, "vban")
+        assert hasattr(vm, 'vban')
-        assert hasattr(vm, "device")
+        assert hasattr(vm, 'device')
-        assert hasattr(vm, "option")
+        assert hasattr(vm, 'option')
-        assert hasattr(vm, "recorder")
+        assert hasattr(vm, 'recorder')
-        assert hasattr(vm, "patch")
+        assert hasattr(vm, 'patch')
 
         assert len(vm.strip) == 5
         assert len(vm.bus) == 5
         assert len(vm.button) == 80
-        assert len(vm.vban.instream) == 8 and len(vm.vban.outstream) == 8
+        assert len(vm.vban.instream) == 10 and len(vm.vban.outstream) == 9
 
     @pytest.mark.skipif(
-        data.name != "potato",
+        data.name != 'potato',
-        reason="Skip test if kind is not potato",
+        reason='Skip test if kind is not potato',
     )
-    def test_it_vm_remote_attrs_for_potato(self):
+    def test_it_tests_vm_remote_attrs_for_potato(self):
-        assert hasattr(vm, "strip")
+        assert hasattr(vm, 'strip')
-        assert hasattr(vm, "bus")
+        assert hasattr(vm, 'bus')
-        assert hasattr(vm, "command")
+        assert hasattr(vm, 'command')
-        assert hasattr(vm, "button")
+        assert hasattr(vm, 'button')
-        assert hasattr(vm, "vban")
+        assert hasattr(vm, 'vban')
-        assert hasattr(vm, "device")
+        assert hasattr(vm, 'device')
-        assert hasattr(vm, "option")
+        assert hasattr(vm, 'option')
-        assert hasattr(vm, "recorder")
+        assert hasattr(vm, 'recorder')
-        assert hasattr(vm, "patch")
+        assert hasattr(vm, 'patch')
-        assert hasattr(vm, "fx")
+        assert hasattr(vm, 'fx')
 
         assert len(vm.strip) == 8
         assert len(vm.bus) == 8
         assert len(vm.button) == 80
-        assert len(vm.vban.instream) == 8 and len(vm.vban.outstream) == 8
+        assert len(vm.vban.instream) == 10 and len(vm.vban.outstream) == 9

tests/test_higher.py

@@ -3,19 +3,18 @@ import pytest
 from tests import data, vm
 
 
-@pytest.mark.parametrize("value", [False, True])
+@pytest.mark.parametrize('value', [False, True])
 class TestSetAndGetBoolHigher:
     __test__ = True
 
     """strip tests, physical and virtual"""
 
     @pytest.mark.parametrize(
-        "index,param",
+        'index,param',
         [
-            (data.phys_in, "mute"),
+            (data.phys_in, 'mute'),
-            (data.phys_in, "mono"),
+            (data.phys_in, 'mono'),
-            (data.virt_in, "mc"),
+            (data.virt_in, 'mc'),
-            (data.virt_in, "mono"),
         ],
     )
     def test_it_sets_and_gets_strip_bool_params(self, index, param, value):
@@ -25,14 +24,14 @@ class TestSetAndGetBoolHigher:
     """ strip EQ tests, physical """
 
     @pytest.mark.skipif(
-        data.name != "potato",
+        data.name != 'potato',
-        reason="Skip test if kind is not potato",
+        reason='Skip test if kind is not potato',
     )
     @pytest.mark.parametrize(
-        "index,param",
+        'index,param',
         [
-            (data.phys_in, "on"),
+            (data.phys_in, 'on'),
-            (data.phys_in, "ab"),
+            (data.phys_in, 'ab'),
         ],
     )
     def test_it_sets_and_gets_strip_eq_bool_params(self, index, param, value):
@@ -43,10 +42,10 @@ class TestSetAndGetBoolHigher:
     """ bus tests, physical and virtual """
 
     @pytest.mark.parametrize(
-        "index,param",
+        'index,param',
         [
-            (data.phys_out, "mute"),
+            (data.phys_out, 'mute'),
-            (data.virt_out, "sel"),
+            (data.virt_out, 'sel'),
         ],
     )
     def test_it_sets_and_gets_bus_bool_params(self, index, param, value):
@@ -57,10 +56,10 @@ class TestSetAndGetBoolHigher:
     """ bus EQ tests, physical and virtual """
 
     @pytest.mark.parametrize(
-        "index,param",
+        'index,param',
         [
-            (data.phys_out, "on"),
+            (data.phys_out, 'on'),
-            (data.virt_out, "ab"),
+            (data.virt_out, 'ab'),
         ],
     )
     def test_it_sets_and_gets_bus_eq_bool_params(self, index, param, value):
@@ -71,16 +70,16 @@ class TestSetAndGetBoolHigher:
     """  bus modes tests, physical and virtual """
 
     @pytest.mark.skipif(
-        data.name != "basic",
+        data.name != 'basic',
-        reason="Skip test if kind is not basic",
+        reason='Skip test if kind is not basic',
     )
     @pytest.mark.parametrize(
-        "index,param",
+        'index,param',
         [
-            (data.phys_out, "normal"),
+            (data.phys_out, 'normal'),
-            (data.phys_out, "amix"),
+            (data.phys_out, 'amix'),
-            (data.virt_out, "normal"),
+            (data.virt_out, 'normal'),
-            (data.virt_out, "composite"),
+            (data.virt_out, 'composite'),
         ],
     )
     def test_it_sets_and_gets_busmode_basic_bool_params(self, index, param, value):
@@ -88,18 +87,18 @@ class TestSetAndGetBoolHigher:
         assert getattr(vm.bus[index].mode, param) == value
 
     @pytest.mark.skipif(
-        data.name == "basic",
+        data.name == 'basic',
-        reason="Skip test if kind is basic",
+        reason='Skip test if kind is basic',
     )
     @pytest.mark.parametrize(
-        "index,param",
+        'index,param',
         [
-            (data.phys_out, "normal"),
+            (data.phys_out, 'normal'),
-            (data.phys_out, "amix"),
+            (data.phys_out, 'amix'),
-            (data.phys_out, "rearonly"),
+            (data.phys_out, 'rearonly'),
-            (data.virt_out, "normal"),
+            (data.virt_out, 'normal'),
-            (data.virt_out, "upmix41"),
+            (data.virt_out, 'upmix41'),
-            (data.virt_out, "composite"),
+            (data.virt_out, 'composite'),
         ],
     )
     def test_it_sets_and_gets_busmode_bool_params(self, index, param, value):
@@ -109,8 +108,8 @@ class TestSetAndGetBoolHigher:
     """ macrobutton tests """
 
     @pytest.mark.parametrize(
-        "index,param",
+        'index,param',
-        [(data.button_lower, "state"), (data.button_upper, "trigger")],
+        [(data.button_lower, 'state'), (data.button_upper, 'trigger')],
     )
     def test_it_sets_and_gets_macrobutton_bool_params(self, index, param, value):
         setattr(vm.button[index], param, value)
@@ -119,8 +118,8 @@ class TestSetAndGetBoolHigher:
     """ vban instream tests """
 
     @pytest.mark.parametrize(
-        "index,param",
+        'index,param',
-        [(data.vban_in, "on")],
+        [(data.vban_in, 'on')],
     )
     def test_it_sets_and_gets_vban_instream_bool_params(self, index, param, value):
         setattr(vm.vban.instream[index], param, value)
@@ -129,8 +128,8 @@ class TestSetAndGetBoolHigher:
     """ vban outstream tests """
 
     @pytest.mark.parametrize(
-        "index,param",
+        'index,param',
-        [(data.vban_out, "on")],
+        [(data.vban_out, 'on')],
     )
     def test_it_sets_and_gets_vban_outstream_bool_params(self, index, param, value):
         setattr(vm.vban.outstream[index], param, value)
@@ -139,8 +138,8 @@ class TestSetAndGetBoolHigher:
     """ command tests """
 
     @pytest.mark.parametrize(
-        "param",
+        'param',
-        [("lock")],
+        [('lock')],
     )
     def test_it_sets_command_bool_params(self, param, value):
         setattr(vm.command, param, value)
@@ -148,37 +147,87 @@ class TestSetAndGetBoolHigher:
     """ recorder tests """
 
     @pytest.mark.skipif(
-        data.name == "basic",
+        data.name == 'basic',
-        reason="Skip test if kind is basic",
+        reason='Skip test if kind is basic',
     )
     @pytest.mark.parametrize(
-        "param",
+        'param',
-        [("A1"), ("B2")],
+        [('A1'), ('B2')],
     )
     def test_it_sets_and_gets_recorder_bool_params(self, param, value):
+        assert hasattr(vm.recorder, param)
         setattr(vm.recorder, param, value)
         assert getattr(vm.recorder, param) == value
 
     @pytest.mark.skipif(
-        data.name == "basic",
+        data.name == 'basic',
-        reason="Skip test if kind is basic",
+        reason='Skip test if kind is basic',
     )
     @pytest.mark.parametrize(
-        "param",
+        'param',
-        [("loop")],
+        [('loop')],
     )
     def test_it_sets_recorder_bool_params(self, param, value):
+        assert hasattr(vm.recorder, param)
         setattr(vm.recorder, param, value)
+        assert getattr(vm.recorder, param) == value
+
+    """ recoder.mode tests """
+
+    @pytest.mark.skipif(
+        data.name == 'basic',
+        reason='Skip test if kind is basic',
+    )
+    @pytest.mark.parametrize(
+        'param',
+        [('loop'), ('recbus')],
+    )
+    def test_it_sets_recorder_mode_bool_params(self, param, value):
+        assert hasattr(vm.recorder.mode, param)
+        setattr(vm.recorder.mode, param, value)
+        assert getattr(vm.recorder.mode, param) == value
+
+    """ recorder.armstrip """
+
+    @pytest.mark.skipif(
+        data.name == 'basic',
+        reason='Skip test if kind is basic',
+    )
+    @pytest.mark.parametrize(
+        'index',
+        [
+            (data.phys_out),
+            (data.virt_out),
+        ],
+    )
+    def test_it_sets_recorder_armstrip_bool_params(self, index, value):
+        vm.recorder.armstrip[index].set(value)
+
+    """ recorder.armbus """
+
+    @pytest.mark.skipif(
+        data.name == 'basic',
+        reason='Skip test if kind is basic',
+    )
+    @pytest.mark.parametrize(
+        'index',
+        [
+            (data.phys_out),
+            (data.virt_out),
+        ],
+    )
+    def test_it_sets_recorder_armbus_bool_params(self, index, value):
+        vm.recorder.armbus[index].set(True)
 
     """ fx tests """
 
     @pytest.mark.skipif(
-        data.name != "potato",
+        data.name != 'potato',
-        reason="Skip test if kind is not potato",
+        reason='Skip test if kind is not potato',
     )
     @pytest.mark.parametrize(
-        "param",
+        'param',
-        [("reverb"), ("reverb_ab"), ("delay"), ("delay_ab")],
+        [('reverb'), ('reverb_ab'), ('delay'), ('delay_ab')],
     )
     def test_it_sets_and_gets_fx_bool_params(self, param, value):
         setattr(vm.fx, param, value)
@@ -187,12 +236,12 @@ class TestSetAndGetBoolHigher:
     """ patch tests """
 
     @pytest.mark.skipif(
-        data.name == "basic",
+        data.name == 'basic',
-        reason="Skip test if kind is basic",
+        reason='Skip test if kind is basic',
     )
     @pytest.mark.parametrize(
-        "param",
+        'param',
-        [("postfadercomposite")],
+        [('postfadercomposite')],
     )
     def test_it_sets_and_gets_patch_bool_params(self, param, value):
         setattr(vm.patch, param, value)
@@ -201,12 +250,12 @@ class TestSetAndGetBoolHigher:
     """ patch.insert tests """
 
     @pytest.mark.skipif(
-        data.name == "basic",
+        data.name == 'basic',
-        reason="Skip test if kind is basic",
+        reason='Skip test if kind is basic',
     )
     @pytest.mark.parametrize(
-        "index, param",
+        'index, param',
-        [(data.insert_lower, "on"), (data.insert_higher, "on")],
+        [(data.insert_lower, 'on'), (data.insert_higher, 'on')],
     )
     def test_it_sets_and_gets_patch_insert_bool_params(self, index, param, value):
         setattr(vm.patch.insert[index], param, value)
@@ -215,8 +264,8 @@ class TestSetAndGetBoolHigher:
     """ option tests """
 
     @pytest.mark.parametrize(
-        "param",
+        'param',
-        [("monitoronsel")],
+        [('monitoronsel')],
     )
     def test_it_sets_and_gets_option_bool_params(self, param, value):
         setattr(vm.option, param, value)
@@ -229,36 +278,49 @@ class TestSetAndGetIntHigher:
     """strip tests, physical and virtual"""
 
     @pytest.mark.parametrize(
-        "index,param,value",
+        'index,param,value',
         [
-            (data.phys_in, "limit", -40),
+            (data.phys_in, 'limit', -40),
-            (data.phys_in, "limit", 12),
+            (data.phys_in, 'limit', 12),
-            (data.virt_in, "k", 0),
+            (data.virt_in - 1, 'k', 0),
-            (data.virt_in, "k", 4),
+            (data.virt_in - 1, 'k', 4),
         ],
     )
-    def test_it_sets_and_gets_strip_bool_params(self, index, param, value):
+    def test_it_sets_and_gets_strip_int_params(self, index, param, value):
         setattr(vm.strip[index], param, value)
         assert getattr(vm.strip[index], param) == value
 
+    """ bus tests, physical """
+
+    @pytest.mark.parametrize(
+        'index,param,value',
+        [
+            (data.phys_out, 'mono', 0),
+            (data.phys_out, 'mono', 2),
+        ],
+    )
+    def test_it_sets_and_gets_bus_int_params(self, index, param, value):
+        setattr(vm.bus[index], param, value)
+        assert getattr(vm.bus[index], param) == value
+
     """ vban outstream tests """
 
     @pytest.mark.parametrize(
-        "index,param,value",
+        'index,param,value',
-        [(data.vban_out, "sr", 48000)],
+        [(data.vban_out, 'sr', 48000)],
     )
-    def test_it_sets_and_gets_vban_outstream_bool_params(self, index, param, value):
+    def test_it_sets_and_gets_vban_outstream_int_params(self, index, param, value):
         setattr(vm.vban.outstream[index], param, value)
         assert getattr(vm.vban.outstream[index], param) == value
 
     """ patch.asio tests """
 
     @pytest.mark.skipif(
-        data.name == "basic",
+        data.name == 'basic',
-        reason="Skip test if kind is basic",
+        reason='Skip test if kind is basic',
     )
     @pytest.mark.parametrize(
-        "index,value",
+        'index,value',
         [
             (0, 1),
             (data.asio_in, 4),
@@ -271,11 +333,11 @@ class TestSetAndGetIntHigher:
     """ patch.A2[i]-A5[i] tests """
 
     @pytest.mark.skipif(
-        data.name == "basic",
+        data.name == 'basic',
-        reason="Skip test if kind is basic",
+        reason='Skip test if kind is basic',
     )
     @pytest.mark.parametrize(
-        "index,value",
+        'index,value',
         [
             (0, 1),
             (data.asio_out, 4),
@@ -290,11 +352,11 @@ class TestSetAndGetIntHigher:
     """ patch.composite tests """
 
     @pytest.mark.skipif(
-        data.name == "basic",
+        data.name == 'basic',
-        reason="Skip test if kind is basic",
+        reason='Skip test if kind is basic',
     )
     @pytest.mark.parametrize(
-        "index,value",
+        'index,value',
         [
             (0, 3),
             (0, data.channels),
@@ -309,11 +371,11 @@ class TestSetAndGetIntHigher:
     """ option tests """
 
     @pytest.mark.skipif(
-        data.name == "basic",
+        data.name == 'basic',
-        reason="Skip test if kind is basic",
+        reason='Skip test if kind is basic',
     )
     @pytest.mark.parametrize(
-        "index,value",
+        'index,value',
         [
             (data.phys_out, 30),
             (data.phys_out, 500),
@@ -323,6 +385,26 @@ class TestSetAndGetIntHigher:
         vm.option.delay[index].set(value)
         assert vm.option.delay[index].get() == value
 
+    """ recorder tests """
+
+    @pytest.mark.skipif(
+        data.name == 'basic',
+        reason='Skip test if kind is basic',
+    )
+    @pytest.mark.parametrize(
+        'param,value',
+        [
+            ('samplerate', 32000),
+            ('samplerate', 96000),
+            ('bitresolution', 16),
+            ('bitresolution', 32),
+        ],
+    )
+    def test_it_sets_and_gets_recorder_int_params(self, param, value):
+        assert hasattr(vm.recorder, param)
+        setattr(vm.recorder, param, value)
+        assert getattr(vm.recorder, param) == value
+
 
 class TestSetAndGetFloatHigher:
     __test__ = True
@@ -330,10 +412,10 @@ class TestSetAndGetFloatHigher:
     """strip tests, physical and virtual"""
 
     @pytest.mark.parametrize(
-        "index,param,value",
+        'index,param,value',
         [
-            (data.phys_in, "gain", -3.6),
+            (data.phys_in, 'gain', -3.6),
-            (data.virt_in, "gain", 5.8),
+            (data.virt_in, 'gain', 5.8),
         ],
     )
     def test_it_sets_and_gets_strip_float_params(self, index, param, value):
@@ -341,25 +423,25 @@ class TestSetAndGetFloatHigher:
         assert getattr(vm.strip[index], param) == value
 
     @pytest.mark.parametrize(
-        "index,value",
+        'index,value',
         [(data.phys_in, 2), (data.phys_in, 2), (data.virt_in, 8), (data.virt_in, 8)],
     )
     def test_it_gets_prefader_levels_and_compares_length_of_array(self, index, value):
         assert len(vm.strip[index].levels.prefader) == value
 
     @pytest.mark.parametrize(
-        "index,value",
+        'index,value',
         [(data.phys_in, 2), (data.phys_in, 2), (data.virt_in, 8), (data.virt_in, 8)],
     )
     def test_it_gets_postmute_levels_and_compares_length_of_array(self, index, value):
         assert len(vm.strip[index].levels.postmute) == value
 
     @pytest.mark.skipif(
-        data.name != "potato",
+        data.name != 'potato',
-        reason="Only test if logged into Potato version",
+        reason='Only test if logged into Potato version',
     )
     @pytest.mark.parametrize(
-        "index, j, value",
+        'index, j, value',
         [
             (data.phys_in, 0, -20.7),
             (data.virt_in, 3, -60),
@@ -374,12 +456,12 @@ class TestSetAndGetFloatHigher:
     """ strip tests, physical """
 
     @pytest.mark.parametrize(
-        "index, param, value",
+        'index, param, value',
         [
-            (data.phys_in, "pan_x", -0.6),
+            (data.phys_in, 'pan_x', -0.6),
-            (data.phys_in, "pan_x", 0.6),
+            (data.phys_in, 'pan_x', 0.6),
-            (data.phys_in, "color_y", 0.8),
+            (data.phys_in, 'color_y', 0.8),
-            (data.phys_in, "fx_x", -0.6),
+            (data.phys_in, 'fx_x', -0.6),
         ],
     )
     def test_it_sets_and_gets_strip_xy_params(self, index, param, value):
@@ -388,14 +470,14 @@ class TestSetAndGetFloatHigher:
         assert getattr(vm.strip[index], param) == value
 
     @pytest.mark.skipif(
-        data.name != "potato",
+        data.name != 'potato',
-        reason="Only test if logged into Potato version",
+        reason='Only test if logged into Potato version',
     )
     @pytest.mark.parametrize(
-        "index, param, value",
+        'index, param, value',
         [
-            (data.phys_in, "reverb", -1.6),
+            (data.phys_in, 'reverb', -1.6),
-            (data.phys_in, "postfx1", True),
+            (data.phys_in, 'postfx1', True),
         ],
     )
     def test_it_sets_and_gets_strip_effects_params(self, index, param, value):
@@ -404,14 +486,14 @@ class TestSetAndGetFloatHigher:
         assert getattr(vm.strip[index], param) == value
 
     @pytest.mark.skipif(
-        data.name != "potato",
+        data.name != 'potato',
-        reason="Only test if logged into Potato version",
+        reason='Only test if logged into Potato version',
     )
     @pytest.mark.parametrize(
-        "index, param, value",
+        'index, param, value',
         [
-            (data.phys_in, "gainin", -8.6),
+            (data.phys_in, 'gainin', -8.6),
-            (data.phys_in, "knee", 0.5),
+            (data.phys_in, 'knee', 0.5),
         ],
     )
     def test_it_sets_and_gets_strip_comp_params(self, index, param, value):
@@ -420,14 +502,14 @@ class TestSetAndGetFloatHigher:
         assert getattr(vm.strip[index].comp, param) == value
 
     @pytest.mark.skipif(
-        data.name != "potato",
+        data.name != 'potato',
-        reason="Only test if logged into Potato version",
+        reason='Only test if logged into Potato version',
     )
     @pytest.mark.parametrize(
-        "index, param, value",
+        'index, param, value',
         [
-            (data.phys_in, "bpsidechain", 120),
+            (data.phys_in, 'bpsidechain', 120),
-            (data.phys_in, "hold", 3000),
+            (data.phys_in, 'hold', 3000),
         ],
     )
     def test_it_sets_and_gets_strip_gate_params(self, index, param, value):
@@ -436,13 +518,13 @@ class TestSetAndGetFloatHigher:
         assert getattr(vm.strip[index].gate, param) == value
 
     @pytest.mark.skipif(
-        data.name != "potato",
+        data.name != 'potato',
-        reason="Only test if logged into Potato version",
+        reason='Only test if logged into Potato version',
     )
     @pytest.mark.parametrize(
-        "index, param, value",
+        'index, param, value',
         [
-            (data.phys_in, "knob", -8.6),
+            (data.phys_in, 'knob', -8.6),
         ],
     )
     def test_it_sets_and_gets_strip_denoiser_params(self, index, param, value):
@@ -452,13 +534,13 @@ class TestSetAndGetFloatHigher:
     """ strip tests, virtual """
 
     @pytest.mark.parametrize(
-        "index, param, value",
+        'index, param, value',
         [
-            (data.virt_in, "pan_x", -0.6),
+            (data.virt_in, 'pan_x', -0.6),
-            (data.virt_in, "pan_x", 0.6),
+            (data.virt_in, 'pan_x', 0.6),
-            (data.virt_in, "treble", -1.6),
+            (data.virt_in, 'treble', -1.6),
-            (data.virt_in, "mid", 5.8),
+            (data.virt_in, 'mid', 5.8),
-            (data.virt_in, "bass", -8.1),
+            (data.virt_in, 'bass', -8.1),
         ],
     )
     def test_it_sets_and_gets_strip_eq_params(self, index, param, value):
@@ -468,12 +550,12 @@ class TestSetAndGetFloatHigher:
     """ bus tests, physical and virtual """
 
     @pytest.mark.skipif(
-        data.name != "potato",
+        data.name != 'potato',
-        reason="Only test if logged into Potato version",
+        reason='Only test if logged into Potato version',
     )
     @pytest.mark.parametrize(
-        "index, param, value",
+        'index, param, value',
-        [(data.phys_out, "returnreverb", 3.6), (data.virt_out, "returnfx1", 5.8)],
+        [(data.phys_out, 'returnreverb', 3.6), (data.virt_out, 'returnfx1', 5.8)],
     )
     def test_it_sets_and_gets_bus_effects_float_params(self, index, param, value):
         assert hasattr(vm.bus[index], param)
@@ -481,30 +563,30 @@ class TestSetAndGetFloatHigher:
         assert getattr(vm.bus[index], param) == value
 
     @pytest.mark.parametrize(
-        "index, param, value",
+        'index, param, value',
-        [(data.phys_out, "gain", -3.6), (data.virt_out, "gain", 5.8)],
+        [(data.phys_out, 'gain', -3.6), (data.virt_out, 'gain', 5.8)],
     )
     def test_it_sets_and_gets_bus_float_params(self, index, param, value):
         setattr(vm.bus[index], param, value)
         assert getattr(vm.bus[index], param) == value
 
     @pytest.mark.parametrize(
-        "index,value",
+        'index,value',
         [(data.phys_out, 8), (data.virt_out, 8)],
     )
-    def test_it_gets_prefader_levels_and_compares_length_of_array(self, index, value):
+    def test_it_gets_bus_levels_and_compares_length_of_array(self, index, value):
         assert len(vm.bus[index].levels.all) == value
 
 
-@pytest.mark.parametrize("value", ["test0", "test1"])
+@pytest.mark.parametrize('value', ['test0', 'test1'])
 class TestSetAndGetStringHigher:
     __test__ = True
 
     """strip tests, physical and virtual"""
 
     @pytest.mark.parametrize(
-        "index, param",
+        'index, param',
-        [(data.phys_in, "label"), (data.virt_in, "label")],
+        [(data.phys_in, 'label'), (data.virt_in, 'label')],
     )
     def test_it_sets_and_gets_strip_string_params(self, index, param, value):
         setattr(vm.strip[index], param, value)
@@ -513,8 +595,8 @@ class TestSetAndGetStringHigher:
     """ bus tests, physical and virtual """
 
     @pytest.mark.parametrize(
-        "index, param",
+        'index, param',
-        [(data.phys_out, "label"), (data.virt_out, "label")],
+        [(data.phys_out, 'label'), (data.virt_out, 'label')],
     )
     def test_it_sets_and_gets_bus_string_params(self, index, param, value):
         setattr(vm.bus[index], param, value)
@@ -523,8 +605,8 @@ class TestSetAndGetStringHigher:
     """ vban instream tests """
 
     @pytest.mark.parametrize(
-        "index, param",
+        'index, param',
-        [(data.vban_in, "name")],
+        [(data.vban_in, 'name')],
     )
     def test_it_sets_and_gets_vban_instream_string_params(self, index, param, value):
         setattr(vm.vban.instream[index], param, value)
@@ -533,29 +615,29 @@ class TestSetAndGetStringHigher:
     """ vban outstream tests """
 
     @pytest.mark.parametrize(
-        "index, param",
+        'index, param',
-        [(data.vban_out, "name")],
+        [(data.vban_out, 'name')],
     )
     def test_it_sets_and_gets_vban_outstream_string_params(self, index, param, value):
         setattr(vm.vban.outstream[index], param, value)
         assert getattr(vm.vban.outstream[index], param) == value
 
 
-@pytest.mark.parametrize("value", [False, True])
+@pytest.mark.parametrize('value', [False, True])
 class TestSetAndGetMacroButtonHigher:
     __test__ = True
 
     """macrobutton tests"""
 
     @pytest.mark.parametrize(
-        "index, param",
+        'index, param',
         [
-            (0, "state"),
+            (0, 'state'),
-            (39, "stateonly"),
+            (39, 'stateonly'),
-            (69, "trigger"),
+            (69, 'trigger'),
-            (22, "stateonly"),
+            (22, 'stateonly'),
-            (45, "state"),
+            (45, 'state'),
-            (65, "trigger"),
+            (65, 'trigger'),
         ],
     )
     def test_it_sets_and_gets_macrobutton_params(self, index, param, value):

tests/test_lower.py

@@ -9,12 +9,12 @@ class TestSetAndGetFloatLower:
     """VBVMR_SetParameterFloat, VBVMR_GetParameterFloat"""
 
     @pytest.mark.parametrize(
-        "param,value",
+        'param,value',
         [
-            (f"Strip[{data.phys_in}].Mute", 1),
+            (f'Strip[{data.phys_in}].Mute', 1),
-            (f"Bus[{data.virt_out}].Eq.on", 1),
+            (f'Bus[{data.virt_out}].Eq.on', 1),
-            (f"Strip[{data.phys_in}].Mute", 0),
+            (f'Strip[{data.phys_in}].Mute', 0),
-            (f"Bus[{data.virt_out}].Eq.on", 0),
+            (f'Bus[{data.virt_out}].Eq.on', 0),
         ],
     )
     def test_it_sets_and_gets_mute_eq_float_params(self, param, value):
@@ -22,11 +22,11 @@ class TestSetAndGetFloatLower:
         assert (round(vm.get(param))) == value
 
     @pytest.mark.parametrize(
-        "param,value",
+        'param,value',
         [
-            (f"Strip[{data.phys_in}].Comp", 5.3),
+            (f'Strip[{data.phys_in}].Comp', 5.3),
-            (f"Strip[{data.virt_in}].Gain", -37.5),
+            (f'Strip[{data.virt_in}].Gain', -37.5),
-            (f"Bus[{data.virt_out}].Gain", -22.7),
+            (f'Bus[{data.virt_out}].Gain', -22.7),
         ],
     )
     def test_it_sets_and_gets_comp_gain_float_params(self, param, value):
@@ -34,29 +34,29 @@ class TestSetAndGetFloatLower:
         assert (round(vm.get(param), 1)) == value
 
 
-@pytest.mark.parametrize("value", ["test0", "test1"])
+@pytest.mark.parametrize('value', ['test0', 'test1'])
 class TestSetAndGetStringLower:
     __test__ = True
 
     """VBVMR_SetParameterStringW, VBVMR_GetParameterStringW"""
 
     @pytest.mark.parametrize(
-        "param",
+        'param',
-        [(f"Strip[{data.phys_out}].label"), (f"Bus[{data.virt_out}].label")],
+        [(f'Strip[{data.phys_out}].label'), (f'Bus[{data.virt_out}].label')],
     )
     def test_it_sets_and_gets_string_params(self, param, value):
         vm.set(param, value)
         assert vm.get(param, string=True) == value
 
 
-@pytest.mark.parametrize("value", [0, 1])
+@pytest.mark.parametrize('value', [0, 1])
 class TestMacroButtonsLower:
     __test__ = True
 
     """VBVMR_MacroButton_SetStatus, VBVMR_MacroButton_GetStatus"""
 
     @pytest.mark.parametrize(
-        "index, mode",
+        'index, mode',
         [(33, 1), (49, 1)],
     )
     def test_it_sets_and_gets_macrobuttons_state(self, index, mode, value):
@@ -64,7 +64,7 @@ class TestMacroButtonsLower:
         assert vm.get_buttonstatus(index, mode) == value
 
     @pytest.mark.parametrize(
-        "index, mode",
+        'index, mode',
         [(14, 2), (12, 2)],
     )
     def test_it_sets_and_gets_macrobuttons_stateonly(self, index, mode, value):
@@ -72,7 +72,7 @@ class TestMacroButtonsLower:
         assert vm.get_buttonstatus(index, mode) == value
 
     @pytest.mark.parametrize(
-        "index, mode",
+        'index, mode',
         [(50, 3), (65, 3)],
     )
     def test_it_sets_and_gets_macrobuttons_trigger(self, index, mode, value):

tox.ini

@@ -0,0 +1,42 @@
+[tox]
+envlist = py310,py311,py312,py313
+
+[testenv]
+passenv = *
+setenv = VIRTUALENV_DISCOVERY=pyenv
+allowlist_externals = poetry
+commands_pre =
+    poetry install --no-interaction --no-root
+commands =
+    poetry run pytest tests
+
+[testenv:genbadge]
+passenv = *
+setenv = VIRTUALENV_DISCOVERY=pyenv
+allowlist_externals = poetry
+deps =
+    genbadge[all]
+    pytest-html
+commands_pre =
+    poetry install --no-interaction --no-root
+commands =
+    poetry run pytest --capture=tee-sys --junitxml=./tests/reports/junit-${KIND}.xml --html=./tests/reports/${KIND}.html tests
+    poetry run genbadge tests -t 90 -i ./tests/reports/junit-${KIND}.xml -o ./tests/reports/badge-${KIND}.svg
+
+[testenv:dsl]
+setenv = VIRTUALENV_DISCOVERY=pyenv
+allowlist_externals = poetry
+deps = pyparsing
+commands_pre =
+    poetry install --no-interaction --no-root --without dev
+commands =
+    poetry run python examples/dsl
+
+[testenv:obs]
+setenv = VIRTUALENV_DISCOVERY=pyenv
+allowlist_externals = poetry
+deps = obsws-python
+commands_pre =
+    poetry install --no-interaction --no-root --without dev
+commands =
+    poetry run python examples/obs

voicemeeterlib/__init__.py

@@ -1,3 +1,3 @@
 from .factory import request_remote_obj as api
 
-__ALL__ = ["api"]
+__ALL__ = ['api']

voicemeeterlib/bus.py

@@ -1,16 +1,16 @@
+import abc
 import time
-from abc import abstractmethod
 from enum import IntEnum
 from math import log
 from typing import Union
 
+from . import kinds
 from .iremote import IRemote
-from .kinds import kinds_all
 from .meta import bus_mode_prop, device_prop, float_prop
 
 BusModes = IntEnum(
-    "BusModes",
+    'BusModes',
-    "normal amix bmix repeat composite tvmix upmix21 upmix41 upmix61 centeronly lfeonly rearonly",
+    'normal amix bmix repeat composite tvmix upmix21 upmix41 upmix61 centeronly lfeonly rearonly',
     start=0,
 )
 
@@ -22,91 +22,188 @@ class Bus(IRemote):
     Defines concrete implementation for bus
     """
 
-    @abstractmethod
+    @abc.abstractmethod
     def __str__(self):
         pass
 
     @property
     def identifier(self) -> str:
-        return f"bus[{self.index}]"
+        return f'bus[{self.index}]'
 
     @property
     def mute(self) -> bool:
-        return self.getter("mute") == 1
+        return self.getter('mute') == 1
 
     @mute.setter
     def mute(self, val: bool):
-        self.setter("mute", 1 if val else 0)
+        self.setter('mute', 1 if val else 0)
 
     @property
-    def mono(self) -> bool:
+    def mono(self) -> int:
-        return self.getter("mono") == 1
+        return int(self.getter('mono'))
 
     @mono.setter
-    def mono(self, val: bool):
+    def mono(self, val: int):
-        self.setter("mono", 1 if val else 0)
+        self.setter('mono', val)
 
     @property
     def sel(self) -> bool:
-        return self.getter("sel") == 1
+        return self.getter('sel') == 1
 
     @sel.setter
     def sel(self, val: bool):
-        self.setter("sel", 1 if val else 0)
+        self.setter('sel', 1 if val else 0)
 
     @property
     def label(self) -> str:
-        return self.getter("Label", is_string=True)
+        return self.getter('Label', is_string=True)
 
     @label.setter
     def label(self, val: str):
-        self.setter("Label", str(val))
+        self.setter('Label', str(val))
 
     @property
     def gain(self) -> float:
-        return round(self.getter("gain"), 1)
+        return round(self.getter('gain'), 1)
 
     @gain.setter
     def gain(self, val: float):
-        self.setter("gain", val)
+        self.setter('gain', val)
 
     @property
     def monitor(self) -> bool:
-        return self.getter("monitor") == 1
+        return self.getter('monitor') == 1
 
     @monitor.setter
     def monitor(self, val: bool):
-        self.setter("monitor", 1 if val else 0)
+        self.setter('monitor', 1 if val else 0)
 
     def fadeto(self, target: float, time_: int):
-        self.setter("FadeTo", f"({target}, {time_})")
+        self.setter('FadeTo', f'({target}, {time_})')
         time.sleep(self._remote.DELAY)
 
     def fadeby(self, change: float, time_: int):
-        self.setter("FadeBy", f"({change}, {time_})")
+        self.setter('FadeBy', f'({change}, {time_})')
         time.sleep(self._remote.DELAY)
 
 
 class BusEQ(IRemote):
+    @classmethod
+    def make(cls, remote, i):
+        """
+        Factory method for BusEQ.
+
+        Returns a BusEQ class.
+        """
+        BusEQ_cls = type(
+            'BusEQ',
+            (cls,),
+            {
+                'channel': tuple(
+                    BusEQCh.make(remote, i, j) for j in range(remote.kind.bus_channels)
+                )
+            },
+        )
+        return BusEQ_cls(remote, i)
+
     @property
     def identifier(self) -> str:
-        return f"Bus[{self.index}].eq"
+        return f'Bus[{self.index}].eq'
 
     @property
     def on(self) -> bool:
-        return self.getter("on") == 1
+        return self.getter('on') == 1
 
     @on.setter
     def on(self, val: bool):
-        self.setter("on", 1 if val else 0)
+        self.setter('on', 1 if val else 0)
 
     @property
     def ab(self) -> bool:
-        return self.getter("ab") == 1
+        return self.getter('ab') == 1
 
     @ab.setter
     def ab(self, val: bool):
-        self.setter("ab", 1 if val else 0)
+        self.setter('ab', 1 if val else 0)
+
+
+class BusEQCh(IRemote):
+    @classmethod
+    def make(cls, remote, i, j):
+        """
+        Factory method for Bus EQ channel.
+
+        Returns a BusEQCh class.
+        """
+        BusEQCh_cls = type(
+            'BusEQCh',
+            (cls,),
+            {
+                'cell': tuple(
+                    BusEQChCell(remote, i, j, k) for k in range(remote.kind.cells)
+                )
+            },
+        )
+        return BusEQCh_cls(remote, i, j)
+
+    def __init__(self, remote, i, j):
+        super().__init__(remote, i)
+        self.channel_index = j
+
+    @property
+    def identifier(self) -> str:
+        return f'Bus[{self.index}].eq.channel[{self.channel_index}]'
+
+
+class BusEQChCell(IRemote):
+    def __init__(self, remote, i, j, k):
+        super().__init__(remote, i)
+        self.channel_index = j
+        self.cell_index = k
+
+    @property
+    def identifier(self) -> str:
+        return f'Bus[{self.index}].eq.channel[{self.channel_index}].cell[{self.cell_index}]'
+
+    @property
+    def on(self) -> bool:
+        return self.getter('on') == 1
+
+    @on.setter
+    def on(self, val: bool):
+        self.setter('on', 1 if val else 0)
+
+    @property
+    def type(self) -> int:
+        return int(self.getter('type'))
+
+    @type.setter
+    def type(self, val: int):
+        self.setter('type', val)
+
+    @property
+    def f(self) -> float:
+        return round(self.getter('f'), 1)
+
+    @f.setter
+    def f(self, val: float):
+        self.setter('f', val)
+
+    @property
+    def gain(self) -> float:
+        return round(self.getter('gain'), 1)
+
+    @gain.setter
+    def gain(self, val: float):
+        self.setter('gain', val)
+
+    @property
+    def q(self) -> float:
+        return round(self.getter('q'), 1)
+
+    @q.setter
+    def q(self, val: float):
+        self.setter('q', val)
 
 
 class PhysicalBus(Bus):
@@ -118,19 +215,19 @@ class PhysicalBus(Bus):
         Returns a PhysicalBus class.
         """
         kls = (cls,)
-        if kind.name == "potato":
+        if kind.name == 'potato':
             EFFECTS_cls = _make_effects_mixin()
             kls += (EFFECTS_cls,)
         return type(
-            "PhysicalBus",
+            'PhysicalBus',
             kls,
             {
-                "device": BusDevice.make(remote, i),
+                'device': BusDevice.make(remote, i),
             },
         )
 
     def __str__(self):
-        return f"{type(self).__name__}{self.index}"
+        return f'{type(self).__name__}{self.index}'
 
 
 class BusDevice(IRemote):
@@ -142,16 +239,16 @@ class BusDevice(IRemote):
         Returns a BusDevice class of a kind.
         """
         DEVICE_cls = type(
-            f"BusDevice{remote.kind}",
+            f'BusDevice{remote.kind}',
             (cls,),
             {
                 **{
                     param: device_prop(param)
                     for param in [
-                        "wdm",
+                        'wdm',
-                        "ks",
+                        'ks',
-                        "mme",
+                        'mme',
-                        "asio",
+                        'asio',
                     ]
                 },
             },
@@ -160,20 +257,20 @@ class BusDevice(IRemote):
 
     @property
     def identifier(self) -> str:
-        return f"Bus[{self.index}].device"
+        return f'Bus[{self.index}].device'
 
     @property
     def name(self) -> str:
-        return self.getter("name", is_string=True)
+        return self.getter('name', is_string=True)
 
     @property
     def sr(self) -> int:
-        return int(self.getter("sr"))
+        return int(self.getter('sr'))
 
 
 class VirtualBus(Bus):
     @classmethod
-    def make(cls, kind):
+    def make(cls, remote, i, kind):
         """
         Factory method for VirtualBus.
 
@@ -182,15 +279,21 @@ class VirtualBus(Bus):
         Returns a VirtualBus class.
         """
         kls = (cls,)
-        if kind.name == "basic":
+        if kind.name == 'basic':
-            kls += (PhysicalBus,)
+            return type(
-        elif kind.name == "potato":
+                'VirtualBus',
+                kls,
+                {
+                    'device': BusDevice.make(remote, i),
+                },
+            )
+        elif kind.name == 'potato':
             EFFECTS_cls = _make_effects_mixin()
             kls += (EFFECTS_cls,)
-        return type("VirtualBus", kls, {})
+        return type('VirtualBus', kls, {})
 
     def __str__(self):
-        return f"{type(self).__name__}{self.index}"
+        return f'{type(self).__name__}{self.index}'
 
 
 class BusLevel(IRemote):
@@ -210,8 +313,8 @@ class BusLevel(IRemote):
         def fget(x):
             return round(20 * log(x, 10), 1) if x > 0 else -200.0
 
-        if self._remote.running and self._remote.event.ldirty:
+        if not self._remote.stopped() and self._remote.event.ldirty:
-            vals = self._remote.cache["bus_level"][self.range[0] : self.range[-1]]
+            vals = self._remote.cache['bus_level'][self.range[0] : self.range[-1]]
         else:
             vals = [self._remote.get_level(mode, i) for i in range(*self.range)]
 
@@ -219,7 +322,7 @@ class BusLevel(IRemote):
 
     @property
     def identifier(self) -> str:
-        return f"Bus[{self.index}]"
+        return f'Bus[{self.index}]'
 
     @property
     def all(self) -> tuple:
@@ -232,7 +335,7 @@ class BusLevel(IRemote):
 
         Expected to be used in a callback only.
         """
-        if self._remote.running:
+        if not self._remote.stopped():
             return any(self._remote._bus_comp[self.range[0] : self.range[-1]])
 
     is_updated = isdirty
@@ -242,14 +345,14 @@ def make_bus_level_map(kind):
     return tuple((i, i + 8) for i in range(0, (kind.phys_out + kind.virt_out) * 8, 8))
 
 
-_make_bus_level_maps = {kind.name: make_bus_level_map(kind) for kind in kinds_all}
+_make_bus_level_maps = {kind.name: make_bus_level_map(kind) for kind in kinds.all}
 
 
 def _make_bus_mode_mixin():
     """Creates a mixin of Bus Modes."""
 
     def identifier(self) -> str:
-        return f"Bus[{self.index}].mode"
+        return f'Bus[{self.index}].mode'
 
     def get(self) -> str:
         time.sleep(0.01)
@@ -270,15 +373,15 @@ def _make_bus_mode_mixin():
         ):
             if val:
                 return BusModes(i + 1).name
-        return "normal"
+        return 'normal'
 
     return type(
-        "BusModeMixin",
+        'BusModeMixin',
         (IRemote,),
         {
-            "identifier": property(identifier),
+            'identifier': property(identifier),
             **{mode.name: bus_mode_prop(mode.name) for mode in BusModes},
-            "get": get,
+            'get': get,
         },
     )
 
@@ -286,12 +389,12 @@ def _make_bus_mode_mixin():
 def _make_effects_mixin():
     """creates an fx mixin"""
     return type(
-        "FX",
+        'FX',
         (),
         {
             **{
-                f"return{param}": float_prop(f"return{param}")
+                f'return{param}': float_prop(f'return{param}')
-                for param in ["reverb", "delay", "fx1", "fx2"]
+                for param in ['reverb', 'delay', 'fx1', 'fx2']
             },
         },
     )
@@ -306,16 +409,16 @@ def bus_factory(is_phys_bus, remote, i) -> Union[PhysicalBus, VirtualBus]:
     BUS_cls = (
         PhysicalBus.make(remote, i, remote.kind)
         if is_phys_bus
-        else VirtualBus.make(remote.kind)
+        else VirtualBus.make(remote, i, remote.kind)
     )
     BUSMODEMIXIN_cls = _make_bus_mode_mixin()
     return type(
-        f"{BUS_cls.__name__}{remote.kind}",
+        f'{BUS_cls.__name__}{remote.kind}',
         (BUS_cls,),
         {
-            "levels": BusLevel(remote, i),
+            'levels': BusLevel(remote, i),
-            "mode": BUSMODEMIXIN_cls(remote, i),
+            'mode': BUSMODEMIXIN_cls(remote, i),
-            "eq": BusEQ(remote, i),
+            'eq': BusEQ.make(remote, i),
         },
     )(remote, i)
 

voicemeeterlib/cbindings.py

@@ -1,6 +1,5 @@
 import ctypes as ct
 import logging
-from abc import ABCMeta
 from ctypes.wintypes import CHAR, FLOAT, LONG, WCHAR
 
 from .error import CAPIError
@@ -9,117 +8,207 @@ from .inst import libc
 logger = logging.getLogger(__name__)
 
 
-class CBindings(metaclass=ABCMeta):
+class CBindings:
-    """
+    """Class responsible for defining C function bindings.
-    C bindings defined here.
 
-    Maps expected ctype argument and res types for each binding.
+    Wrapper methods are provided for each C function to handle error checking and logging.
     """
 
-    logger_cbindings = logger.getChild("Cbindings")
+    logger_cbindings = logger.getChild('CBindings')
 
-    vm_login = libc.VBVMR_Login
+    bind_login = libc.VBVMR_Login
-    vm_login.restype = LONG
+    bind_login.restype = LONG
-    vm_login.argtypes = None
+    bind_login.argtypes = None
 
-    vm_logout = libc.VBVMR_Logout
+    bind_logout = libc.VBVMR_Logout
-    vm_logout.restype = LONG
+    bind_logout.restype = LONG
-    vm_logout.argtypes = None
+    bind_logout.argtypes = None
 
-    vm_runvm = libc.VBVMR_RunVoicemeeter
+    bind_run_voicemeeter = libc.VBVMR_RunVoicemeeter
-    vm_runvm.restype = LONG
+    bind_run_voicemeeter.restype = LONG
-    vm_runvm.argtypes = [LONG]
+    bind_run_voicemeeter.argtypes = [LONG]
 
-    vm_get_type = libc.VBVMR_GetVoicemeeterType
+    bind_get_voicemeeter_type = libc.VBVMR_GetVoicemeeterType
-    vm_get_type.restype = LONG
+    bind_get_voicemeeter_type.restype = LONG
-    vm_get_type.argtypes = [ct.POINTER(LONG)]
+    bind_get_voicemeeter_type.argtypes = [ct.POINTER(LONG)]
 
-    vm_get_version = libc.VBVMR_GetVoicemeeterVersion
+    bind_get_voicemeeter_version = libc.VBVMR_GetVoicemeeterVersion
-    vm_get_version.restype = LONG
+    bind_get_voicemeeter_version.restype = LONG
-    vm_get_version.argtypes = [ct.POINTER(LONG)]
+    bind_get_voicemeeter_version.argtypes = [ct.POINTER(LONG)]
 
-    if hasattr(libc, "VBVMR_MacroButton_IsDirty"):
+    if hasattr(libc, 'VBVMR_MacroButton_IsDirty'):
-        vm_mdirty = libc.VBVMR_MacroButton_IsDirty
+        bind_macro_button_is_dirty = libc.VBVMR_MacroButton_IsDirty
-        vm_mdirty.restype = LONG
+        bind_macro_button_is_dirty.restype = LONG
-        vm_mdirty.argtypes = None
+        bind_macro_button_is_dirty.argtypes = None
 
-    if hasattr(libc, "VBVMR_MacroButton_GetStatus"):
+    if hasattr(libc, 'VBVMR_MacroButton_GetStatus'):
-        vm_get_buttonstatus = libc.VBVMR_MacroButton_GetStatus
+        bind_macro_button_get_status = libc.VBVMR_MacroButton_GetStatus
-        vm_get_buttonstatus.restype = LONG
+        bind_macro_button_get_status.restype = LONG
-        vm_get_buttonstatus.argtypes = [LONG, ct.POINTER(FLOAT), LONG]
+        bind_macro_button_get_status.argtypes = [LONG, ct.POINTER(FLOAT), LONG]
 
-    if hasattr(libc, "VBVMR_MacroButton_SetStatus"):
+    if hasattr(libc, 'VBVMR_MacroButton_SetStatus'):
-        vm_set_buttonstatus = libc.VBVMR_MacroButton_SetStatus
+        bind_macro_button_set_status = libc.VBVMR_MacroButton_SetStatus
-        vm_set_buttonstatus.restype = LONG
+        bind_macro_button_set_status.restype = LONG
-        vm_set_buttonstatus.argtypes = [LONG, FLOAT, LONG]
+        bind_macro_button_set_status.argtypes = [LONG, FLOAT, LONG]
 
-    vm_pdirty = libc.VBVMR_IsParametersDirty
+    bind_is_parameters_dirty = libc.VBVMR_IsParametersDirty
-    vm_pdirty.restype = LONG
+    bind_is_parameters_dirty.restype = LONG
-    vm_pdirty.argtypes = None
+    bind_is_parameters_dirty.argtypes = None
 
-    vm_get_parameter_float = libc.VBVMR_GetParameterFloat
+    bind_get_parameter_float = libc.VBVMR_GetParameterFloat
-    vm_get_parameter_float.restype = LONG
+    bind_get_parameter_float.restype = LONG
-    vm_get_parameter_float.argtypes = [ct.POINTER(CHAR), ct.POINTER(FLOAT)]
+    bind_get_parameter_float.argtypes = [ct.POINTER(CHAR), ct.POINTER(FLOAT)]
 
-    vm_set_parameter_float = libc.VBVMR_SetParameterFloat
+    bind_set_parameter_float = libc.VBVMR_SetParameterFloat
-    vm_set_parameter_float.restype = LONG
+    bind_set_parameter_float.restype = LONG
-    vm_set_parameter_float.argtypes = [ct.POINTER(CHAR), FLOAT]
+    bind_set_parameter_float.argtypes = [ct.POINTER(CHAR), FLOAT]
 
-    vm_get_parameter_string = libc.VBVMR_GetParameterStringW
+    bind_get_parameter_string_w = libc.VBVMR_GetParameterStringW
-    vm_get_parameter_string.restype = LONG
+    bind_get_parameter_string_w.restype = LONG
-    vm_get_parameter_string.argtypes = [ct.POINTER(CHAR), ct.POINTER(WCHAR * 512)]
+    bind_get_parameter_string_w.argtypes = [ct.POINTER(CHAR), ct.POINTER(WCHAR * 512)]
 
-    vm_set_parameter_string = libc.VBVMR_SetParameterStringW
+    bind_set_parameter_string_w = libc.VBVMR_SetParameterStringW
-    vm_set_parameter_string.restype = LONG
+    bind_set_parameter_string_w.restype = LONG
-    vm_set_parameter_string.argtypes = [ct.POINTER(CHAR), ct.POINTER(WCHAR)]
+    bind_set_parameter_string_w.argtypes = [ct.POINTER(CHAR), ct.POINTER(WCHAR)]
 
-    vm_set_parameter_multi = libc.VBVMR_SetParameters
+    bind_set_parameters = libc.VBVMR_SetParameters
-    vm_set_parameter_multi.restype = LONG
+    bind_set_parameters.restype = LONG
-    vm_set_parameter_multi.argtypes = [ct.POINTER(CHAR)]
+    bind_set_parameters.argtypes = [ct.POINTER(CHAR)]
 
-    vm_get_level = libc.VBVMR_GetLevel
+    bind_get_level = libc.VBVMR_GetLevel
-    vm_get_level.restype = LONG
+    bind_get_level.restype = LONG
-    vm_get_level.argtypes = [LONG, LONG, ct.POINTER(FLOAT)]
+    bind_get_level.argtypes = [LONG, LONG, ct.POINTER(FLOAT)]
 
-    vm_get_num_indevices = libc.VBVMR_Input_GetDeviceNumber
+    bind_input_get_device_number = libc.VBVMR_Input_GetDeviceNumber
-    vm_get_num_indevices.restype = LONG
+    bind_input_get_device_number.restype = LONG
-    vm_get_num_indevices.argtypes = None
+    bind_input_get_device_number.argtypes = None
 
-    vm_get_desc_indevices = libc.VBVMR_Input_GetDeviceDescW
+    bind_input_get_device_desc_w = libc.VBVMR_Input_GetDeviceDescW
-    vm_get_desc_indevices.restype = LONG
+    bind_input_get_device_desc_w.restype = LONG
-    vm_get_desc_indevices.argtypes = [
+    bind_input_get_device_desc_w.argtypes = [
         LONG,
         ct.POINTER(LONG),
         ct.POINTER(WCHAR * 256),
         ct.POINTER(WCHAR * 256),
     ]
 
-    vm_get_num_outdevices = libc.VBVMR_Output_GetDeviceNumber
+    bind_output_get_device_number = libc.VBVMR_Output_GetDeviceNumber
-    vm_get_num_outdevices.restype = LONG
+    bind_output_get_device_number.restype = LONG
-    vm_get_num_outdevices.argtypes = None
+    bind_output_get_device_number.argtypes = None
 
-    vm_get_desc_outdevices = libc.VBVMR_Output_GetDeviceDescW
+    bind_output_get_device_desc_w = libc.VBVMR_Output_GetDeviceDescW
-    vm_get_desc_outdevices.restype = LONG
+    bind_output_get_device_desc_w.restype = LONG
-    vm_get_desc_outdevices.argtypes = [
+    bind_output_get_device_desc_w.argtypes = [
         LONG,
         ct.POINTER(LONG),
         ct.POINTER(WCHAR * 256),
         ct.POINTER(WCHAR * 256),
     ]
 
-    vm_get_midi_message = libc.VBVMR_GetMidiMessage
+    bind_get_midi_message = libc.VBVMR_GetMidiMessage
-    vm_get_midi_message.restype = LONG
+    bind_get_midi_message.restype = LONG
-    vm_get_midi_message.argtypes = [ct.POINTER(CHAR * 1024), LONG]
+    bind_get_midi_message.argtypes = [ct.POINTER(CHAR * 1024), LONG]
 
-    def call(self, func, *args, ok=(0,), ok_exp=None):
+    def _call(self, func, *args, ok=(0,), ok_exp=None):
+        """Call a C function and handle errors."""
         try:
             res = func(*args)
             if ok_exp is None:
                 if res not in ok:
-                    raise CAPIError(f"{func.__name__} returned {res}")
+                    raise CAPIError(func.__name__, res)
-            elif not ok_exp(res):
+            elif not ok_exp(res) and res not in ok:
-                raise CAPIError(f"{func.__name__} returned {res}")
+                raise CAPIError(func.__name__, res)
             return res
         except CAPIError as e:
-            self.logger_cbindings.exception(f"{type(e).__name__}: {e}")
+            self.logger_cbindings.exception(f'{type(e).__name__}: {e}')
             raise
+
+    def login(self, **kwargs):
+        """Login to Voicemeeter API"""
+        return self._call(self.bind_login, **kwargs)
+
+    def logout(self):
+        """Logout from Voicemeeter API"""
+        return self._call(self.bind_logout)
+
+    def run_voicemeeter(self, value):
+        """Run Voicemeeter with specified type"""
+        return self._call(self.bind_run_voicemeeter, value)
+
+    def get_voicemeeter_type(self, type_ref):
+        """Get Voicemeeter type"""
+        return self._call(self.bind_get_voicemeeter_type, type_ref)
+
+    def get_voicemeeter_version(self, version_ref):
+        """Get Voicemeeter version"""
+        return self._call(self.bind_get_voicemeeter_version, version_ref)
+
+    def is_parameters_dirty(self, **kwargs):
+        """Check if parameters are dirty"""
+        return self._call(self.bind_is_parameters_dirty, **kwargs)
+
+    def macro_button_is_dirty(self, **kwargs):
+        """Check if macro button parameters are dirty"""
+        if hasattr(self, 'bind_macro_button_is_dirty'):
+            return self._call(self.bind_macro_button_is_dirty, **kwargs)
+        raise AttributeError('macro_button_is_dirty not available')
+
+    def get_parameter_float(self, param_name, value_ref):
+        """Get float parameter value"""
+        return self._call(self.bind_get_parameter_float, param_name, value_ref)
+
+    def set_parameter_float(self, param_name, value):
+        """Set float parameter value"""
+        return self._call(self.bind_set_parameter_float, param_name, value)
+
+    def get_parameter_string_w(self, param_name, buffer_ref):
+        """Get string parameter value (Unicode)"""
+        return self._call(self.bind_get_parameter_string_w, param_name, buffer_ref)
+
+    def set_parameter_string_w(self, param_name, value):
+        """Set string parameter value (Unicode)"""
+        return self._call(self.bind_set_parameter_string_w, param_name, value)
+
+    def macro_button_get_status(self, id_, state_ref, mode):
+        """Get macro button status"""
+        if hasattr(self, 'bind_macro_button_get_status'):
+            return self._call(self.bind_macro_button_get_status, id_, state_ref, mode)
+        raise AttributeError('macro_button_get_status not available')
+
+    def macro_button_set_status(self, id_, state, mode):
+        """Set macro button status"""
+        if hasattr(self, 'bind_macro_button_set_status'):
+            return self._call(self.bind_macro_button_set_status, id_, state, mode)
+        raise AttributeError('macro_button_set_status not available')
+
+    def get_level(self, type_, index, value_ref):
+        """Get audio level"""
+        return self._call(self.bind_get_level, type_, index, value_ref)
+
+    def input_get_device_number(self, **kwargs):
+        """Get number of input devices"""
+        return self._call(self.bind_input_get_device_number, **kwargs)
+
+    def output_get_device_number(self, **kwargs):
+        """Get number of output devices"""
+        return self._call(self.bind_output_get_device_number, **kwargs)
+
+    def input_get_device_desc_w(self, index, type_ref, name_ref, hwid_ref):
+        """Get input device description"""
+        return self._call(
+            self.bind_input_get_device_desc_w, index, type_ref, name_ref, hwid_ref
+        )
+
+    def output_get_device_desc_w(self, index, type_ref, name_ref, hwid_ref):
+        """Get output device description"""
+        return self._call(
+            self.bind_output_get_device_desc_w, index, type_ref, name_ref, hwid_ref
+        )
+
+    def get_midi_message(self, buffer_ref, length, **kwargs):
+        """Get MIDI message"""
+        return self._call(self.bind_get_midi_message, buffer_ref, length, **kwargs)
+
+    def set_parameters(self, script):
+        """Set multiple parameters via script"""
+        return self._call(self.bind_set_parameters, script)

voicemeeterlib/command.py

@@ -17,33 +17,33 @@ class Command(IRemote):
         Returns a Command class of a kind.
         """
         CMD_cls = type(
-            f"Command{remote.kind}",
+            f'Command{remote.kind}',
             (cls,),
             {
                 **{
-                    param: action_fn(param) for param in ["show", "shutdown", "restart"]
+                    param: action_fn(param) for param in ['show', 'shutdown', 'restart']
                 },
-                "hide": action_fn("show", val=0),
+                'hide': action_fn('show', val=0),
             },
         )
         return CMD_cls(remote)
 
     def __str__(self):
-        return f"{type(self).__name__}"
+        return f'{type(self).__name__}'
 
     @property
     def identifier(self) -> str:
-        return "Command"
+        return 'Command'
 
     def set_showvbanchat(self, val: bool):
-        self.setter("DialogShow.VBANCHAT", 1 if val else 0)
+        self.setter('DialogShow.VBANCHAT', 1 if val else 0)
 
     showvbanchat = property(fset=set_showvbanchat)
 
     def set_lock(self, val: bool):
-        self.setter("lock", 1 if val else 0)
+        self.setter('lock', 1 if val else 0)
 
     lock = property(fset=set_lock)
 
     def reset(self):
-        self._remote.apply_config("reset")
+        self._remote.apply_config('reset')

voicemeeterlib/config.py

@@ -20,72 +20,72 @@ class TOMLStrBuilder:
     def __init__(self, kind):
         self.kind = kind
         self.higher = itertools.chain(
-            [f"strip-{i}" for i in range(kind.num_strip)],
+            [f'strip-{i}' for i in range(kind.num_strip)],
-            [f"bus-{i}" for i in range(kind.num_bus)],
+            [f'bus-{i}' for i in range(kind.num_bus)],
         )
 
     def init_config(self, profile=None):
         self.virt_strip_params = (
             [
-                "mute = false",
+                'mute = false',
-                "mono = false",
+                'mono = false',
-                "solo = false",
+                'solo = false',
-                "gain = 0.0",
+                'gain = 0.0',
             ]
-            + [f"A{i} = false" for i in range(1, self.kind.phys_out + 1)]
+            + [f'A{i} = false' for i in range(1, self.kind.phys_out + 1)]
-            + [f"B{i} = false" for i in range(1, self.kind.virt_out + 1)]
+            + [f'B{i} = false' for i in range(1, self.kind.virt_out + 1)]
         )
         self.phys_strip_params = self.virt_strip_params + [
-            "comp.knob = 0.0",
+            'comp.knob = 0.0',
-            "gate.knob = 0.0",
+            'gate.knob = 0.0',
-            "denoiser.knob = 0.0",
+            'denoiser.knob = 0.0',
-            "eq.on = false",
+            'eq.on = false',
         ]
         self.bus_params = [
-            "mono = false",
+            'mono = false',
-            "eq.on = false",
+            'eq.on = false',
-            "mute = false",
+            'mute = false',
-            "gain = 0.0",
+            'gain = 0.0',
         ]
 
-        if profile == "reset":
+        if profile == 'reset':
             self.reset_config()
 
     def reset_config(self):
         self.phys_strip_params = list(
-            map(lambda x: x.replace("B1 = false", "B1 = true"), self.phys_strip_params)
+            map(lambda x: x.replace('B1 = false', 'B1 = true'), self.phys_strip_params)
         )
         self.virt_strip_params = list(
-            map(lambda x: x.replace("A1 = false", "A1 = true"), self.virt_strip_params)
+            map(lambda x: x.replace('A1 = false', 'A1 = true'), self.virt_strip_params)
         )
 
-    def build(self, profile="reset"):
+    def build(self, profile='reset'):
         self.init_config(profile)
         toml_str = str()
         for eachclass in self.higher:
-            toml_str += f"[{eachclass}]\n"
+            toml_str += f'[{eachclass}]\n'
             toml_str = self.join(eachclass, toml_str)
         return toml_str
 
     def join(self, eachclass, toml_str):
-        kls, index = eachclass.split("-")
+        kls, index = eachclass.split('-')
         match kls:
-            case "strip":
+            case 'strip':
-                toml_str += ("\n").join(
+                toml_str += ('\n').join(
                     self.phys_strip_params
                     if int(index) < self.kind.phys_in
                     else self.virt_strip_params
                 )
-            case "bus":
+            case 'bus':
-                toml_str += ("\n").join(self.bus_params)
+                toml_str += ('\n').join(self.bus_params)
             case _:
                 pass
-        return toml_str + "\n"
+        return toml_str + '\n'
 
 
 class TOMLDataExtractor:
     def __init__(self, file):
-        with open(file, "rb") as f:
+        with open(file, 'rb') as f:
             self._data = tomllib.load(f)
 
     @property
@@ -103,10 +103,10 @@ def dataextraction_factory(file):
 
     this opens the possibility for other parsers to be added
     """
-    if file.suffix == ".toml":
+    if file.suffix == '.toml':
         extractor = TOMLDataExtractor
     else:
-        raise ValueError("Cannot extract data from {}".format(file))
+        raise ValueError('Cannot extract data from {}'.format(file))
     return extractor(file)
 
 
@@ -140,20 +140,25 @@ class Loader(metaclass=SingletonType):
     def defaults(self, kind):
         self.builder = TOMLStrBuilder(kind)
         toml_str = self.builder.build()
-        self.register("reset", tomllib.loads(toml_str))
+        self.register('reset', tomllib.loads(toml_str))
 
     def parse(self, identifier, data):
         if identifier in self._configs:
             self.logger.info(
-                f"config file with name {identifier} already in memory, skipping.."
+                f'config file with name {identifier} already in memory, skipping..'
             )
-            return False
+            return
-        self.parser = dataextraction_factory(data)
+        try:
+            self.parser = dataextraction_factory(data)
+        except tomllib.TOMLDecodeError as e:
+            ERR_MSG = (str(e), f'When attempting to load {identifier}.toml')
+            self.logger.error(f"{type(e).__name__}: {' '.join(ERR_MSG)}")
+            return
         return True
 
     def register(self, identifier, data=None):
         self._configs[identifier] = data if data else self.parser.data
-        self.logger.info(f"config {self.name}/{identifier} loaded into memory")
+        self.logger.info(f'config {self.name}/{identifier} loaded into memory')
 
     def deregister(self):
         self._configs.clear()
@@ -176,18 +181,18 @@ def loader(kind):
 
     returns configs loaded into memory
     """
-    logger_loader = logger.getChild("loader")
+    logger_loader = logger.getChild('loader')
     loader = Loader(kind)
 
     for path in (
-        Path.cwd() / "configs" / kind.name,
+        Path.cwd() / 'configs' / kind.name,
-        Path.home() / ".config" / "voicemeeter" / kind.name,
+        Path.home() / '.config' / 'voicemeeter' / kind.name,
-        Path.home() / "Documents" / "Voicemeeter" / "configs" / kind.name,
+        Path.home() / 'Documents' / 'Voicemeeter' / 'configs' / kind.name,
     ):
         if path.is_dir():
-            logger_loader.info(f"Checking [{path}] for TOML config files:")
+            logger_loader.info(f'Checking [{path}] for TOML config files:')
-            for file in path.glob("*.toml"):
+            for file in path.glob('*.toml'):
-                identifier = file.with_suffix("").stem
+                identifier = file.with_suffix('').stem
                 if loader.parse(identifier, file):
                     loader.register(identifier)
     return loader.configs
@@ -202,5 +207,5 @@ def request_config(kind_id: str):
     try:
         configs = loader(kindmap(kind_id))
     except KeyError as e:
-        raise VMError(f"Unknown Voicemeeter kind {kind_id}") from e
+        raise VMError(f'Unknown Voicemeeter kind {kind_id}') from e
     return configs

voicemeeterlib/device.py

@@ -1,4 +1,4 @@
-from abc import abstractmethod
+import abc
 from typing import Union
 
 from .iremote import IRemote
@@ -7,19 +7,19 @@ from .iremote import IRemote
 class Adapter(IRemote):
     """Adapter to the common interface."""
 
-    @abstractmethod
+    @abc.abstractmethod
     def ins(self):
         pass
 
-    @abstractmethod
+    @abc.abstractmethod
     def outs(self):
         pass
 
-    @abstractmethod
+    @abc.abstractmethod
     def input(self):
         pass
 
-    @abstractmethod
+    @abc.abstractmethod
     def output(self):
         pass
 
@@ -31,8 +31,8 @@ class Adapter(IRemote):
             return self._remote.get_num_devices(direction)
 
         vals = self._remote.get_device_description(index, direction)
-        types = {1: "mme", 3: "wdm", 4: "ks", 5: "asio"}
+        types = {1: 'mme', 3: 'wdm', 4: 'ks', 5: 'asio'}
-        return {"name": vals[0], "type": types[vals[1]], "id": vals[2]}
+        return {'name': vals[0], 'type': types[vals[1]], 'id': vals[2]}
 
 
 class Device(Adapter):
@@ -47,26 +47,26 @@ class Device(Adapter):
         """
 
         def num_ins(cls) -> int:
-            return cls.getter(direction="in")
+            return cls.getter(direction='in')
 
         def num_outs(cls) -> int:
-            return cls.getter(direction="out")
+            return cls.getter(direction='out')
 
         DEVICE_cls = type(
-            f"Device{remote.kind}",
+            f'Device{remote.kind}',
             (cls,),
             {
-                "ins": property(num_ins),
+                'ins': property(num_ins),
-                "outs": property(num_outs),
+                'outs': property(num_outs),
             },
         )
         return DEVICE_cls(remote)
 
     def __str__(self):
-        return f"{type(self).__name__}"
+        return f'{type(self).__name__}'
 
     def input(self, index: int) -> dict:
-        return self.getter(index=index, direction="in")
+        return self.getter(index=index, direction='in')
 
     def output(self, index: int) -> dict:
-        return self.getter(index=index, direction="out")
+        return self.getter(index=index, direction='out')

voicemeeterlib/error.py

@@ -1,10 +1,24 @@
-class InstallError(Exception):
+class VMError(Exception):
+    """Base voicemeeterlib exception class."""
+
+
+class InstallError(VMError):
     """Exception raised when installation errors occur"""
 
 
-class CAPIError(Exception):
+class CAPIError(VMError):
-    """Exception raised when the C-API returns error values"""
+    """Exception raised when the C-API returns an error code"""
 
-
+    def __init__(self, fn_name, code):
-class VMError(Exception):
+        self.fn_name = fn_name
-    """Exception raised when general errors occur"""
+        self.code = code
+        if self.code == -9:
+            message = ' '.join(
+                (
+                    f'no bind for {self.fn_name}.',
+                    'are you using an old version of the API?',
+                )
+            )
+        else:
+            message = f'{self.fn_name} returned {self.code}'
+        super().__init__(message)

voicemeeterlib/event.py

@@ -12,47 +12,47 @@ class Event:
         self.logger = logger.getChild(self.__class__.__name__)
 
     def info(self, msg=None):
-        info = (f"{msg} events",) if msg else ()
+        info = (f'{msg} events',) if msg else ()
         if self.any():
             info += (f"now listening for {', '.join(self.get())} events",)
         else:
-            info += (f"not listening for any events",)
+            info += ('not listening for any events',)
-        self.logger.info(", ".join(info))
+        self.logger.info(', '.join(info))
 
     @property
     def pdirty(self) -> bool:
-        return self.subs["pdirty"]
+        return self.subs['pdirty']
 
     @pdirty.setter
     def pdirty(self, val: bool):
-        self.subs["pdirty"] = val
+        self.subs['pdirty'] = val
         self.info(f"pdirty {'added to' if val else 'removed from'}")
 
     @property
     def mdirty(self) -> bool:
-        return self.subs["mdirty"]
+        return self.subs['mdirty']
 
     @mdirty.setter
     def mdirty(self, val: bool):
-        self.subs["mdirty"] = val
+        self.subs['mdirty'] = val
         self.info(f"mdirty {'added to' if val else 'removed from'}")
 
     @property
     def midi(self) -> bool:
-        return self.subs["midi"]
+        return self.subs['midi']
 
     @midi.setter
     def midi(self, val: bool):
-        self.subs["midi"] = val
+        self.subs['midi'] = val
         self.info(f"midi {'added to' if val else 'removed from'}")
 
     @property
     def ldirty(self) -> bool:
-        return self.subs["ldirty"]
+        return self.subs['ldirty']
 
     @ldirty.setter
     def ldirty(self, val: bool):
-        self.subs["ldirty"] = val
+        self.subs['ldirty'] = val
         self.info(f"ldirty {'added to' if val else 'removed from'}")
 
     def get(self) -> list:

voicemeeterlib/factory.py

@@ -1,8 +1,7 @@
 import logging
-from abc import abstractmethod
 from enum import IntEnum
 from functools import cached_property
-from typing import Iterable, NoReturn
+from typing import Iterable
 
 from . import misc
 from .bus import request_bus_obj as bus
@@ -29,8 +28,8 @@ class FactoryBuilder:
     """
 
     BuilderProgress = IntEnum(
-        "BuilderProgress",
+        'BuilderProgress',
-        "strip bus command macrobutton vban device option recorder patch fx",
+        'strip bus command macrobutton vban device option recorder patch fx',
         start=0,
     )
 
@@ -38,22 +37,22 @@ class FactoryBuilder:
         self._factory = factory
         self.kind = kind
         self._info = (
-            f"Finished building strips for {self._factory}",
+            f'Finished building strips for {self._factory}',
-            f"Finished building buses for {self._factory}",
+            f'Finished building buses for {self._factory}',
-            f"Finished building commands for {self._factory}",
+            f'Finished building commands for {self._factory}',
-            f"Finished building macrobuttons for {self._factory}",
+            f'Finished building macrobuttons for {self._factory}',
-            f"Finished building vban in/out streams for {self._factory}",
+            f'Finished building vban in/out streams for {self._factory}',
-            f"Finished building device for {self._factory}",
+            f'Finished building device for {self._factory}',
-            f"Finished building option for {self._factory}",
+            f'Finished building option for {self._factory}',
-            f"Finished building recorder for {self._factory}",
+            f'Finished building recorder for {self._factory}',
-            f"Finished building patch for {self._factory}",
+            f'Finished building patch for {self._factory}',
-            f"Finished building fx for {self._factory}",
+            f'Finished building fx for {self._factory}',
         )
         self.logger = logger.getChild(self.__class__.__name__)
 
-    def _pinfo(self, name: str) -> NoReturn:
+    def _pinfo(self, name: str) -> None:
         """prints progress status for each step"""
-        name = name.split("_")[1]
+        name = name.split('_')[1]
         self.logger.debug(self._info[int(getattr(self.BuilderProgress, name))])
 
     def make_strip(self):
@@ -108,15 +107,17 @@ class FactoryBase(Remote):
 
     def __init__(self, kind_id: str, **kwargs):
         defaultkwargs = {
-            "sync": False,
+            'sync': False,
-            "ratelimit": 0.033,
+            'ratelimit': 0.033,
-            "pdirty": False,
+            'pdirty': False,
-            "mdirty": False,
+            'mdirty': False,
-            "midi": False,
+            'midi': False,
-            "ldirty": False,
+            'ldirty': False,
+            'timeout': 2,
+            'bits': 64,
         }
-        if "subs" in kwargs:
+        if 'subs' in kwargs:
-            defaultkwargs |= kwargs.pop("subs")  # for backwards compatibility
+            defaultkwargs |= kwargs.pop('subs')  # for backwards compatibility
         kwargs = defaultkwargs | kwargs
         self.kind = kindmap(kind_id)
         super().__init__(**kwargs)
@@ -133,12 +134,7 @@ class FactoryBase(Remote):
         self._configs = None
 
     def __str__(self) -> str:
-        return f"Voicemeeter {self.kind}"
+        return f'Voicemeeter {self.kind}'
-
-    @property
-    @abstractmethod
-    def steps(self):
-        pass
 
     @cached_property
     def configs(self):
@@ -223,15 +219,15 @@ def remote_factory(kind_id: str, **kwargs) -> Remote:
     Returns a Remote class of a kind
     """
     match kind_id:
-        case "basic":
+        case 'basic':
             _factory = BasicFactory
-        case "banana":
+        case 'banana':
             _factory = BananaFactory
-        case "potato":
+        case 'potato':
             _factory = PotatoFactory
         case _:
             raise ValueError(f"Unknown Voicemeeter kind '{kind_id}'")
-    return type(f"Remote{kind_id.capitalize()}", (_factory,), {})(kind_id, **kwargs)
+    return type(f'Remote{kind_id.capitalize()}', (_factory,), {})(kind_id, **kwargs)
 
 
 def request_remote_obj(kind_id: str, **kwargs) -> Remote:
@@ -241,12 +237,12 @@ def request_remote_obj(kind_id: str, **kwargs) -> Remote:
     Returns a reference to a Remote class of a kind
     """
 
-    logger_entry = logger.getChild("request_remote_obj")
+    logger_entry = logger.getChild('request_remote_obj')
 
     REMOTE_obj = None
     try:
         REMOTE_obj = remote_factory(kind_id, **kwargs)
     except (ValueError, TypeError) as e:
-        logger_entry.exception(f"{type(e).__name__}: {e}")
+        logger_entry.exception(f'{type(e).__name__}: {e}')
         raise VMError(str(e)) from e
     return REMOTE_obj

voicemeeterlib/inst.py

@@ -5,39 +5,44 @@ from pathlib import Path
 
 from .error import InstallError
 
-bits = 64 if ct.sizeof(ct.c_voidp) == 8 else 32
+BITS = 64 if ct.sizeof(ct.c_void_p) == 8 else 32
 
-if platform.system() != "Windows":
+if platform.system() != 'Windows':
-    raise InstallError("Only Windows OS supported")
+    raise InstallError('Only Windows OS supported')
 
 
-VM_KEY = "VB:Voicemeeter {17359A74-1236-5467}"
+VM_KEY = 'VB:Voicemeeter {17359A74-1236-5467}'
-REG_KEY = "".join(
+REG_KEY = '\\'.join(
-    [
+    filter(
-        "SOFTWARE",
+        None,
-        ("\\WOW6432Node" if bits == 64 else ""),
+        (
-        "\\Microsoft\\Windows\\CurrentVersion\\Uninstall",
+            'SOFTWARE',
-    ]
+            'WOW6432Node' if BITS == 64 else '',
+            'Microsoft',
+            'Windows',
+            'CurrentVersion',
+            'Uninstall',
+        ),
+    )
 )
 
 
 def get_vmpath():
     with winreg.OpenKey(
-        winreg.HKEY_LOCAL_MACHINE, r"{}".format(REG_KEY + "\\" + VM_KEY)
+        winreg.HKEY_LOCAL_MACHINE, r'{}'.format('\\'.join((REG_KEY, VM_KEY)))
     ) as vm_key:
-        return winreg.QueryValueEx(vm_key, r"UninstallString")[0]
+        return winreg.QueryValueEx(vm_key, r'UninstallString')[0].strip('"')
 
 
 try:
-    vm_path = Path(get_vmpath())
+    vm_parent = Path(get_vmpath()).parent
 except FileNotFoundError as e:
-    raise InstallError(f"Unable to fetch DLL path from the registry") from e
+    raise InstallError('Unable to fetch DLL path from the registry') from e
-vm_parent = vm_path.parent
 
-DLL_NAME = f'VoicemeeterRemote{"64" if bits == 64 else ""}.dll'
+DLL_NAME = f'VoicemeeterRemote{"64" if BITS == 64 else ""}.dll'
 
 dll_path = vm_parent.joinpath(DLL_NAME)
 if not dll_path.is_file():
-    raise InstallError(f"Could not find {dll_path}")
+    raise InstallError(f'Could not find {dll_path}')
 
 libc = ct.CDLL(str(dll_path))

voicemeeterlib/iremote.py

@@ -1,11 +1,11 @@
+import abc
 import logging
 import time
-from abc import ABCMeta, abstractmethod
 
 logger = logging.getLogger(__name__)
 
 
-class IRemote(metaclass=ABCMeta):
+class IRemote(abc.ABC):
     """
     Common interface between base class and extended (higher) classes
 
@@ -19,27 +19,27 @@ class IRemote(metaclass=ABCMeta):
 
     def getter(self, param, **kwargs):
         """Gets a parameter value"""
-        self.logger.debug(f"getter: {self._cmd(param)}")
+        self.logger.debug(f'getter: {self._cmd(param)}')
         return self._remote.get(self._cmd(param), **kwargs)
 
     def setter(self, param, val):
         """Sets a parameter value"""
-        self.logger.debug(f"setter: {self._cmd(param)}={val}")
+        self.logger.debug(f'setter: {self._cmd(param)}={val}')
         self._remote.set(self._cmd(param), val)
 
     def _cmd(self, param):
         cmd = (self.identifier,)
         if param:
-            cmd += (f".{param}",)
+            cmd += (f'.{param}',)
-        return "".join(cmd)
+        return ''.join(cmd)
 
-    @abstractmethod
+    @abc.abstractmethod
     def identifier(self):
         pass
 
     def apply(self, data: dict):
         def fget(attr, val):
-            if attr == "mode":
+            if attr == 'mode':
                 return (getattr(self, attr), val, 1)
             return (self, attr, val)
 
@@ -49,7 +49,7 @@ class IRemote(metaclass=ABCMeta):
                     target, attr, val = fget(attr, val)
                     setattr(target, attr, val)
                 else:
-                    self.logger.error(f"invalid attribute {attr} for {self}")
+                    self.logger.error(f'invalid attribute {attr} for {self}')
             else:
                 target = getattr(self, attr)
                 target.apply(val)

voicemeeterlib/kinds.py

@@ -22,7 +22,7 @@ class SingletonType(type):
         return cls._instances[cls]
 
 
-@dataclass
+@dataclass(frozen=True)
 class KindMapClass(metaclass=SingletonType):
     name: str
     ins: tuple
@@ -30,75 +30,96 @@ class KindMapClass(metaclass=SingletonType):
     vban: tuple
     asio: tuple
     insert: int
+    composite: int
+    strip_channels: int
+    bus_channels: int
+    cells: int
 
     @property
-    def phys_in(self):
+    def phys_in(self) -> int:
         return self.ins[0]
 
     @property
-    def virt_in(self):
+    def virt_in(self) -> int:
         return self.ins[-1]
 
     @property
-    def phys_out(self):
+    def phys_out(self) -> int:
         return self.outs[0]
 
     @property
-    def virt_out(self):
+    def virt_out(self) -> int:
         return self.outs[-1]
 
     @property
-    def num_strip(self):
+    def num_strip(self) -> int:
         return sum(self.ins)
 
     @property
-    def num_bus(self):
+    def num_bus(self) -> int:
         return sum(self.outs)
 
+    @property
+    def num_strip_levels(self) -> int:
+        return 2 * self.phys_in + 8 * self.virt_in
+
+    @property
+    def num_bus_levels(self) -> int:
+        return 8 * (self.phys_out + self.virt_out)
+
     def __str__(self) -> str:
         return self.name.capitalize()
 
 
-@dataclass
+@dataclass(frozen=True)
 class BasicMap(KindMapClass):
-    name: str
     ins: tuple = (2, 1)
     outs: tuple = (1, 1)
-    vban: tuple = (4, 4)
+    vban: tuple = (4, 4, 1, 1)
     asio: tuple = (0, 0)
     insert: int = 0
+    composite: int = 0
+    strip_channels: int = 0
+    bus_channels: int = 0
+    cells: int = 0
 
 
-@dataclass
+@dataclass(frozen=True)
 class BananaMap(KindMapClass):
-    name: str
     ins: tuple = (3, 2)
     outs: tuple = (3, 2)
-    vban: tuple = (8, 8)
+    vban: tuple = (8, 8, 1, 1)
     asio: tuple = (6, 8)
     insert: int = 22
+    composite: int = 8
+    strip_channels: int = 0
+    bus_channels: int = 8
+    cells: int = 6
 
 
-@dataclass
+@dataclass(frozen=True)
 class PotatoMap(KindMapClass):
-    name: str
     ins: tuple = (5, 3)
     outs: tuple = (5, 3)
-    vban: tuple = (8, 8)
+    vban: tuple = (8, 8, 1, 1)
     asio: tuple = (10, 8)
     insert: int = 34
+    composite: int = 8
+    strip_channels: int = 2
+    bus_channels: int = 8
+    cells: int = 6
 
 
 def kind_factory(kind_id):
     match kind_id:
-        case "basic":
+        case 'basic':
             _kind_map = BasicMap
-        case "banana":
+        case 'banana':
             _kind_map = BananaMap
-        case "potato":
+        case 'potato':
             _kind_map = PotatoMap
         case _:
-            raise ValueError(f"Unknown Voicemeeter kind {kind_id}")
+            raise ValueError(f'Unknown Voicemeeter kind {kind_id}')
     return _kind_map(name=kind_id)
 
 
@@ -111,4 +132,4 @@ def request_kind_map(kind_id):
     return KIND_obj
 
 
-kinds_all = list(request_kind_map(kind_id.name.lower()) for kind_id in KindId)
+all = kinds_all = [request_kind_map(kind_id.name.lower()) for kind_id in KindId]

voicemeeterlib/macrobutton.py

@@ -1,5 +1,13 @@
+from enum import IntEnum
+
 from .iremote import IRemote
 
+ButtonModes = IntEnum(
+    'ButtonModes',
+    'state stateonly trigger',
+    start=1,
+)
+
 
 class Adapter(IRemote):
     """Adapter to the common interface."""
@@ -8,9 +16,13 @@ class Adapter(IRemote):
         pass
 
     def getter(self, mode):
+        self.logger.debug(f'getter: button[{self.index}].{ButtonModes(mode).name}')
         return self._remote.get_buttonstatus(self.index, mode)
 
-    def setter(self, val, mode):
+    def setter(self, mode, val):
+        self.logger.debug(
+            f'setter: button[{self.index}].{ButtonModes(mode).name}={val}'
+        )
         self._remote.set_buttonstatus(self.index, val, mode)
 
 
@@ -18,28 +30,28 @@ class MacroButton(Adapter):
     """Defines concrete implementation for macrobutton"""
 
     def __str__(self):
-        return f"{type(self).__name__}{self._remote.kind}{self.index}"
+        return f'{type(self).__name__}{self._remote.kind}{self.index}'
 
     @property
     def state(self) -> bool:
-        return self.getter(1) == 1
+        return self.getter(ButtonModes.state) == 1
 
     @state.setter
-    def state(self, val):
+    def state(self, val: bool):
-        self.setter(1 if val else 0, 1)
+        self.setter(ButtonModes.state, 1 if val else 0)
 
     @property
     def stateonly(self) -> bool:
-        return self.getter(2) == 1
+        return self.getter(ButtonModes.stateonly) == 1
 
     @stateonly.setter
-    def stateonly(self, val):
+    def stateonly(self, val: bool):
-        self.setter(1 if val else 0, 2)
+        self.setter(ButtonModes.stateonly, 1 if val else 0)
 
     @property
     def trigger(self) -> bool:
-        return self.getter(3) == 1
+        return self.getter(ButtonModes.trigger) == 1
 
     @trigger.setter
-    def trigger(self, val):
+    def trigger(self, val: bool):
-        self.setter(1 if val else 0, 3)
+        self.setter(ButtonModes.trigger, 1 if val else 0)

voicemeeterlib/misc.py

@@ -1,49 +1,48 @@
 from typing import Optional
 
-from .error import VMError
+from . import kinds
 from .iremote import IRemote
-from .kinds import kinds_all
 
 
 class FX(IRemote):
     def __str__(self):
-        return f"{type(self).__name__}"
+        return f'{type(self).__name__}'
 
     @property
     def identifier(self) -> str:
-        return "FX"
+        return 'FX'
 
     @property
     def reverb(self) -> bool:
-        return self.getter("reverb.On") == 1
+        return self.getter('reverb.On') == 1
 
     @reverb.setter
     def reverb(self, val: bool):
-        self.setter("reverb.On", 1 if val else 0)
+        self.setter('reverb.On', 1 if val else 0)
 
     @property
     def reverb_ab(self) -> bool:
-        return self.getter("reverb.ab") == 1
+        return self.getter('reverb.ab') == 1
 
     @reverb_ab.setter
     def reverb_ab(self, val: bool):
-        self.setter("reverb.ab", 1 if val else 0)
+        self.setter('reverb.ab', 1 if val else 0)
 
     @property
     def delay(self) -> bool:
-        return self.getter("delay.On") == 1
+        return self.getter('delay.On') == 1
 
     @delay.setter
     def delay(self, val: bool):
-        self.setter("delay.On", 1 if val else 0)
+        self.setter('delay.On', 1 if val else 0)
 
     @property
     def delay_ab(self) -> bool:
-        return self.getter("delay.ab") == 1
+        return self.getter('delay.ab') == 1
 
     @delay_ab.setter
     def delay_ab(self, val: bool):
-        self.setter("delay.ab", 1 if val else 0)
+        self.setter('delay.ab', 1 if val else 0)
 
 
 class Patch(IRemote):
@@ -58,50 +57,50 @@ class Patch(IRemote):
         """
         ASIO_cls = _make_asio_mixins(remote)[remote.kind.name]
         return type(
-            f"Patch{remote.kind}",
+            f'Patch{remote.kind}',
             (cls, ASIO_cls),
             {
-                "composite": tuple(Composite(remote, i) for i in range(8)),
+                'composite': tuple(Composite(remote, i) for i in range(8)),
-                "insert": tuple(Insert(remote, i) for i in range(remote.kind.insert)),
+                'insert': tuple(Insert(remote, i) for i in range(remote.kind.insert)),
             },
         )(remote)
 
     def __str__(self):
-        return f"{type(self).__name__}"
+        return f'{type(self).__name__}'
 
     @property
     def identifier(self) -> str:
-        return f"patch"
+        return 'patch'
 
     @property
     def postfadercomp(self) -> bool:
-        return self.getter("postfadercomposite") == 1
+        return self.getter('postfadercomposite') == 1
 
     @postfadercomp.setter
     def postfadercomp(self, val: bool):
-        self.setter("postfadercomposite", 1 if val else 0)
+        self.setter('postfadercomposite', 1 if val else 0)
 
     @property
     def postfxinsert(self) -> bool:
-        return self.getter("postfxinsert") == 1
+        return self.getter('postfxinsert') == 1
 
     @postfxinsert.setter
     def postfxinsert(self, val: bool):
-        self.setter("postfxinsert", 1 if val else 0)
+        self.setter('postfxinsert', 1 if val else 0)
 
 
 class Asio(IRemote):
     @property
     def identifier(self) -> str:
-        return f"patch"
+        return 'patch'
 
 
 class AsioIn(Asio):
     def get(self) -> int:
-        return int(self.getter(f"asio[{self.index}]"))
+        return int(self.getter(f'asio[{self.index}]'))
 
     def set(self, val: int):
-        self.setter(f"asio[{self.index}]", val)
+        self.setter(f'asio[{self.index}]', val)
 
 
 class AsioOut(Asio):
@@ -110,10 +109,10 @@ class AsioOut(Asio):
         self._param = param
 
     def get(self) -> int:
-        return int(self.getter(f"out{self._param}[{self.index}]"))
+        return int(self.getter(f'out{self._param}[{self.index}]'))
 
     def set(self, val: int):
-        self.setter(f"out{self._param}[{self.index}]", val)
+        self.setter(f'out{self._param}[{self.index}]', val)
 
 
 def _make_asio_mixin(remote, kind):
@@ -121,46 +120,46 @@ def _make_asio_mixin(remote, kind):
     asio_in, asio_out = kind.asio
 
     return type(
-        f"ASIO{kind}",
+        f'ASIO{kind}',
         (IRemote,),
         {
-            "asio": tuple(AsioIn(remote, i) for i in range(asio_in)),
+            'asio': tuple(AsioIn(remote, i) for i in range(asio_in)),
             **{
                 param: tuple(AsioOut(remote, i, param) for i in range(asio_out))
-                for param in ["A2", "A3", "A4", "A5"]
+                for param in ['A2', 'A3', 'A4', 'A5']
             },
         },
     )
 
 
 def _make_asio_mixins(remote):
-    return {kind.name: _make_asio_mixin(remote, kind) for kind in kinds_all}
+    return {kind.name: _make_asio_mixin(remote, kind) for kind in kinds.all}
 
 
 class Composite(IRemote):
     @property
     def identifier(self) -> str:
-        return "patch"
+        return 'patch'
 
     def get(self) -> int:
-        return int(self.getter(f"composite[{self.index}]"))
+        return int(self.getter(f'composite[{self.index}]'))
 
     def set(self, val: int):
-        self.setter(f"composite[{self.index}]", val)
+        self.setter(f'composite[{self.index}]', val)
 
 
 class Insert(IRemote):
     @property
     def identifier(self) -> str:
-        return "patch"
+        return 'patch'
 
     @property
     def on(self) -> bool:
-        return self.getter(f"insert[{self.index}]") == 1
+        return self.getter(f'insert[{self.index}]') == 1
 
     @on.setter
     def on(self, val: bool):
-        self.setter(f"insert[{self.index}]", 1 if val else 0)
+        self.setter(f'insert[{self.index}]', 1 if val else 0)
 
 
 class Option(IRemote):
@@ -174,61 +173,61 @@ class Option(IRemote):
         Returns a Option class of a kind.
         """
         return type(
-            f"Option{remote.kind}",
+            f'Option{remote.kind}',
             (cls,),
             {
-                "delay": tuple(Delay(remote, i) for i in range(remote.kind.phys_out)),
+                'delay': tuple(Delay(remote, i) for i in range(remote.kind.phys_out)),
             },
         )(remote)
 
     def __str__(self):
-        return f"{type(self).__name__}"
+        return f'{type(self).__name__}'
 
     @property
     def identifier(self) -> str:
-        return "option"
+        return 'option'
 
     @property
     def sr(self) -> int:
-        return int(self.getter("sr"))
+        return int(self.getter('sr'))
 
     @sr.setter
     def sr(self, val: int):
         opts = (44100, 48000, 88200, 96000, 176400, 192000)
         if val not in opts:
-            raise VMError(f"Expected one of: {opts}")
+            self.logger.warning(f'sr got: {val} but expected a value in {opts}')
-        self.setter("sr", val)
+        self.setter('sr', val)
 
     @property
     def asiosr(self) -> bool:
-        return self.getter("asiosr") == 1
+        return self.getter('asiosr') == 1
 
     @asiosr.setter
     def asiosr(self, val: bool):
-        self.setter("asiosr", 1 if val else 0)
+        self.setter('asiosr', 1 if val else 0)
 
     @property
     def monitoronsel(self) -> bool:
-        return self.getter("monitoronsel") == 1
+        return self.getter('monitoronsel') == 1
 
     @monitoronsel.setter
     def monitoronsel(self, val: bool):
-        self.setter("monitoronsel", 1 if val else 0)
+        self.setter('monitoronsel', 1 if val else 0)
 
     def buffer(self, driver, buffer):
-        self.setter(f"buffer.{driver}", buffer)
+        self.setter(f'buffer.{driver}', buffer)
 
 
 class Delay(IRemote):
     @property
     def identifier(self) -> str:
-        return "option"
+        return 'option'
 
     def get(self) -> int:
-        return int(self.getter(f"delay[{self.index}]"))
+        return int(self.getter(f'delay[{self.index}]'))
 
     def set(self, val: int):
-        self.setter(f"delay[{self.index}]", val)
+        self.setter(f'delay[{self.index}]', val)
 
 
 class Midi:

voicemeeterlib/recorder.py

@@ -1,6 +1,8 @@
+import re
+
+from . import kinds
 from .error import VMError
 from .iremote import IRemote
-from .kinds import kinds_all
 from .meta import action_fn, bool_prop
 
 
@@ -19,57 +21,222 @@ class Recorder(IRemote):
         Returns a Recorder class of a kind.
         """
         CHANNELOUTMIXIN_cls = _make_channelout_mixins[remote.kind.name]
+        ARMCHANNELMIXIN_cls = _make_armchannel_mixins(remote)[remote.kind.name]
         REC_cls = type(
-            f"Recorder{remote.kind}",
+            f'Recorder{remote.kind}',
-            (cls, CHANNELOUTMIXIN_cls),
+            (cls, CHANNELOUTMIXIN_cls, ARMCHANNELMIXIN_cls),
             {
                 **{
                     param: action_fn(param)
                     for param in [
-                        "play",
+                        'play',
-                        "stop",
+                        'stop',
-                        "pause",
+                        'pause',
-                        "replay",
+                        'replay',
-                        "record",
+                        'record',
-                        "ff",
+                        'ff',
-                        "rew",
+                        'rew',
                     ]
                 },
+                'mode': RecorderMode(remote),
             },
         )
         return REC_cls(remote)
 
     def __str__(self):
-        return f"{type(self).__name__}"
+        return f'{type(self).__name__}'
 
     @property
     def identifier(self) -> str:
-        return "recorder"
+        return 'recorder'
+
+    @property
+    def samplerate(self) -> int:
+        return int(self.getter('samplerate'))
+
+    @samplerate.setter
+    def samplerate(self, val: int):
+        opts = (22050, 24000, 32000, 44100, 48000, 88200, 96000, 176400, 192000)
+        if val not in opts:
+            self.logger.warning(f'samplerate got: {val} but expected a value in {opts}')
+        self.setter('samplerate', val)
+
+    @property
+    def bitresolution(self) -> int:
+        return int(self.getter('bitresolution'))
+
+    @bitresolution.setter
+    def bitresolution(self, val: int):
+        opts = (8, 16, 24, 32)
+        if val not in opts:
+            self.logger.warning(
+                f'bitresolution got: {val} but expected a value in {opts}'
+            )
+        self.setter('bitresolution', val)
+
+    @property
+    def channel(self) -> int:
+        return int(self.getter('channel'))
+
+    @channel.setter
+    def channel(self, val: int):
+        if not 1 <= val <= 8:
+            self.logger.warning(f'channel got: {val} but expected a value from 1 to 8')
+        self.setter('channel', val)
+
+    @property
+    def kbps(self):
+        return int(self.getter('kbps'))
+
+    @kbps.setter
+    def kbps(self, val: int):
+        opts = (32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320)
+        if val not in opts:
+            self.logger.warning(f'kbps got: {val} but expected a value in {opts}')
+        self.setter('kbps', val)
+
+    @property
+    def gain(self) -> float:
+        return round(self.getter('gain'), 1)
+
+    @gain.setter
+    def gain(self, val: float):
+        self.setter('gain', val)
 
     def load(self, file: str):
         try:
-            self.setter("load", file)
+            self.setter('load', file)
         except UnicodeError:
-            raise VMError("File full directory must be a raw string")
+            raise VMError('File full directory must be a raw string')
 
-    def set_loop(self, val: bool):
+    # loop forwarder methods, for backwards compatibility
-        self.setter("mode.loop", 1 if val else 0)
+    @property
+    def loop(self):
+        return self.mode.loop
 
-    loop = property(fset=set_loop)
+    @loop.setter
+    def loop(self, val: bool):
+        self.mode.loop = val
+
+    def goto(self, time_str):
+        def get_sec():
+            """Get seconds from time string"""
+            h, m, s = time_str.split(':')
+            return int(h) * 3600 + int(m) * 60 + int(s)
+
+        time_str = str(time_str)  # coerce the type
+        if (
+            re.match(
+                r'^(?:[01]\d|2[0123]):(?:[012345]\d):(?:[012345]\d)$',
+                time_str,
+            )
+            is not None
+        ):
+            self.setter('goto', get_sec())
+        else:
+            self.logger.warning(
+                "goto expects a string that matches the format 'hh:mm:ss'"
+            )
+
+    def filetype(self, val: str):
+        opts = {'wav': 1, 'aiff': 2, 'bwf': 3, 'mp3': 100}
+        try:
+            self.setter('filetype', opts[val.lower()])
+        except KeyError:
+            self.logger.warning(
+                f'filetype got: {val} but expected a value in {list(opts.keys())}'
+            )
+
+
+class RecorderMode(IRemote):
+    @property
+    def identifier(self):
+        return 'recorder.mode'
+
+    @property
+    def recbus(self) -> bool:
+        return self.getter('recbus') == 1
+
+    @recbus.setter
+    def recbus(self, val: bool):
+        self.setter('recbus', 1 if val else 0)
+
+    @property
+    def playonload(self) -> bool:
+        return self.getter('playonload') == 1
+
+    @playonload.setter
+    def playonload(self, val: bool):
+        self.setter('playonload', 1 if val else 0)
+
+    @property
+    def loop(self) -> bool:
+        return self.getter('loop') == 1
+
+    @loop.setter
+    def loop(self, val: bool):
+        self.setter('loop', 1 if val else 0)
+
+    @property
+    def multitrack(self) -> bool:
+        return self.getter('multitrack') == 1
+
+    @multitrack.setter
+    def multitrack(self, val: bool):
+        self.setter('multitrack', 1 if val else 0)
+
+
+class RecorderArmChannel(IRemote):
+    def __init__(self, remote, i):
+        super().__init__(remote)
+        self._i = i
+
+    def set(self, val: bool):
+        self.setter('', 1 if val else 0)
+
+
+class RecorderArmStrip(RecorderArmChannel):
+    @property
+    def identifier(self):
+        return f'recorder.armstrip[{self._i}]'
+
+
+class RecorderArmBus(RecorderArmChannel):
+    @property
+    def identifier(self):
+        return f'recorder.armbus[{self._i}]'
+
+
+def _make_armchannel_mixin(remote, kind):
+    """Creates an armchannel out mixin"""
+    return type(
+        f'ArmChannelMixin{kind}',
+        (),
+        {
+            'armstrip': tuple(
+                RecorderArmStrip(remote, i) for i in range(kind.num_strip)
+            ),
+            'armbus': tuple(RecorderArmBus(remote, i) for i in range(kind.num_bus)),
+        },
+    )
+
+
+def _make_armchannel_mixins(remote):
+    return {kind.name: _make_armchannel_mixin(remote, kind) for kind in kinds.all}
 
 
 def _make_channelout_mixin(kind):
-    """Creates a channel out property mixin"""
+    """Creates a channel out mixin"""
     return type(
-        f"ChannelOutMixin{kind}",
+        f'ChannelOutMixin{kind}',
         (),
         {
-            **{f"A{i}": bool_prop(f"A{i}") for i in range(1, kind.phys_out + 1)},
+            **{f'A{i}': bool_prop(f'A{i}') for i in range(1, kind.phys_out + 1)},
-            **{f"B{i}": bool_prop(f"B{i}") for i in range(1, kind.virt_out + 1)},
+            **{f'B{i}': bool_prop(f'B{i}') for i in range(1, kind.virt_out + 1)},
         },
     )
 
 
 _make_channelout_mixins = {
-    kind.name: _make_channelout_mixin(kind) for kind in kinds_all
+    kind.name: _make_channelout_mixin(kind) for kind in kinds.all
 }

voicemeeterlib/remote.py

@@ -1,43 +1,51 @@
+import abc
 import ctypes as ct
 import logging
+import threading
 import time
-from abc import abstractmethod
 from queue import Queue
-from typing import Iterable, NoReturn, Optional, Union
+from typing import Iterable, Optional, Union
 
 from .cbindings import CBindings
 from .error import CAPIError, VMError
 from .event import Event
-from .inst import bits
+from .inst import BITS
 from .kinds import KindId
 from .misc import Midi, VmGui
 from .subject import Subject
 from .updater import Producer, Updater
-from .util import grouper, polling, script
+from .util import deep_merge, grouper, polling, script, timeout
 
 logger = logging.getLogger(__name__)
 
 
-class Remote(CBindings):
+class Remote(abc.ABC):
-    """Base class responsible for wrapping the C Remote API"""
+    """An abstract base class for Voicemeeter Remote API wrappers. Defines common methods and properties."""
 
     DELAY = 0.001
 
     def __init__(self, **kwargs):
+        self._bindings = CBindings()
         self.strip_mode = 0
         self.cache = {}
         self.midi = Midi()
         self.subject = self.observer = Subject()
-        self.running = False
         self.event = Event(
-            {k: kwargs.pop(k) for k in ("pdirty", "mdirty", "midi", "ldirty")}
+            {k: kwargs.pop(k) for k in ('pdirty', 'mdirty', 'midi', 'ldirty')}
         )
         self.gui = VmGui()
+        self.stop_event = None
         self.logger = logger.getChild(self.__class__.__name__)
 
         for attr, val in kwargs.items():
             setattr(self, attr, val)
 
+        if self.bits not in (32, 64):
+            self.logger.warning(
+                f'kwarg bits got {self.bits}, expected either 32 or 64, defaulting to 64'
+            )
+            self.bits = 64
+
     def __enter__(self):
         """setup procedures"""
         self.login()
@@ -45,57 +53,58 @@ class Remote(CBindings):
             self.init_thread()
         return self
 
-    @abstractmethod
+    @property
-    def __str__(self):
+    @abc.abstractmethod
-        """Ensure subclasses override str magic method"""
+    def steps(self):
-        pass
+        """Steps required to build the interface for this Voicemeeter kind"""
 
     def init_thread(self):
         """Starts updates thread."""
-        self.running = True
         self.event.info()
 
-        self.logger.debug("initiating events thread")
+        self.logger.debug('initiating events thread')
+        self.stop_event = threading.Event()
+        self.stop_event.clear()
         queue = Queue()
         self.updater = Updater(self, queue)
         self.updater.start()
-        self.producer = Producer(self, queue)
+        self.producer = Producer(self, queue, self.stop_event)
         self.producer.start()
 
-    def login(self) -> NoReturn:
+    def stopped(self):
+        return self.stop_event is None or self.stop_event.is_set()
+
+    @timeout
+    def login(self) -> None:
         """Login to the API, initialize dirty parameters"""
-        self.gui.launched = self.call(self.vm_login, ok=(0, 1)) == 0
+        self.gui.launched = self._bindings.login(ok=(0, 1)) == 0
         if not self.gui.launched:
             self.logger.info(
-                "Voicemeeter engine running but GUI not launched. Launching the GUI now."
+                'Voicemeeter engine running but GUI not launched. Launching the GUI now.'
             )
             self.run_voicemeeter(self.kind.name)
-        self.logger.info(f"{type(self).__name__}: Successfully logged into {self}")
-        self.clear_dirty()
 
-    def run_voicemeeter(self, kind_id: str) -> NoReturn:
+    def run_voicemeeter(self, kind_id: str) -> None:
         if kind_id not in (kind.name.lower() for kind in KindId):
             raise VMError(f"Unexpected Voicemeeter type: '{kind_id}'")
-        if kind_id == "potato" and bits == 8:
+        value = KindId[kind_id.upper()].value
-            value = KindId[kind_id.upper()].value + 3
+        if BITS == 64 and self.bits == 64:
-        else:
+            value += 3
-            value = KindId[kind_id.upper()].value
+        self._bindings.run_voicemeeter(value)
-        self.call(self.vm_runvm, value)
-        time.sleep(1)
 
     @property
     def type(self) -> str:
         """Returns the type of Voicemeeter installation (basic, banana, potato)."""
         type_ = ct.c_long()
-        self.call(self.vm_get_type, ct.byref(type_))
+        self._bindings.get_voicemeeter_type(ct.byref(type_))
         return KindId(type_.value).name.lower()
 
     @property
     def version(self) -> str:
         """Returns Voicemeeter's version as a string"""
         ver = ct.c_long()
-        self.call(self.vm_get_version, ct.byref(ver))
+        self._bindings.get_voicemeeter_version(ct.byref(ver))
-        return "{}.{}.{}.{}".format(
+        return '{}.{}.{}.{}'.format(
             (ver.value & 0xFF000000) >> 24,
             (ver.value & 0x00FF0000) >> 16,
             (ver.value & 0x0000FF00) >> 8,
@@ -105,34 +114,34 @@ class Remote(CBindings):
     @property
     def pdirty(self) -> bool:
         """True iff UI parameters have been updated."""
-        return self.call(self.vm_pdirty, ok=(0, 1)) == 1
+        return self._bindings.is_parameters_dirty(ok=(0, 1)) == 1
 
     @property
     def mdirty(self) -> bool:
         """True iff MB parameters have been updated."""
         try:
-            return self.call(self.vm_mdirty, ok=(0, 1)) == 1
+            return self._bindings.macro_button_is_dirty(ok=(0, 1)) == 1
         except AttributeError as e:
-            self.logger.exception(f"{type(e).__name__}: {e}")
+            self.logger.exception(f'{type(e).__name__}: {e}')
-            raise CAPIError(
+            raise CAPIError('VBVMR_MacroButton_IsDirty', -9) from e
-                "no bind for VBVMR_MacroButton_IsDirty. are you using an old version of the API?"
-            ) from e
 
     @property
     def ldirty(self) -> bool:
         """True iff levels have been updated."""
         self._strip_buf, self._bus_buf = self._get_levels()
         return not (
-            self.cache.get("strip_level") == self._strip_buf
+            self.cache.get('strip_level') == self._strip_buf
-            and self.cache.get("bus_level") == self._bus_buf
+            and self.cache.get('bus_level') == self._bus_buf
         )
 
-    def clear_dirty(self) -> NoReturn:
+    def clear_dirty(self) -> None:
         try:
             while self.pdirty or self.mdirty:
                 pass
-        except CAPIError:
+        except CAPIError as e:
-            self.logger.error("no bind for mdirty, clearing pdirty only")
+            if not (e.fn_name == 'VBVMR_MacroButton_IsDirty' and e.code == -9):
+                raise
+            self.logger.error(f'{e} clearing pdirty only.')
             while self.pdirty:
                 pass
 
@@ -141,72 +150,71 @@ class Remote(CBindings):
         """Gets a string or float parameter"""
         if is_string:
             buf = ct.create_unicode_buffer(512)
-            self.call(self.vm_get_parameter_string, param.encode(), ct.byref(buf))
+            self._bindings.get_parameter_string_w(param.encode(), ct.byref(buf))
         else:
             buf = ct.c_float()
-            self.call(self.vm_get_parameter_float, param.encode(), ct.byref(buf))
+            self._bindings.get_parameter_float(param.encode(), ct.byref(buf))
         return buf.value
 
-    def set(self, param: str, val: Union[str, float]) -> NoReturn:
+    def set(self, param: str, val: Union[str, float]) -> None:
         """Sets a string or float parameter. Caches value"""
         if isinstance(val, str):
             if len(val) >= 512:
-                raise VMError("String is too long")
+                raise VMError('String is too long')
-            self.call(self.vm_set_parameter_string, param.encode(), ct.c_wchar_p(val))
+            self._bindings.set_parameter_string_w(param.encode(), ct.c_wchar_p(val))
         else:
-            self.call(
+            self._bindings.set_parameter_float(
-                self.vm_set_parameter_float, param.encode(), ct.c_float(float(val))
+                param.encode(),
+                ct.c_float(float(val)),
             )
         self.cache[param] = val
 
     @polling
-    def get_buttonstatus(self, id: int, mode: int) -> int:
+    def get_buttonstatus(self, id_: int, mode: int) -> int:
         """Gets a macrobutton parameter"""
-        state = ct.c_float()
+        c_state = ct.c_float()
         try:
-            self.call(
+            self._bindings.macro_button_get_status(
-                self.vm_get_buttonstatus,
+                ct.c_long(id_),
-                ct.c_long(id),
+                ct.byref(c_state),
-                ct.byref(state),
                 ct.c_long(mode),
             )
         except AttributeError as e:
-            self.logger.exception(f"{type(e).__name__}: {e}")
+            self.logger.exception(f'{type(e).__name__}: {e}')
-            raise CAPIError(
+            raise CAPIError('VBVMR_MacroButton_GetStatus', -9) from e
-                "no bind for VBVMR_MacroButton_GetStatus. are you using an old version of the API?"
+        return int(c_state.value)
-            ) from e
-        return int(state.value)
 
-    def set_buttonstatus(self, id: int, state: int, mode: int) -> NoReturn:
+    def set_buttonstatus(self, id_: int, val: int, mode: int) -> None:
         """Sets a macrobutton parameter. Caches value"""
-        c_state = ct.c_float(float(state))
+        c_state = ct.c_float(float(val))
         try:
-            self.call(self.vm_set_buttonstatus, ct.c_long(id), c_state, ct.c_long(mode))
+            self._bindings.macro_button_set_status(
+                ct.c_long(id_),
+                c_state,
+                ct.c_long(mode),
+            )
         except AttributeError as e:
-            self.logger.exception(f"{type(e).__name__}: {e}")
+            self.logger.exception(f'{type(e).__name__}: {e}')
-            raise CAPIError(
+            raise CAPIError('VBVMR_MacroButton_SetStatus', -9) from e
-                "no bind for VBVMR_MacroButton_SetStatus. are you using an old version of the API?"
+        self.cache[f'mb_{id_}_{mode}'] = int(c_state.value)
-            ) from e
-        self.cache[f"mb_{id}_{mode}"] = int(c_state.value)
 
     def get_num_devices(self, direction: str = None) -> int:
         """Retrieves number of physical devices connected"""
-        if direction not in ("in", "out"):
+        if direction not in ('in', 'out'):
-            raise VMError("Expected a direction: in or out")
+            raise VMError('Expected a direction: in or out')
-        func = getattr(self, f"vm_get_num_{direction}devices")
+        func = getattr(self._bindings, f'{direction}put_get_device_number')
-        res = self.call(func, ok_exp=lambda r: r >= 0)
+        res = func(ok_exp=lambda r: r >= 0)
         return res
 
     def get_device_description(self, index: int, direction: str = None) -> tuple:
         """Returns a tuple of device parameters"""
-        if direction not in ("in", "out"):
+        if direction not in ('in', 'out'):
-            raise VMError("Expected a direction: in or out")
+            raise VMError('Expected a direction: in or out')
         type_ = ct.c_long()
         name = ct.create_unicode_buffer(256)
         hwid = ct.create_unicode_buffer(256)
-        func = getattr(self, f"vm_get_desc_{direction}devices")
+        func = getattr(self._bindings, f'{direction}put_get_device_desc_w')
-        self.call(
+        func(
-            func,
             ct.c_long(index),
             ct.byref(type_),
             ct.byref(name),
@@ -217,7 +225,7 @@ class Remote(CBindings):
     def get_level(self, type_: int, index: int) -> float:
         """Retrieves a single level value"""
         val = ct.c_float()
-        self.call(self.vm_get_level, ct.c_long(type_), ct.c_long(index), ct.byref(val))
+        self._bindings.get_level(ct.c_long(type_), ct.c_long(index), ct.byref(val))
         return val.value
 
     def _get_levels(self) -> Iterable:
@@ -227,21 +235,23 @@ class Remote(CBindings):
         return (
             tuple(
                 self.get_level(self.strip_mode, i)
-                for i in range(2 * self.kind.phys_in + 8 * self.kind.virt_in)
+                for i in range(self.kind.num_strip_levels)
-            ),
-            tuple(
-                self.get_level(3, i)
-                for i in range(8 * (self.kind.phys_out + self.kind.virt_out))
             ),
+            tuple(self.get_level(3, i) for i in range(self.kind.num_bus_levels)),
         )
 
     def get_midi_message(self):
         n = ct.c_long(1024)
         buf = ct.create_string_buffer(1024)
-        res = self.vm_get_midi_message(ct.byref(buf), n, ok_exp=lambda r: r >= 0)
+        res = self._bindings.get_midi_message(
+            ct.byref(buf),
+            n,
+            ok=(-5, -6),  # no data received from midi device
+            ok_exp=lambda r: r >= 0,
+        )
         if res > 0:
             vals = tuple(
-                grouper(3, (int.from_bytes(buf[i], "little") for i in range(res)))
+                grouper(3, (int.from_bytes(buf[i], 'little') for i in range(res)))
             )
             for msg in vals:
                 ch, pitch, vel = msg
@@ -255,8 +265,8 @@ class Remote(CBindings):
     def sendtext(self, script: str):
         """Sets many parameters from a script"""
         if len(script) > 48000:
-            raise ValueError("Script too large, max size 48kB")
+            raise ValueError('Script too large, max size 48kB')
-        self.call(self.vm_set_parameter_multi, script.encode())
+        self._bindings.set_parameters(script.encode())
         time.sleep(self.DELAY * 5)
 
     def apply(self, data: dict):
@@ -266,41 +276,67 @@ class Remote(CBindings):
         minor delay between each recursion
         """
 
-        def param(key):
+        def target(key):
-            obj, m2, *rem = key.split("-")
+            match key.split('-'):
-            index = int(m2) if m2.isnumeric() else int(*rem)
+                case ['strip' | 'bus' | 'button' as kls, index] if index.isnumeric():
-            if obj in ("strip", "bus", "button"):
+                    target = getattr(self, kls)
-                return getattr(self, obj)[index]
+                case [
-            elif obj == "vban":
+                    'vban',
-                return getattr(getattr(self, obj), f"{m2}stream")[index]
+                    'in'
-            raise ValueError(obj)
+                    | 'instream'
+                    | 'out'
+                    | 'outstream' as direction,
+                    index,
+                ] if index.isnumeric():
+                    target = getattr(
+                        self.vban, f"{direction.removesuffix('stream')}stream"
+                    )
+                case _:
+                    ERR_MSG = f"invalid config key '{key}'"
+                    self.logger.error(ERR_MSG)
+                    raise ValueError(ERR_MSG)
+            return target[int(index)]
 
-        [param(key).apply(datum).then_wait() for key, datum in data.items()]
+        [target(key).apply(di).then_wait() for key, di in data.items()]
 
     def apply_config(self, name):
         """applies a config from memory"""
-        error_msg = (
+        ERR_MSG = (
             f"No config with name '{name}' is loaded into memory",
-            f"Known configs: {list(self.configs.keys())}",
+            f'Known configs: {list(self.configs.keys())}',
         )
         try:
-            self.apply(self.configs[name])
+            config = self.configs[name]
-            self.logger.info(f"Profile '{name}' applied!")
+        except KeyError as e:
-        except KeyError:
+            self.logger.error(('\n').join(ERR_MSG))
-            self.logger.error(("\n").join(error_msg))
+            raise VMError(('\n').join(ERR_MSG)) from e
 
-    def logout(self) -> NoReturn:
+        if 'extends' in config:
-        """Wait for dirty parameters to clear, then logout of the API"""
+            extended = config['extends']
-        self.clear_dirty()
+            config = {
-        time.sleep(0.1)
+                k: v
-        self.call(self.vm_logout)
+                for k, v in deep_merge(self.configs[extended], config)
-        self.logger.info(f"{type(self).__name__}: Successfully logged out of {self}")
+                if k not in ('extends')
+            }
+            self.logger.debug(
+                f"profile '{name}' extends '{extended}', profiles merged.."
+            )
+        self.apply(config)
+        self.logger.info(f"Profile '{name}' applied!")
 
     def end_thread(self):
-        self.logger.debug("events thread shutdown started")
+        if not self.stopped():
-        self.running = False
+            self.logger.debug('events thread shutdown started')
+            self.stop_event.set()
+            self.producer.join()  # wait for producer thread to complete cycle
 
-    def __exit__(self, exc_type, exc_value, exc_traceback) -> NoReturn:
+    def logout(self) -> None:
+        """Logout of the API"""
+        time.sleep(0.1)
+        self._bindings.logout()
+        self.logger.info(f'{type(self).__name__}: Successfully logged out of {self}')
+
+    def __exit__(self, exc_type, exc_value, exc_traceback) -> None:
         """teardown procedures"""
         self.end_thread()
         self.logout()

voicemeeterlib/strip.py

@@ -1,10 +1,10 @@
+import abc
 import time
-from abc import abstractmethod
 from math import log
 from typing import Union
 
+from . import kinds
 from .iremote import IRemote
-from .kinds import kinds_all
 from .meta import bool_prop, device_prop, float_prop
 
 
@@ -15,68 +15,68 @@ class Strip(IRemote):
     Defines concrete implementation for strip
     """
 
-    @abstractmethod
+    @abc.abstractmethod
     def __str__(self):
         pass
 
     @property
     def identifier(self) -> str:
-        return f"strip[{self.index}]"
+        return f'strip[{self.index}]'
 
     @property
     def mono(self) -> bool:
-        return self.getter("mono") == 1
+        return self.getter('mono') == 1
 
     @mono.setter
     def mono(self, val: bool):
-        self.setter("mono", 1 if val else 0)
+        self.setter('mono', 1 if val else 0)
 
     @property
     def solo(self) -> bool:
-        return self.getter("solo") == 1
+        return self.getter('solo') == 1
 
     @solo.setter
     def solo(self, val: bool):
-        self.setter("solo", 1 if val else 0)
+        self.setter('solo', 1 if val else 0)
 
     @property
     def mute(self) -> bool:
-        return self.getter("mute") == 1
+        return self.getter('mute') == 1
 
     @mute.setter
     def mute(self, val: bool):
-        self.setter("mute", 1 if val else 0)
+        self.setter('mute', 1 if val else 0)
 
     @property
     def limit(self) -> int:
-        return int(self.getter("limit"))
+        return int(self.getter('limit'))
 
     @limit.setter
     def limit(self, val: int):
-        self.setter("limit", val)
+        self.setter('limit', val)
 
     @property
     def label(self) -> str:
-        return self.getter("Label", is_string=True)
+        return self.getter('Label', is_string=True)
 
     @label.setter
     def label(self, val: str):
-        self.setter("Label", str(val))
+        self.setter('Label', str(val))
 
     @property
     def gain(self) -> float:
-        return round(self.getter("gain"), 1)
+        return round(self.getter('gain'), 1)
 
     @gain.setter
     def gain(self, val: float):
-        self.setter("gain", val)
+        self.setter('gain', val)
 
     def fadeto(self, target: float, time_: int):
-        self.setter("FadeTo", f"({target}, {time_})")
+        self.setter('FadeTo', f'({target}, {time_})')
         time.sleep(self._remote.DELAY)
 
     def fadeby(self, change: float, time_: int):
-        self.setter("FadeBy", f"({change}, {time_})")
+        self.setter('FadeBy', f'({change}, {time_})')
         time.sleep(self._remote.DELAY)
 
 
@@ -90,203 +90,301 @@ class PhysicalStrip(Strip):
         """
         EFFECTS_cls = _make_effects_mixins(is_phys)[remote.kind.name]
         return type(
-            f"PhysicalStrip",
+            'PhysicalStrip',
             (cls, EFFECTS_cls),
             {
-                "comp": StripComp(remote, i),
+                'comp': StripComp(remote, i),
-                "gate": StripGate(remote, i),
+                'gate': StripGate(remote, i),
-                "denoiser": StripDenoiser(remote, i),
+                'denoiser': StripDenoiser(remote, i),
-                "eq": StripEQ(remote, i),
+                'eq': StripEQ.make(remote, i),
-                "device": StripDevice.make(remote, i),
+                'device': StripDevice.make(remote, i),
             },
         )
 
     def __str__(self):
-        return f"{type(self).__name__}{self.index}"
+        return f'{type(self).__name__}{self.index}'
 
     @property
     def audibility(self) -> float:
-        return round(self.getter("audibility"), 1)
+        return round(self.getter('audibility'), 1)
 
     @audibility.setter
     def audibility(self, val: float):
-        self.setter("audibility", val)
+        self.setter('audibility', val)
 
 
 class StripComp(IRemote):
     @property
     def identifier(self) -> str:
-        return f"Strip[{self.index}].comp"
+        return f'Strip[{self.index}].comp'
 
     @property
     def knob(self) -> float:
-        return round(self.getter(""), 1)
+        return round(self.getter(''), 1)
 
     @knob.setter
     def knob(self, val: float):
-        self.setter("", val)
+        self.setter('', val)
 
     @property
     def gainin(self) -> float:
-        return round(self.getter("GainIn"), 1)
+        return round(self.getter('GainIn'), 1)
 
     @gainin.setter
     def gainin(self, val: float):
-        self.setter("GainIn", val)
+        self.setter('GainIn', val)
 
     @property
     def ratio(self) -> float:
-        return round(self.getter("Ratio"), 1)
+        return round(self.getter('Ratio'), 1)
 
     @ratio.setter
     def ratio(self, val: float):
-        self.setter("Ratio", val)
+        self.setter('Ratio', val)
 
     @property
     def threshold(self) -> float:
-        return round(self.getter("Threshold"), 1)
+        return round(self.getter('Threshold'), 1)
 
     @threshold.setter
     def threshold(self, val: float):
-        self.setter("Threshold", val)
+        self.setter('Threshold', val)
 
     @property
     def attack(self) -> float:
-        return round(self.getter("Attack"), 1)
+        return round(self.getter('Attack'), 1)
 
     @attack.setter
     def attack(self, val: float):
-        self.setter("Attack", val)
+        self.setter('Attack', val)
 
     @property
     def release(self) -> float:
-        return round(self.getter("Release"), 1)
+        return round(self.getter('Release'), 1)
 
     @release.setter
     def release(self, val: float):
-        self.setter("Release", val)
+        self.setter('Release', val)
 
     @property
     def knee(self) -> float:
-        return round(self.getter("Knee"), 1)
+        return round(self.getter('Knee'), 2)
 
     @knee.setter
     def knee(self, val: float):
-        self.setter("Knee", val)
+        self.setter('Knee', val)
 
     @property
     def gainout(self) -> float:
-        return round(self.getter("GainOut"), 1)
+        return round(self.getter('GainOut'), 1)
 
     @gainout.setter
     def gainout(self, val: float):
-        self.setter("GainOut", val)
+        self.setter('GainOut', val)
 
     @property
     def makeup(self) -> bool:
-        return self.getter("makeup") == 1
+        return self.getter('makeup') == 1
 
     @makeup.setter
     def makeup(self, val: bool):
-        self.setter("makeup", 1 if val else 0)
+        self.setter('makeup', 1 if val else 0)
 
 
 class StripGate(IRemote):
     @property
     def identifier(self) -> str:
-        return f"Strip[{self.index}].gate"
+        return f'Strip[{self.index}].gate'
 
     @property
     def knob(self) -> float:
-        return round(self.getter(""), 1)
+        return round(self.getter(''), 1)
 
     @knob.setter
     def knob(self, val: float):
-        self.setter("", val)
+        self.setter('', val)
 
     @property
     def threshold(self) -> float:
-        return round(self.getter("Threshold"), 1)
+        return round(self.getter('Threshold'), 1)
 
     @threshold.setter
     def threshold(self, val: float):
-        self.setter("Threshold", val)
+        self.setter('Threshold', val)
 
     @property
     def damping(self) -> float:
-        return round(self.getter("Damping"), 1)
+        return round(self.getter('Damping'), 1)
 
     @damping.setter
     def damping(self, val: float):
-        self.setter("Damping", val)
+        self.setter('Damping', val)
 
     @property
     def bpsidechain(self) -> int:
-        return int(self.getter("BPSidechain"))
+        return int(self.getter('BPSidechain'))
 
     @bpsidechain.setter
     def bpsidechain(self, val: int):
-        self.setter("BPSidechain", val)
+        self.setter('BPSidechain', val)
 
     @property
     def attack(self) -> float:
-        return round(self.getter("Attack"), 1)
+        return round(self.getter('Attack'), 1)
 
     @attack.setter
     def attack(self, val: float):
-        self.setter("Attack", val)
+        self.setter('Attack', val)
 
     @property
     def hold(self) -> float:
-        return round(self.getter("Hold"), 1)
+        return round(self.getter('Hold'), 1)
 
     @hold.setter
     def hold(self, val: float):
-        self.setter("Hold", val)
+        self.setter('Hold', val)
 
     @property
     def release(self) -> float:
-        return round(self.getter("Release"), 1)
+        return round(self.getter('Release'), 1)
 
     @release.setter
     def release(self, val: float):
-        self.setter("Release", val)
+        self.setter('Release', val)
 
 
 class StripDenoiser(IRemote):
     @property
     def identifier(self) -> str:
-        return f"Strip[{self.index}].denoiser"
+        return f'Strip[{self.index}].denoiser'
 
     @property
     def knob(self) -> float:
-        return round(self.getter(""), 1)
+        return round(self.getter(''), 1)
 
     @knob.setter
     def knob(self, val: float):
-        self.setter("", val)
+        self.setter('', val)
 
 
 class StripEQ(IRemote):
+    @classmethod
+    def make(cls, remote, i):
+        """
+        Factory method for Strip EQ.
+
+        Returns a StripEQ class.
+        """
+        STRIPEQ_cls = type(
+            'StripEQ',
+            (cls,),
+            {
+                'channel': tuple(
+                    StripEQCh.make(remote, i, j)
+                    for j in range(remote.kind.strip_channels)
+                )
+            },
+        )
+        return STRIPEQ_cls(remote, i)
+
     @property
     def identifier(self) -> str:
-        return f"Strip[{self.index}].eq"
+        return f'Strip[{self.index}].eq'
 
     @property
     def on(self) -> bool:
-        return self.getter("on") == 1
+        return self.getter('on') == 1
 
     @on.setter
     def on(self, val: bool):
-        self.setter("on", 1 if val else 0)
+        self.setter('on', 1 if val else 0)
 
     @property
     def ab(self) -> bool:
-        return self.getter("ab") == 1
+        return self.getter('ab') == 1
 
     @ab.setter
     def ab(self, val: bool):
-        self.setter("ab", 1 if val else 0)
+        self.setter('ab', 1 if val else 0)
+
+
+class StripEQCh(IRemote):
+    @classmethod
+    def make(cls, remote, i, j):
+        """
+        Factory method for Strip EQ channel.
+
+        Returns a StripEQCh class.
+        """
+        StripEQCh_cls = type(
+            'StripEQCh',
+            (cls,),
+            {
+                'cell': tuple(
+                    StripEQChCell(remote, i, j, k) for k in range(remote.kind.cells)
+                )
+            },
+        )
+        return StripEQCh_cls(remote, i, j)
+
+    def __init__(self, remote, i, j):
+        super().__init__(remote, i)
+        self.channel_index = j
+
+    @property
+    def identifier(self) -> str:
+        return f'Strip[{self.index}].eq.channel[{self.channel_index}]'
+
+
+class StripEQChCell(IRemote):
+    def __init__(self, remote, i, j, k):
+        super().__init__(remote, i)
+        self.channel_index = j
+        self.cell_index = k
+
+    @property
+    def identifier(self) -> str:
+        return f'Strip[{self.index}].eq.channel[{self.channel_index}].cell[{self.cell_index}]'
+
+    @property
+    def on(self) -> bool:
+        return self.getter('on') == 1
+
+    @on.setter
+    def on(self, val: bool):
+        self.setter('on', 1 if val else 0)
+
+    @property
+    def type(self) -> int:
+        return int(self.getter('type'))
+
+    @type.setter
+    def type(self, val: int):
+        self.setter('type', val)
+
+    @property
+    def f(self) -> float:
+        return round(self.getter('f'), 1)
+
+    @f.setter
+    def f(self, val: float):
+        self.setter('f', val)
+
+    @property
+    def gain(self) -> float:
+        return round(self.getter('gain'), 1)
+
+    @gain.setter
+    def gain(self, val: float):
+        self.setter('gain', val)
+
+    @property
+    def q(self) -> float:
+        return round(self.getter('q'), 1)
+
+    @q.setter
+    def q(self, val: float):
+        self.setter('q', val)
 
 
 class StripDevice(IRemote):
@@ -298,16 +396,16 @@ class StripDevice(IRemote):
         Returns a StripDevice class of a kind.
         """
         DEVICE_cls = type(
-            f"StripDevice{remote.kind}",
+            f'StripDevice{remote.kind}',
             (cls,),
             {
                 **{
                     param: device_prop(param)
                     for param in [
-                        "wdm",
+                        'wdm',
-                        "ks",
+                        'ks',
-                        "mme",
+                        'mme',
-                        "asio",
+                        'asio',
                     ]
                 },
             },
@@ -316,15 +414,15 @@ class StripDevice(IRemote):
 
     @property
     def identifier(self) -> str:
-        return f"Strip[{self.index}].device"
+        return f'Strip[{self.index}].device'
 
     @property
     def name(self) -> str:
-        return self.getter("name", is_string=True)
+        return self.getter('name', is_string=True)
 
     @property
     def sr(self) -> int:
-        return int(self.getter("sr"))
+        return int(self.getter('sr'))
 
 
 class VirtualStrip(Strip):
@@ -337,65 +435,65 @@ class VirtualStrip(Strip):
         """
         EFFECTS_cls = _make_effects_mixins(is_phys)[remote.kind.name]
         return type(
-            f"VirtualStrip",
+            'VirtualStrip',
             (cls, EFFECTS_cls),
             {},
         )
 
     def __str__(self):
-        return f"{type(self).__name__}{self.index}"
+        return f'{type(self).__name__}{self.index}'
 
     @property
     def mc(self) -> bool:
-        return self.getter("mc") == 1
+        return self.getter('mc') == 1
 
     @mc.setter
     def mc(self, val: bool):
-        self.setter("mc", 1 if val else 0)
+        self.setter('mc', 1 if val else 0)
 
     mono = mc
 
     @property
     def k(self) -> int:
-        return int(self.getter("karaoke"))
+        return int(self.getter('karaoke'))
 
     @k.setter
     def k(self, val: int):
-        self.setter("karaoke", val)
+        self.setter('karaoke', val)
 
     @property
-    def bass(self):
+    def bass(self) -> float:
-        return round(self.getter("EQGain1"), 1)
+        return round(self.getter('EQGain1'), 1)
 
     @bass.setter
     def bass(self, val: float):
-        self.setter("EQGain1", val)
+        self.setter('EQGain1', val)
 
     @property
-    def mid(self):
+    def mid(self) -> float:
-        return round(self.getter("EQGain2"), 1)
+        return round(self.getter('EQGain2'), 1)
 
     @mid.setter
     def mid(self, val: float):
-        self.setter("EQGain2", val)
+        self.setter('EQGain2', val)
 
     med = mid
 
     @property
-    def treble(self):
+    def treble(self) -> float:
-        return round(self.getter("EQGain3"), 1)
+        return round(self.getter('EQGain3'), 1)
 
     high = treble
 
     @treble.setter
     def treble(self, val: float):
-        self.setter("EQGain3", val)
+        self.setter('EQGain3', val)
 
     def appgain(self, name: str, gain: float):
-        self.setter("AppGain", f'("{name}", {gain})')
+        self.setter('AppGain', f'("{name}", {gain})')
 
     def appmute(self, name: str, mute: bool = None):
-        self.setter("AppMute", f'("{name}", {1 if mute else 0})')
+        self.setter('AppMute', f'("{name}", {1 if mute else 0})')
 
 
 class StripLevel(IRemote):
@@ -415,8 +513,8 @@ class StripLevel(IRemote):
         def fget(x):
             return round(20 * log(x, 10), 1) if x > 0 else -200.0
 
-        if self._remote.running and self._remote.event.ldirty:
+        if not self._remote.stopped() and self._remote.event.ldirty:
-            vals = self._remote.cache["strip_level"][self.range[0] : self.range[-1]]
+            vals = self._remote.cache['strip_level'][self.range[0] : self.range[-1]]
         else:
             vals = [self._remote.get_level(mode, i) for i in range(*self.range)]
 
@@ -424,7 +522,7 @@ class StripLevel(IRemote):
 
     @property
     def identifier(self) -> str:
-        return f"Strip[{self.index}]"
+        return f'Strip[{self.index}]'
 
     @property
     def prefader(self) -> tuple:
@@ -448,7 +546,7 @@ class StripLevel(IRemote):
 
         Expected to be used in a callback only.
         """
-        if self._remote.running:
+        if not self._remote.stopped():
             return any(self._remote._strip_comp[self.range[0] : self.range[-1]])
 
     is_updated = isdirty
@@ -467,7 +565,7 @@ def make_strip_level_map(kind):
     return phys_map + virt_map
 
 
-_make_strip_level_maps = {kind.name: make_strip_level_map(kind) for kind in kinds_all}
+_make_strip_level_maps = {kind.name: make_strip_level_map(kind) for kind in kinds.all}
 
 
 class GainLayer(IRemote):
@@ -477,24 +575,24 @@ class GainLayer(IRemote):
 
     @property
     def identifier(self) -> str:
-        return f"Strip[{self.index}]"
+        return f'Strip[{self.index}]'
 
     @property
     def gain(self):
-        return self.getter(f"GainLayer[{self._i}]")
+        return self.getter(f'GainLayer[{self._i}]')
 
     @gain.setter
     def gain(self, val):
-        self.setter(f"GainLayer[{self._i}]", val)
+        self.setter(f'GainLayer[{self._i}]', val)
 
 
 def _make_gainlayer_mixin(remote, index):
     """Creates a GainLayer mixin"""
     return type(
-        f"GainlayerMixin",
+        'GainlayerMixin',
         (),
         {
-            "gainlayer": tuple(
+            'gainlayer': tuple(
                 GainLayer(remote, index, i) for i in range(remote.kind.num_bus)
             )
         },
@@ -504,17 +602,17 @@ def _make_gainlayer_mixin(remote, index):
 def _make_channelout_mixin(kind):
     """Creates a channel out property mixin"""
     return type(
-        f"ChannelOutMixin{kind}",
+        f'ChannelOutMixin{kind}',
         (),
         {
-            **{f"A{i}": bool_prop(f"A{i}") for i in range(1, kind.phys_out + 1)},
+            **{f'A{i}': bool_prop(f'A{i}') for i in range(1, kind.phys_out + 1)},
-            **{f"B{i}": bool_prop(f"B{i}") for i in range(1, kind.virt_out + 1)},
+            **{f'B{i}': bool_prop(f'B{i}') for i in range(1, kind.virt_out + 1)},
         },
     )
 
 
 _make_channelout_mixins = {
-    kind.name: _make_channelout_mixin(kind) for kind in kinds_all
+    kind.name: _make_channelout_mixin(kind) for kind in kinds.all
 }
 
 
@@ -522,12 +620,12 @@ def _make_effects_mixin(kind, is_phys):
     """creates an effects mixin for a kind"""
 
     def _make_xy_cls():
-        pan = {param: float_prop(param) for param in ["pan_x", "pan_y"]}
+        pan = {param: float_prop(param) for param in ['pan_x', 'pan_y']}
-        color = {param: float_prop(param) for param in ["color_x", "color_y"]}
+        color = {param: float_prop(param) for param in ['color_x', 'color_y']}
-        fx = {param: float_prop(param) for param in ["fx_x", "fx_y"]}
+        fx = {param: float_prop(param) for param in ['fx_x', 'fx_y']}
         if is_phys:
             return type(
-                "XYPhys",
+                'XYPhys',
                 (),
                 {
                     **pan,
@@ -536,7 +634,7 @@ def _make_effects_mixin(kind, is_phys):
                 },
             )
         return type(
-            "XYVirt",
+            'XYVirt',
             (),
             {**pan},
         )
@@ -544,32 +642,32 @@ def _make_effects_mixin(kind, is_phys):
     def _make_fx_cls():
         if is_phys:
             return type(
-                "FX",
+                'FX',
                 (),
                 {
                     **{
                         param: float_prop(param)
-                        for param in ["reverb", "delay", "fx1", "fx2"]
+                        for param in ['reverb', 'delay', 'fx1', 'fx2']
                     },
                     **{
-                        f"post{param}": bool_prop(f"post{param}")
+                        f'post{param}': bool_prop(f'post{param}')
-                        for param in ["reverb", "delay", "fx1", "fx2"]
+                        for param in ['reverb', 'delay', 'fx1', 'fx2']
                     },
                 },
             )
-        return type("FX", (), {})
+        return type('FX', (), {})
 
-    if kind.name == "basic":
+    if kind.name == 'basic':
         steps = (_make_xy_cls,)
-    elif kind.name == "banana":
+    elif kind.name == 'banana':
         steps = (_make_xy_cls,)
-    elif kind.name == "potato":
+    elif kind.name == 'potato':
         steps = (_make_xy_cls, _make_fx_cls)
-    return type(f"Effects{kind}", tuple(step() for step in steps), {})
+    return type(f'Effects{kind}', tuple(step() for step in steps), {})
 
 
 def _make_effects_mixins(is_phys):
-    return {kind.name: _make_effects_mixin(kind, is_phys) for kind in kinds_all}
+    return {kind.name: _make_effects_mixin(kind, is_phys) for kind in kinds.all}
 
 
 def strip_factory(is_phys_strip, remote, i) -> Union[PhysicalStrip, VirtualStrip]:
@@ -588,14 +686,14 @@ def strip_factory(is_phys_strip, remote, i) -> Union[PhysicalStrip, VirtualStrip
     CHANNELOUTMIXIN_cls = _make_channelout_mixins[remote.kind.name]
 
     _kls = (STRIP_cls, CHANNELOUTMIXIN_cls)
-    if remote.kind.name == "potato":
+    if remote.kind.name == 'potato':
         GAINLAYERMIXIN_cls = _make_gainlayer_mixin(remote, i)
         _kls += (GAINLAYERMIXIN_cls,)
     return type(
-        f"{STRIP_cls.__name__}{remote.kind}",
+        f'{STRIP_cls.__name__}{remote.kind}',
         _kls,
         {
-            "levels": StripLevel(remote, i),
+            'levels': StripLevel(remote, i),
         },
     )(remote, i)
 

voicemeeterlib/subject.py

@@ -20,10 +20,10 @@ class Subject:
         """run callbacks on update"""
 
         for o in self._observers:
-            if hasattr(o, "on_update"):
+            if hasattr(o, 'on_update'):
                 o.on_update(event)
             else:
-                if o.__name__ == f"on_{event}":
+                if o.__name__ == f'on_{event}':
                     o()
 
     def add(self, observer):
@@ -34,15 +34,15 @@ class Subject:
             for o in iterator:
                 if o not in self._observers:
                     self._observers.append(o)
-                    self.logger.info(f"{o} added to event observers")
+                    self.logger.info(f'{o} added to event observers')
                 else:
-                    self.logger.error(f"Failed to add {o} to event observers")
+                    self.logger.error(f'Failed to add {o} to event observers')
         except TypeError:
             if observer not in self._observers:
                 self._observers.append(observer)
-                self.logger.info(f"{observer} added to event observers")
+                self.logger.info(f'{observer} added to event observers')
             else:
-                self.logger.error(f"Failed to add {observer} to event observers")
+                self.logger.error(f'Failed to add {observer} to event observers')
 
     register = add
 
@@ -54,15 +54,15 @@ class Subject:
             for o in iterator:
                 try:
                     self._observers.remove(o)
-                    self.logger.info(f"{o} removed from event observers")
+                    self.logger.info(f'{o} removed from event observers')
                 except ValueError:
-                    self.logger.error(f"Failed to remove {o} from event observers")
+                    self.logger.error(f'Failed to remove {o} from event observers')
         except TypeError:
             try:
                 self._observers.remove(observer)
-                self.logger.info(f"{observer} removed from event observers")
+                self.logger.info(f'{observer} removed from event observers')
             except ValueError:
-                self.logger.error(f"Failed to remove {observer} from event observers")
+                self.logger.error(f'Failed to remove {observer} from event observers')
 
     deregister = remove
 

voicemeeterlib/updater.py

@@ -10,46 +10,48 @@ logger = logging.getLogger(__name__)
 class Producer(threading.Thread):
     """Continously send job queue to the Updater thread at a rate of self._remote.ratelimit."""
 
-    def __init__(self, remote, queue):
+    def __init__(self, remote, queue, stop_event):
-        super().__init__(name="producer", daemon=True)
+        super().__init__(name='producer', daemon=False)
         self._remote = remote
         self.queue = queue
+        self.stop_event = stop_event
         self.logger = logger.getChild(self.__class__.__name__)
 
+    def stopped(self):
+        return self.stop_event.is_set()
+
     def run(self):
-        while self._remote.running:
+        while not self.stopped():
             if self._remote.event.pdirty:
-                self.queue.put("pdirty")
+                self.queue.put('pdirty')
             if self._remote.event.mdirty:
-                self.queue.put("mdirty")
+                self.queue.put('mdirty')
             if self._remote.event.midi:
-                self.queue.put("midi")
+                self.queue.put('midi')
             if self._remote.event.ldirty:
-                self.queue.put("ldirty")
+                self.queue.put('ldirty')
             time.sleep(self._remote.ratelimit)
-        self.logger.debug(f"terminating {self.name} thread")
+        self.logger.debug(f'terminating {self.name} thread')
         self.queue.put(None)
 
 
 class Updater(threading.Thread):
     def __init__(self, remote, queue):
-        super().__init__(name="updater", daemon=True)
+        super().__init__(name='updater', daemon=True)
         self._remote = remote
         self.queue = queue
-        self._remote._strip_comp = [False] * (
+        self._remote._strip_comp = [False] * (self._remote.kind.num_strip_levels)
-            2 * self._remote.kind.phys_in + 8 * self._remote.kind.virt_in
+        self._remote._bus_comp = [False] * (self._remote.kind.num_bus_levels)
-        )
-        self._remote._bus_comp = [False] * (self._remote.kind.num_bus * 8)
         (
-            self._remote.cache["strip_level"],
+            self._remote.cache['strip_level'],
-            self._remote.cache["bus_level"],
+            self._remote.cache['bus_level'],
         ) = self._remote._get_levels()
         self.logger = logger.getChild(self.__class__.__name__)
 
     def _update_comps(self, strip_level, bus_level):
         self._remote._strip_comp, self._remote._bus_comp = (
-            tuple(not x for x in comp(self._remote.cache["strip_level"], strip_level)),
+            tuple(not x for x in comp(self._remote.cache['strip_level'], strip_level)),
-            tuple(not x for x in comp(self._remote.cache["bus_level"], bus_level)),
+            tuple(not x for x in comp(self._remote.cache['bus_level'], bus_level)),
         )
 
     def run(self):
@@ -58,20 +60,16 @@ class Updater(threading.Thread):
 
         Generate _strip_comp, _bus_comp and update level cache if ldirty.
         """
-        while True:
+        while event := self.queue.get():
-            event = self.queue.get()
+            if event == 'pdirty' and self._remote.pdirty:
-            if event is None:
-                self.logger.debug(f"terminating {self.name} thread")
-                break
-
-            if event == "pdirty" and self._remote.pdirty:
                 self._remote.subject.notify(event)
-            elif event == "mdirty" and self._remote.mdirty:
+            elif event == 'mdirty' and self._remote.mdirty:
                 self._remote.subject.notify(event)
-            elif event == "midi" and self._remote.get_midi_message():
+            elif event == 'midi' and self._remote.get_midi_message():
                 self._remote.subject.notify(event)
-            elif event == "ldirty" and self._remote.ldirty:
+            elif event == 'ldirty' and self._remote.ldirty:
                 self._update_comps(self._remote._strip_buf, self._remote._bus_buf)
-                self._remote.cache["strip_level"] = self._remote._strip_buf
+                self._remote.cache['strip_level'] = self._remote._strip_buf
-                self._remote.cache["bus_level"] = self._remote._bus_buf
+                self._remote.cache['bus_level'] = self._remote._bus_buf
                 self._remote.subject.notify(event)
+        self.logger.debug(f'terminating {self.name} thread')

voicemeeterlib/util.py

@@ -1,7 +1,41 @@
 import functools
+import time
 from itertools import zip_longest
 from typing import Iterator
 
+from .error import CAPIError, VMError
+
+
+def timeout(func):
+    """
+    Times out the login function once time elapsed exceeds remote.timeout.
+    """
+
+    @functools.wraps(func)
+    def wrapper(*args, **kwargs):
+        remote, *_ = args
+        func(*args, **kwargs)
+
+        err = None
+        start = time.time()
+        while time.time() < start + remote.timeout:
+            try:
+                time.sleep(0.1)  # ensure at least 0.1 delay before clearing dirty
+                remote.logger.info(
+                    f'{type(remote).__name__}: Successfully logged into {remote} version {remote.version}'
+                )
+                remote.logger.debug(f'login time: {round(time.time() - start, 2)}')
+                err = None
+                break
+            except CAPIError as e:
+                err = e
+                continue
+        if err:
+            raise VMError('Timeout logging into the api')
+        remote.clear_dirty()
+
+    return wrapper
+
 
 def polling(func):
     """
@@ -14,15 +48,15 @@ def polling(func):
 
     @functools.wraps(func)
     def wrapper(*args, **kwargs):
-        get = func.__name__ == "get"
+        get = func.__name__ == 'get'
-        mb_get = func.__name__ == "get_buttonstatus"
+        mb_get = func.__name__ == 'get_buttonstatus'
         remote, *remaining = args
 
         if get:
             param, *rem = remaining
         elif mb_get:
             id, mode, *rem = remaining
-            param = f"mb_{id}_{mode}"
+            param = f'mb_{id}_{mode}'
 
         if param in remote.cache:
             return remote.cache.pop(param)
@@ -39,15 +73,15 @@ def script(func):
     def wrapper(*args):
         remote, script = args
         if isinstance(script, dict):
-            params = ""
+            params = ''
             for key, val in script.items():
-                obj, m2, *rem = key.split("-")
+                obj, m2, *rem = key.split('-')
                 index = int(m2) if m2.isnumeric() else int(*rem)
-                params += ";".join(
+                params += ';'.join(
                     f"{obj}{f'.{m2}stream' if not m2.isnumeric() else ''}[{index}].{k}={int(v) if isinstance(v, bool) else v}"
                     for k, v in val.items()
                 )
-                params += ";"
+                params += ';'
             script = params
         return func(remote, script)
 
@@ -70,3 +104,17 @@ def grouper(n, iterable, fillvalue=None):
     """
     args = [iter(iterable)] * n
     return zip_longest(fillvalue=fillvalue, *args)
+
+
+def deep_merge(dict1, dict2):
+    """Generator function for deep merging two dicts"""
+    for k in set(dict1) | set(dict2):
+        if k in dict1 and k in dict2:
+            if isinstance(dict1[k], dict) and isinstance(dict2[k], dict):
+                yield k, dict(deep_merge(dict1[k], dict2[k]))
+            else:
+                yield k, dict2[k]
+        elif k in dict1:
+            yield k, dict1[k]
+        else:
+            yield k, dict2[k]

voicemeeterlib/vban.py

@@ -1,6 +1,6 @@
-from abc import abstractmethod
+import abc
 
-from .error import VMError
+from . import kinds
 from .iremote import IRemote
 
 
@@ -11,98 +11,100 @@ class VbanStream(IRemote):
     Defines concrete implementation for vban stream
     """
 
-    @abstractmethod
+    @abc.abstractmethod
     def __str__(self):
         pass
 
     @property
     def identifier(self) -> str:
-        return f"vban.{self.direction}stream[{self.index}]"
+        return f'vban.{self.direction}stream[{self.index}]'
 
     @property
     def on(self) -> bool:
-        return self.getter("on") == 1
+        return self.getter('on') == 1
 
     @on.setter
     def on(self, val: bool):
-        self.setter("on", 1 if val else 0)
+        self.setter('on', 1 if val else 0)
 
     @property
     def name(self) -> str:
-        return self.getter("name", is_string=True)
+        return self.getter('name', is_string=True)
 
     @name.setter
     def name(self, val: str):
-        self.setter("name", val)
+        self.setter('name', val)
 
     @property
     def ip(self) -> str:
-        return self.getter("ip", is_string=True)
+        return self.getter('ip', is_string=True)
 
     @ip.setter
     def ip(self, val: str):
-        self.setter("ip", val)
+        self.setter('ip', val)
 
     @property
     def port(self) -> int:
-        return int(self.getter("port"))
+        return int(self.getter('port'))
 
     @port.setter
     def port(self, val: int):
         if not 1024 <= val <= 65535:
-            raise VMError("Expected value from 1024 to 65535")
+            self.logger.warning(
-        self.setter("port", val)
+                f'port got: {val} but expected a value from 1024 to 65535'
+            )
+        self.setter('port', val)
 
     @property
     def sr(self) -> int:
-        return int(self.getter("sr"))
+        return int(self.getter('sr'))
 
     @sr.setter
     def sr(self, val: int):
         opts = (11025, 16000, 22050, 24000, 32000, 44100, 48000, 64000, 88200, 96000)
         if val not in opts:
-            raise VMError(f"Expected one of: {opts}")
+            self.logger.warning(f'sr got: {val} but expected a value in {opts}')
-        self.setter("sr", val)
+        self.setter('sr', val)
 
     @property
     def channel(self) -> int:
-        return int(self.getter("channel"))
+        return int(self.getter('channel'))
 
     @channel.setter
     def channel(self, val: int):
         if not 1 <= val <= 8:
-            raise VMError("Expected value from 1 to 8")
+            self.logger.warning(f'channel got: {val} but expected a value from 1 to 8')
-        self.setter("channel", val)
+        self.setter('channel', val)
 
     @property
     def bit(self) -> int:
-        return 16 if (int(self.getter("bit") == 1)) else 24
+        return 16 if (int(self.getter('bit') == 1)) else 24
 
     @bit.setter
     def bit(self, val: int):
         if val not in (16, 24):
-            raise VMError("Expected value 16 or 24")
+            self.logger.warning(f'bit got: {val} but expected value 16 or 24')
-        self.setter("bit", 1 if (val == 16) else 2)
+        self.setter('bit', 1 if (val == 16) else 2)
 
     @property
     def quality(self) -> int:
-        return int(self.getter("quality"))
+        return int(self.getter('quality'))
 
     @quality.setter
     def quality(self, val: int):
         if not 0 <= val <= 4:
-            raise VMError("Expected value from 0 to 4")
+            self.logger.warning(f'quality got: {val} but expected a value from 0 to 4')
-        self.setter("quality", val)
+        self.setter('quality', val)
 
     @property
     def route(self) -> int:
-        return int(self.getter("route"))
+        return int(self.getter('route'))
 
     @route.setter
     def route(self, val: int):
         if not 0 <= val <= 8:
-            raise VMError("Expected value from 0 to 8")
+            self.logger.warning(f'route got: {val} but expected a value from 0 to 8')
-        self.setter("route", val)
+        self.setter('route', val)
 
 
 class VbanInstream(VbanStream):
@@ -113,11 +115,11 @@ class VbanInstream(VbanStream):
     """
 
     def __str__(self):
-        return f"{type(self).__name__}{self._remote.kind}{self.index}"
+        return f'{type(self).__name__}{self._remote.kind}{self.index}'
 
     @property
     def direction(self) -> str:
-        return "in"
+        return 'in'
 
     @property
     def sr(self) -> int:
@@ -132,6 +134,18 @@ class VbanInstream(VbanStream):
         return super(VbanInstream, self).bit
 
 
+class VbanAudioInstream(VbanInstream):
+    """Represents a VBAN Audio Instream"""
+
+
+class VbanMidiInstream(VbanInstream):
+    """Represents a VBAN Midi Instream"""
+
+
+class VbanTextInstream(VbanInstream):
+    """Represents a VBAN Text Instream"""
+
+
 class VbanOutstream(VbanStream):
     """
     class representing a vban outstream
@@ -140,11 +154,47 @@ class VbanOutstream(VbanStream):
     """
 
     def __str__(self):
-        return f"{type(self).__name__}{self._remote.kind}{self.index}"
+        return f'{type(self).__name__}{self._remote.kind}{self.index}'
 
     @property
     def direction(self) -> str:
-        return "out"
+        return 'out'
+
+
+class VbanAudioOutstream(VbanOutstream):
+    """Represents a VBAN Audio Outstream"""
+
+
+class VbanMidiOutstream(VbanOutstream):
+    """Represents a VBAN Midi Outstream"""
+
+
+def _make_stream_pair(remote, kind):
+    num_instream, num_outstream, num_midi, num_text = kind.vban
+
+    def _make_cls(i, direction):
+        match direction:
+            case 'in':
+                if i < num_instream:
+                    return VbanAudioInstream(remote, i)
+                elif i < num_instream + num_midi:
+                    return VbanMidiInstream(remote, i)
+                else:
+                    return VbanTextInstream(remote, i)
+            case 'out':
+                if i < num_outstream:
+                    return VbanAudioOutstream(remote, i)
+                else:
+                    return VbanMidiOutstream(remote, i)
+
+    return (
+        tuple(_make_cls(i, 'in') for i in range(num_instream + num_midi + num_text)),
+        tuple(_make_cls(i, 'out') for i in range(num_outstream + num_midi)),
+    )
+
+
+def _make_stream_pairs(remote):
+    return {kind.name: _make_stream_pair(remote, kind) for kind in kinds.all}
 
 
 class Vban:
@@ -156,15 +206,13 @@ class Vban:
 
     def __init__(self, remote):
         self.remote = remote
-        num_instream, num_outstream = remote.kind.vban
+        self.instream, self.outstream = _make_stream_pairs(remote)[remote.kind.name]
-        self.instream = tuple(VbanInstream(remote, i) for i in range(num_instream))
-        self.outstream = tuple(VbanOutstream(remote, i) for i in range(num_outstream))
 
     def enable(self):
-        self.remote.set("vban.Enable", 1)
+        self.remote.set('vban.Enable', 1)
 
     def disable(self):
-        self.remote.set("vban.Enable", 0)
+        self.remote.set('vban.Enable', 0)
 
 
 def vban_factory(remote) -> Vban:
@@ -174,7 +222,7 @@ def vban_factory(remote) -> Vban:
     Returns a class that represents the VBAN module.
     """
     VBAN_cls = Vban
-    return type(f"{VBAN_cls.__name__}", (VBAN_cls,), {})(remote)
+    return type(f'{VBAN_cls.__name__}', (VBAN_cls,), {})(remote)
 
 
 def request_vban_obj(remote) -> Vban: