reword

In case the events thread was not initiated.

examples/events/__main__.py

@@ -1,7 +1,5 @@
-import json
 import logging
 import time
-from logging import config
 
 import voicemeeterlib
 

examples/midi/__main__.py

@@ -14,19 +14,20 @@ class App:
         self.vm.observer.add(self.on_midi)
 
     def on_midi(self):
-        self.get_info()
-        self.on_midi_press()
+        if self.get_info() == self.MIDI_BUTTON:
+            self.on_midi_press()
 
     def get_info(self):
         current = self.vm.midi.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
-            and self.vm.midi.get(self.MIDI_BUTTON) == 127
+            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"

pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "voicemeeter-api"
-version = "2.3.3"
+version = "2.4.4"
 description = "A Python wrapper for the Voiceemeter API"
 authors = ["onyx-and-iris <code@onyxandiris.online>"]
 license = "MIT"

voicemeeterlib/bus.py

@@ -210,7 +210,7 @@ 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]]
         else:
             vals = [self._remote.get_level(mode, i) for i in range(*self.range)]
@@ -232,7 +232,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

voicemeeterlib/cbindings.py

@@ -18,98 +18,98 @@ class CBindings(metaclass=ABCMeta):
 
     logger_cbindings = logger.getChild("CBindings")
 
-    vm_login = libc.VBVMR_Login
-    vm_login.restype = LONG
-    vm_login.argtypes = None
+    bind_login = libc.VBVMR_Login
+    bind_login.restype = LONG
+    bind_login.argtypes = None
 
-    vm_logout = libc.VBVMR_Logout
-    vm_logout.restype = LONG
-    vm_logout.argtypes = None
+    bind_logout = libc.VBVMR_Logout
+    bind_logout.restype = LONG
+    bind_logout.argtypes = None
 
-    vm_runvm = libc.VBVMR_RunVoicemeeter
-    vm_runvm.restype = LONG
-    vm_runvm.argtypes = [LONG]
+    bind_run_voicemeeter = libc.VBVMR_RunVoicemeeter
+    bind_run_voicemeeter.restype = LONG
+    bind_run_voicemeeter.argtypes = [LONG]
 
-    vm_get_type = libc.VBVMR_GetVoicemeeterType
-    vm_get_type.restype = LONG
-    vm_get_type.argtypes = [ct.POINTER(LONG)]
+    bind_get_voicemeeter_type = libc.VBVMR_GetVoicemeeterType
+    bind_get_voicemeeter_type.restype = LONG
+    bind_get_voicemeeter_type.argtypes = [ct.POINTER(LONG)]
 
-    vm_get_version = libc.VBVMR_GetVoicemeeterVersion
-    vm_get_version.restype = LONG
-    vm_get_version.argtypes = [ct.POINTER(LONG)]
+    bind_get_voicemeeter_version = libc.VBVMR_GetVoicemeeterVersion
+    bind_get_voicemeeter_version.restype = LONG
+    bind_get_voicemeeter_version.argtypes = [ct.POINTER(LONG)]
 
     if hasattr(libc, "VBVMR_MacroButton_IsDirty"):
-        vm_mdirty = libc.VBVMR_MacroButton_IsDirty
-        vm_mdirty.restype = LONG
-        vm_mdirty.argtypes = None
+        bind_macro_button_is_dirty = libc.VBVMR_MacroButton_IsDirty
+        bind_macro_button_is_dirty.restype = LONG
+        bind_macro_button_is_dirty.argtypes = None
 
     if hasattr(libc, "VBVMR_MacroButton_GetStatus"):
-        vm_get_buttonstatus = libc.VBVMR_MacroButton_GetStatus
-        vm_get_buttonstatus.restype = LONG
-        vm_get_buttonstatus.argtypes = [LONG, ct.POINTER(FLOAT), LONG]
+        bind_macro_button_get_status = libc.VBVMR_MacroButton_GetStatus
+        bind_macro_button_get_status.restype = LONG
+        bind_macro_button_get_status.argtypes = [LONG, ct.POINTER(FLOAT), LONG]
 
     if hasattr(libc, "VBVMR_MacroButton_SetStatus"):
-        vm_set_buttonstatus = libc.VBVMR_MacroButton_SetStatus
-        vm_set_buttonstatus.restype = LONG
-        vm_set_buttonstatus.argtypes = [LONG, FLOAT, LONG]
+        bind_macro_button_set_status = libc.VBVMR_MacroButton_SetStatus
+        bind_macro_button_set_status.restype = LONG
+        bind_macro_button_set_status.argtypes = [LONG, FLOAT, LONG]
 
-    vm_pdirty = libc.VBVMR_IsParametersDirty
-    vm_pdirty.restype = LONG
-    vm_pdirty.argtypes = None
+    bind_is_parameters_dirty = libc.VBVMR_IsParametersDirty
+    bind_is_parameters_dirty.restype = LONG
+    bind_is_parameters_dirty.argtypes = None
 
-    vm_get_parameter_float = libc.VBVMR_GetParameterFloat
-    vm_get_parameter_float.restype = LONG
-    vm_get_parameter_float.argtypes = [ct.POINTER(CHAR), ct.POINTER(FLOAT)]
+    bind_get_parameter_float = libc.VBVMR_GetParameterFloat
+    bind_get_parameter_float.restype = LONG
+    bind_get_parameter_float.argtypes = [ct.POINTER(CHAR), ct.POINTER(FLOAT)]
 
-    vm_set_parameter_float = libc.VBVMR_SetParameterFloat
-    vm_set_parameter_float.restype = LONG
-    vm_set_parameter_float.argtypes = [ct.POINTER(CHAR), FLOAT]
+    bind_set_parameter_float = libc.VBVMR_SetParameterFloat
+    bind_set_parameter_float.restype = LONG
+    bind_set_parameter_float.argtypes = [ct.POINTER(CHAR), FLOAT]
 
-    vm_get_parameter_string = libc.VBVMR_GetParameterStringW
-    vm_get_parameter_string.restype = LONG
-    vm_get_parameter_string.argtypes = [ct.POINTER(CHAR), ct.POINTER(WCHAR * 512)]
+    bind_get_parameter_string_w = libc.VBVMR_GetParameterStringW
+    bind_get_parameter_string_w.restype = LONG
+    bind_get_parameter_string_w.argtypes = [ct.POINTER(CHAR), ct.POINTER(WCHAR * 512)]
 
-    vm_set_parameter_string = libc.VBVMR_SetParameterStringW
-    vm_set_parameter_string.restype = LONG
-    vm_set_parameter_string.argtypes = [ct.POINTER(CHAR), ct.POINTER(WCHAR)]
+    bind_set_parameter_string_w = libc.VBVMR_SetParameterStringW
+    bind_set_parameter_string_w.restype = LONG
+    bind_set_parameter_string_w.argtypes = [ct.POINTER(CHAR), ct.POINTER(WCHAR)]
 
-    vm_set_parameter_multi = libc.VBVMR_SetParameters
-    vm_set_parameter_multi.restype = LONG
-    vm_set_parameter_multi.argtypes = [ct.POINTER(CHAR)]
+    bind_set_parameters = libc.VBVMR_SetParameters
+    bind_set_parameters.restype = LONG
+    bind_set_parameters.argtypes = [ct.POINTER(CHAR)]
 
-    vm_get_level = libc.VBVMR_GetLevel
-    vm_get_level.restype = LONG
-    vm_get_level.argtypes = [LONG, LONG, ct.POINTER(FLOAT)]
+    bind_get_level = libc.VBVMR_GetLevel
+    bind_get_level.restype = LONG
+    bind_get_level.argtypes = [LONG, LONG, ct.POINTER(FLOAT)]
 
-    vm_get_num_indevices = libc.VBVMR_Input_GetDeviceNumber
-    vm_get_num_indevices.restype = LONG
-    vm_get_num_indevices.argtypes = None
+    bind_input_get_device_number = libc.VBVMR_Input_GetDeviceNumber
+    bind_input_get_device_number.restype = LONG
+    bind_input_get_device_number.argtypes = None
 
-    vm_get_desc_indevices = libc.VBVMR_Input_GetDeviceDescW
-    vm_get_desc_indevices.restype = LONG
-    vm_get_desc_indevices.argtypes = [
+    bind_input_get_device_desc_w = libc.VBVMR_Input_GetDeviceDescW
+    bind_input_get_device_desc_w.restype = LONG
+    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
-    vm_get_num_outdevices.restype = LONG
-    vm_get_num_outdevices.argtypes = None
+    bind_output_get_device_number = libc.VBVMR_Output_GetDeviceNumber
+    bind_output_get_device_number.restype = LONG
+    bind_output_get_device_number.argtypes = None
 
-    vm_get_desc_outdevices = libc.VBVMR_Output_GetDeviceDescW
-    vm_get_desc_outdevices.restype = LONG
-    vm_get_desc_outdevices.argtypes = [
+    bind_output_get_device_desc_w = libc.VBVMR_Output_GetDeviceDescW
+    bind_output_get_device_desc_w.restype = LONG
+    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
-    vm_get_midi_message.restype = LONG
-    vm_get_midi_message.argtypes = [ct.POINTER(CHAR * 1024), LONG]
+    bind_get_midi_message = libc.VBVMR_GetMidiMessage
+    bind_get_midi_message.restype = LONG
+    bind_get_midi_message.argtypes = [ct.POINTER(CHAR * 1024), LONG]
 
     def call(self, func, *args, ok=(0,), ok_exp=None):
         try:

voicemeeterlib/config.py

@@ -147,8 +147,13 @@ class Loader(metaclass=SingletonType):
             self.logger.info(
                 f"config file with name {identifier} already in memory, skipping.."
             )
-            return False
-        self.parser = dataextraction_factory(data)
+            return
+        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):

voicemeeterlib/error.py

@@ -1,19 +1,22 @@
-class InstallError(Exception):
-    """Exception raised when installation errors occur"""
+class VMError(Exception):
+    """Base VM Exception class. Raised when general errors occur."""
 
-
-class CAPIError(Exception):
-    """Exception raised when the C-API returns error values"""
-
-    def __init__(self, fn_name, code, msg=None):
-        self.fn_name = fn_name
-        self.code = code
-        self.message = msg if msg else f"{fn_name} returned {code}"
+    def __init__(self, msg):
+        self.message = msg
         super().__init__(self.message)
 
     def __str__(self):
         return f"{type(self).__name__}: {self.message}"
 
 
-class VMError(Exception):
-    """Exception raised when general errors occur"""
+class InstallError(VMError):
+    """Exception raised when installation errors occur"""
+
+
+class CAPIError(VMError):
+    """Exception raised when the C-API returns an error code"""
+
+    def __init__(self, fn_name, code, msg=None):
+        self.fn_name = fn_name
+        self.code = code
+        super(CAPIError, self).__init__(msg if msg else f"{fn_name} returned {code}")

voicemeeterlib/factory.py

@@ -2,7 +2,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
@@ -51,7 +51,7 @@ class FactoryBuilder:
         )
         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]
         self.logger.debug(self._info[int(getattr(self.BuilderProgress, name))])

voicemeeterlib/kinds.py

@@ -32,29 +32,37 @@ class KindMapClass(metaclass=SingletonType):
     insert: 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()
 

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)
 
 
@@ -22,24 +34,24 @@ class MacroButton(Adapter):
 
     @property
     def state(self) -> bool:
-        return self.getter(1) == 1
+        return self.getter(ButtonModes.state) == 1
 
     @state.setter
-    def state(self, val):
-        self.setter(1 if val else 0, 1)
+    def state(self, val: bool):
+        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):
-        self.setter(1 if val else 0, 2)
+    def stateonly(self, val: bool):
+        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):
-        self.setter(1 if val else 0, 3)
+    def trigger(self, val: bool):
+        self.setter(ButtonModes.trigger, 1 if val else 0)

voicemeeterlib/remote.py

@@ -1,10 +1,10 @@
-import copy
 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
@@ -29,11 +29,11 @@ class Remote(CBindings):
         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")}
         )
         self.gui = VmGui()
+        self.stop_event = None
         self.logger = logger.getChild(self.__class__.__name__)
 
         for attr, val in kwargs.items():
@@ -53,19 +53,23 @@ class Remote(CBindings):
 
     def init_thread(self):
         """Starts updates thread."""
-        self.running = True
         self.event.info()
 
         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()
+
+    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.call(self.bind_login, ok=(0, 1)) == 0
         if not self.gui.launched:
             self.logger.info(
                 "Voicemeeter engine running but GUI not launched. Launching the GUI now."
@@ -76,28 +80,28 @@ class Remote(CBindings):
         )
         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 + 3
         else:
             value = KindId[kind_id.upper()].value
-        self.call(self.vm_runvm, value)
+        self.call(self.bind_run_voicemeeter, 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.call(self.bind_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.call(self.bind_get_voicemeeter_version, ct.byref(ver))
         return "{}.{}.{}.{}".format(
             (ver.value & 0xFF000000) >> 24,
             (ver.value & 0x00FF0000) >> 16,
@@ -108,13 +112,13 @@ 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.call(self.bind_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.call(self.bind_macro_button_is_dirty, ok=(0, 1)) == 1
         except AttributeError as e:
             self.logger.exception(f"{type(e).__name__}: {e}")
             ERR_MSG = (
@@ -134,7 +138,7 @@ class Remote(CBindings):
             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
@@ -150,33 +154,35 @@ 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.call(self.bind_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.call(self.bind_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")
-            self.call(self.vm_set_parameter_string, param.encode(), ct.c_wchar_p(val))
+            self.call(
+                self.bind_set_parameter_string_w, param.encode(), ct.c_wchar_p(val)
+            )
         else:
             self.call(
-                self.vm_set_parameter_float, param.encode(), ct.c_float(float(val))
+                self.bind_set_parameter_float, 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.vm_get_buttonstatus,
-                ct.c_long(id),
-                ct.byref(state),
+                self.bind_macro_button_get_status,
+                ct.c_long(id_),
+                ct.byref(c_state),
                 ct.c_long(mode),
             )
         except AttributeError as e:
@@ -188,13 +194,18 @@ class Remote(CBindings):
             raise CAPIError(
                 "VBVMR_MacroButton_GetStatus", -9, msg=" ".join(ERR_MSG)
             ) from e
-        return int(state.value)
+        return int(c_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.call(
+                self.bind_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}")
             ERR_MSG = (
@@ -204,13 +215,13 @@ class Remote(CBindings):
             raise CAPIError(
                 "VBVMR_MacroButton_SetStatus", -9, msg=" ".join(ERR_MSG)
             ) from e
-        self.cache[f"mb_{id}_{mode}"] = int(c_state.value)
+        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"):
             raise VMError("Expected a direction: in or out")
-        func = getattr(self, f"vm_get_num_{direction}devices")
+        func = getattr(self, f"bind_{direction}put_get_device_number")
         res = self.call(func, ok_exp=lambda r: r >= 0)
         return res
 
@@ -221,7 +232,7 @@ class Remote(CBindings):
         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, f"bind_{direction}put_get_device_desc_w")
         self.call(
             func,
             ct.c_long(index),
@@ -234,7 +245,9 @@ 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.call(
+            self.bind_get_level, ct.c_long(type_), ct.c_long(index), ct.byref(val)
+        )
         return val.value
 
     def _get_levels(self) -> Iterable:
@@ -244,19 +257,16 @@ 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)
-            ),
-            tuple(
-                self.get_level(3, i)
-                for i in range(8 * (self.kind.phys_out + self.kind.virt_out))
+                for i in range(self.kind.num_strip_levels)
             ),
+            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.call(
-            self.vm_get_midi_message,
+            self.bind_get_midi_message,
             ct.byref(buf),
             n,
             ok=(-5, -6),  # no data received from midi device
@@ -279,7 +289,7 @@ class Remote(CBindings):
         """Sets many parameters from a script"""
         if len(script) > 48000:
             raise ValueError("Script too large, max size 48kB")
-        self.call(self.vm_set_parameter_multi, script.encode())
+        self.call(self.bind_set_parameters, script.encode())
         time.sleep(self.DELAY * 5)
 
     def apply(self, data: dict):
@@ -325,17 +335,19 @@ class Remote(CBindings):
         self.apply(config)
         self.logger.info(f"Profile '{name}' applied!")
 
-    def logout(self) -> NoReturn:
-        """Wait for dirty parameters to clear, then logout of the API"""
+    def end_thread(self):
+        if not self.stopped():
+            self.logger.debug("events thread shutdown started")
+            self.stop_event.set()
+            self.producer.join()  # wait for producer thread to complete cycle
+
+    def logout(self) -> None:
+        """Logout of the API"""
         time.sleep(0.1)
-        self.call(self.vm_logout)
+        self.call(self.bind_logout)
         self.logger.info(f"{type(self).__name__}: Successfully logged out of {self}")
 
-    def end_thread(self):
-        self.logger.debug("events thread shutdown started")
-        self.running = False
-
-    def __exit__(self, exc_type, exc_value, exc_traceback) -> NoReturn:
+    def __exit__(self, exc_type, exc_value, exc_traceback) -> None:
         """teardown procedures"""
         self.end_thread()
         self.logout()

voicemeeterlib/strip.py

@@ -364,7 +364,7 @@ class VirtualStrip(Strip):
         self.setter("karaoke", val)
 
     @property
-    def bass(self):
+    def bass(self) -> float:
         return round(self.getter("EQGain1"), 1)
 
     @bass.setter
@@ -372,7 +372,7 @@ class VirtualStrip(Strip):
         self.setter("EQGain1", val)
 
     @property
-    def mid(self):
+    def mid(self) -> float:
         return round(self.getter("EQGain2"), 1)
 
     @mid.setter
@@ -382,7 +382,7 @@ class VirtualStrip(Strip):
     med = mid
 
     @property
-    def treble(self):
+    def treble(self) -> float:
         return round(self.getter("EQGain3"), 1)
 
     high = treble
@@ -415,7 +415,7 @@ 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]]
         else:
             vals = [self._remote.get_level(mode, i) for i in range(*self.range)]
@@ -448,7 +448,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

voicemeeterlib/updater.py

@@ -10,14 +10,18 @@ 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):
-        super().__init__(name="producer", daemon=True)
+    def __init__(self, remote, queue, stop_event):
+        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")
             if self._remote.event.mdirty:
@@ -36,10 +40,8 @@ class Updater(threading.Thread):
         super().__init__(name="updater", daemon=True)
         self._remote = remote
         self.queue = queue
-        self._remote._strip_comp = [False] * (
-            2 * self._remote.kind.phys_in + 8 * self._remote.kind.virt_in
-        )
-        self._remote._bus_comp = [False] * (self._remote.kind.num_bus * 8)
+        self._remote._strip_comp = [False] * (self._remote.kind.num_strip_levels)
+        self._remote._bus_comp = [False] * (self._remote.kind.num_bus_levels)
         (
             self._remote.cache["strip_level"],
             self._remote.cache["bus_level"],
@@ -58,12 +60,7 @@ class Updater(threading.Thread):
 
         Generate _strip_comp, _bus_comp and update level cache if ldirty.
         """
-        while True:
-            event = self.queue.get()
-            if event is None:
-                self.logger.debug(f"terminating {self.name} thread")
-                break
-
+        while event := self.queue.get():
             if event == "pdirty" and self._remote.pdirty:
                 self._remote.subject.notify(event)
             elif event == "mdirty" and self._remote.mdirty:
@@ -75,3 +72,4 @@ class Updater(threading.Thread):
                 self._remote.cache["strip_level"] = self._remote._strip_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,4 +1,3 @@
-import copy
 import functools
 from itertools import zip_longest
 from typing import Iterator

voicemeeterlib/vban.py

@@ -135,18 +135,15 @@ class VbanInstream(VbanStream):
 
 
 class VbanAudioInstream(VbanInstream):
-    def __str__(self):
-        return f"{type(self).__name__}{self._remote.kind}{self.index}"
+    """Represents a VBAN Audio Instream"""
 
 
 class VbanMidiInstream(VbanInstream):
-    def __str__(self):
-        return f"{type(self).__name__}{self._remote.kind}{self.index}"
+    """Represents a VBAN Midi Instream"""
 
 
 class VbanTextInstream(VbanInstream):
-    def __str__(self):
-        return f"{type(self).__name__}{self._remote.kind}{self.index}"
+    """Represents a VBAN Text Instream"""
 
 
 class VbanOutstream(VbanStream):
@@ -165,44 +162,34 @@ class VbanOutstream(VbanStream):
 
 
 class VbanAudioOutstream(VbanOutstream):
-    def __str__(self):
-        return f"{type(self).__name__}{self._remote.kind}{self.index}"
+    """Represents a VBAN Audio Outstream"""
 
 
 class VbanMidiOutstream(VbanOutstream):
-    def __str__(self):
-        return f"{type(self).__name__}{self._remote.kind}{self.index}"
+    """Represents a VBAN Midi Outstream"""
 
 
 def _make_stream_pair(remote, kind):
     num_instream, num_outstream, num_midi, num_text = kind.vban
 
-    def _generate_streams(i, dir):
-        """generator function for instream/outstream types"""
-        if dir == "in":
-            if i < num_instream:
-                yield VbanAudioInstream
-            elif i < num_instream + num_midi:
-                yield VbanMidiInstream
-            else:
-                yield VbanTextInstream
-        else:
-            if i < num_outstream:
-                yield VbanAudioOutstream
-            else:
-                yield VbanMidiOutstream
+    def _make_cls(i, dir):
+        match dir:
+            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(
-            cls(remote, i)
-            for i in range(num_instream + num_midi + num_text)
-            for cls in _generate_streams(i, "in")
-        ),
-        tuple(
-            cls(remote, i)
-            for i in range(num_outstream + num_midi)
-            for cls in _generate_streams(i, "out")
-        ),
+        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)),
     )