README.md

@@ -548,7 +548,7 @@ You may pass the following optional keyword arguments:
 -   `channel`: int=0, channel on which to send the UDP requests.
 -   `pdirty`: boolean=False, parameter updates
 -   `ldirty`: boolean=False, level updates
--   `script_ratelimit`: float | None=None, ratelimit for vban.sendtext() specifically.
+-   `script_ratelimit`: float=0.05, default to 20 script requests per second. This affects vban.sendtext() specifically.
 -   `timeout`: int=5, timeout for socket operations.
 -   `disable_rt_listeners`: boolean=False, set `True` if you don't wish to receive RT packets.
     -   You can still send Matrix string requests ending with `?` and receive a response.

examples/gui/__main__.py

@@ -103,7 +103,7 @@ class App(tk.Tk):
 def main():
     KIND_ID = 'banana'
     conn = {
-        'host': os.environ.get('VBANCMD_HOST', 'localhost'),
+        'ip': os.environ.get('VBANCMD_IP', 'localhost'),
         'port': int(os.environ.get('VBANCMD_PORT', 6980)),
         'streamname': os.environ.get('VBANCMD_STREAMNAME', 'Command1'),
     }

examples/obs/__main__.py

@@ -94,7 +94,7 @@ class Observer:
 def main():
     KIND_ID = 'potato'
     conn = {
-        'host': os.environ.get('VBANCMD_HOST', 'localhost'),
+        'ip': os.environ.get('VBANCMD_IP', 'localhost'),
         'port': int(os.environ.get('VBANCMD_PORT', 6980)),
         'streamname': os.environ.get('VBANCMD_STREAMNAME', 'Command1'),
     }

examples/observer/__main__.py

@@ -25,7 +25,7 @@ class App:
 def main():
     KIND_ID = 'banana'
     conn = {
-        'host': os.environ.get('VBANCMD_HOST', 'localhost'),
+        'ip': os.environ.get('VBANCMD_IP', 'localhost'),
         'port': int(os.environ.get('VBANCMD_PORT', 6980)),
         'streamname': os.environ.get('VBANCMD_STREAMNAME', 'Command1'),
     }

poetry.lock

@@ -1,4 +1,4 @@
-# This file is automatically @generated by Poetry 2.2.1 and should not be changed by hand.
+# This file is automatically @generated by Poetry 2.0.1 and should not be changed by hand.
 
 [[package]]
 name = "cachetools"
@@ -55,7 +55,7 @@ description = "Backport of PEP 654 (exception groups)"
 optional = false
 python-versions = ">=3.7"
 groups = ["dev"]
-markers = "python_version == \"3.10\""
+markers = "python_version < \"3.11\""
 files = [
     {file = "exceptiongroup-1.2.2-py3-none-any.whl", hash = "sha256:3111b9d131c238bec2f8f516e123e14ba243563fb135d3fe885990585aa7795b"},
     {file = "exceptiongroup-1.2.2.tar.gz", hash = "sha256:47c2edf7c6738fafb49fd34290706d1a1a2f4d1c6df275526b62cbb4aa5393cc"},
@@ -66,16 +66,21 @@ test = ["pytest (>=6)"]
 
 [[package]]
 name = "filelock"
-version = "3.20.3"
+version = "3.16.1"
 description = "A platform independent file lock."
 optional = false
-python-versions = ">=3.10"
+python-versions = ">=3.8"
 groups = ["dev"]
 files = [
-    {file = "filelock-3.20.3-py3-none-any.whl", hash = "sha256:4b0dda527ee31078689fc205ec4f1c1bf7d56cf88b6dc9426c4f230e46c2dce1"},
-    {file = "filelock-3.20.3.tar.gz", hash = "sha256:18c57ee915c7ec61cff0ecf7f0f869936c7c30191bb0cf406f1341778d0834e1"},
+    {file = "filelock-3.16.1-py3-none-any.whl", hash = "sha256:2082e5703d51fbf98ea75855d9d5527e33d8ff23099bec374a134febee6946b0"},
+    {file = "filelock-3.16.1.tar.gz", hash = "sha256:c249fbfcd5db47e5e2d6d62198e565475ee65e4831e2561c8e313fa7eb961435"},
 ]
 
+[package.extras]
+docs = ["furo (>=2024.8.6)", "sphinx (>=8.0.2)", "sphinx-autodoc-typehints (>=2.4.1)"]
+testing = ["covdefaults (>=2.3)", "coverage (>=7.6.1)", "diff-cover (>=9.2)", "pytest (>=8.3.3)", "pytest-asyncio (>=0.24)", "pytest-cov (>=5)", "pytest-mock (>=3.14)", "pytest-timeout (>=2.3.1)", "virtualenv (>=20.26.4)"]
+typing = ["typing-extensions (>=4.12.2)"]
+
 [[package]]
 name = "iniconfig"
 version = "2.0.0"
@@ -238,7 +243,7 @@ description = "A lil' TOML parser"
 optional = false
 python-versions = ">=3.8"
 groups = ["main", "dev"]
-markers = "python_version == \"3.10\""
+markers = "python_version < \"3.11\""
 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"},
@@ -304,38 +309,37 @@ test = ["devpi-process (>=1.0.2)", "pytest (>=8.3.3)", "pytest-mock (>=3.14)"]
 
 [[package]]
 name = "typing-extensions"
-version = "4.15.0"
-description = "Backported and Experimental Type Hints for Python 3.9+"
+version = "4.12.2"
+description = "Backported and Experimental Type Hints for Python 3.8+"
 optional = false
-python-versions = ">=3.9"
+python-versions = ">=3.8"
 groups = ["dev"]
-markers = "python_version == \"3.10\""
+markers = "python_version < \"3.11\""
 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"},
+    {file = "typing_extensions-4.12.2-py3-none-any.whl", hash = "sha256:04e5ca0351e0f3f85c6853954072df659d0d13fac324d0072316b67d7794700d"},
+    {file = "typing_extensions-4.12.2.tar.gz", hash = "sha256:1a7ead55c7e559dd4dee8856e3a88b41225abfe1ce8df57b7c13915fe121ffb8"},
 ]
 
 [[package]]
 name = "virtualenv"
-version = "20.36.1"
+version = "20.29.0"
 description = "Virtual Python Environment builder"
 optional = false
 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"},
+    {file = "virtualenv-20.29.0-py3-none-any.whl", hash = "sha256:c12311863497992dc4b8644f8ea82d3b35bb7ef8ee82e6630d76d0197c39baf9"},
+    {file = "virtualenv-20.29.0.tar.gz", hash = "sha256:6345e1ff19d4b1296954cee076baaf58ff2a12a84a338c62b02eda39f20aa982"},
 ]
 
 [package.dependencies]
 distlib = ">=0.3.7,<1"
-filelock = {version = ">=3.20.1,<4", markers = "python_version >= \"3.10\""}
+filelock = ">=3.12.2,<4"
 platformdirs = ">=3.9.1,<5"
-typing-extensions = {version = ">=4.13.2", markers = "python_version < \"3.11\""}
 
 [package.extras]
 docs = ["furo (>=2023.7.26)", "proselint (>=0.13)", "sphinx (>=7.1.2,!=7.3)", "sphinx-argparse (>=0.4)", "sphinxcontrib-towncrier (>=0.2.1a0)", "towncrier (>=23.6)"]
-test = ["covdefaults (>=2.3)", "coverage (>=7.2.7)", "coverage-enable-subprocess (>=1)", "flaky (>=3.7)", "packaging (>=23.1)", "pytest (>=7.4)", "pytest-env (>=0.8.2)", "pytest-freezer (>=0.4.8) ; platform_python_implementation == \"PyPy\" or platform_python_implementation == \"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\""]
+test = ["covdefaults (>=2.3)", "coverage (>=7.2.7)", "coverage-enable-subprocess (>=1)", "flaky (>=3.7)", "packaging (>=23.1)", "pytest (>=7.4)", "pytest-env (>=0.8.2)", "pytest-freezer (>=0.4.8)", "pytest-mock (>=3.11.1)", "pytest-randomly (>=3.12)", "pytest-timeout (>=2.1)", "setuptools (>=68)", "time-machine (>=2.10)"]
 
 [[package]]
 name = "virtualenv-pyenv"

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "vban-cmd"
-version = "2.10.3"
+version = "2.9.7"
 description = "Python interface for the VBAN RT Packet Service (Sendtext)"
 authors = [{ name = "Onyx and Iris", email = "code@onyxandiris.online" }]
 license = { text = "MIT" }

vban_cmd/error.py

@@ -1,18 +1,6 @@
-from .packet.enums import ServiceTypes, SubProtocols
-
-
 class VBANCMDError(Exception):
     """Base VBANCMD Exception class."""
 
 
 class VBANCMDConnectionError(VBANCMDError):
     """Exception raised when connection/timeout errors occur"""
-
-
-class VBANCMDPacketError(VBANCMDError):
-    """Exception raised when packet parsing errors occur"""
-
-    def __init__(self, message: str, protocol: SubProtocols, type_: ServiceTypes):
-        super().__init__(message)
-        self.protocol = protocol
-        self.type = type_

vban_cmd/factory.py

@@ -1,3 +1,4 @@
+import abc
 import logging
 from enum import IntEnum
 from functools import cached_property
@@ -88,7 +89,7 @@ class FactoryBase(VbanCmd):
             'streamname': 'Command1',
             'bps': 256000,
             'channel': 0,
-            'script_ratelimit': None,  # if None or 0, no rate limit applied to script commands
+            'script_ratelimit': 0.05,  # 20 commands per second, to avoid overloading Voicemeeter
             'timeout': 5,  # timeout on socket operations, in seconds
             'disable_rt_listeners': False,
             'sync': False,
@@ -121,6 +122,11 @@ class FactoryBase(VbanCmd):
             + f"({self.kind}, ip='{self.ip}', port={self.port}, streamname='{self.streamname}')"
         )
 
+    @property
+    @abc.abstractmethod
+    def steps(self):
+        pass
+
     @cached_property
     def configs(self):
         self._configs = configs(self.kind.name)

vban_cmd/iremote.py

@@ -48,18 +48,26 @@ class IRemote(abc.ABC):
     def apply(self, data):
         """Sets all parameters of a dict for the channel."""
 
+        script = ''
+
         def fget(attr, val):
             if attr == 'mode':
-                return (getattr(self, attr), val, 1)
-            return (self, attr, val)
+                return (f'mode.{val}', 1)
+            elif attr == 'knob':
+                return ('', val)
+            return (attr, val)
 
         for attr, val in data.items():
             if not isinstance(val, dict):
                 if attr in dir(self):  # avoid calling getattr (with hasattr)
-                    target, attr, val = fget(attr, val)
-                    setattr(target, attr, val)
-                else:
-                    self.logger.error(f'invalid attribute {attr} for {self}')
+                    attr, val = fget(attr, val)
+                    if isinstance(val, bool):
+                        val = 1 if val else 0
+
+                    self._remote.cache[self._cmd(attr)] = val
+                    script += f'{self._cmd(attr)}={val};'
             else:
                 target = getattr(self, attr)
                 target.apply(val)
+
+        self._remote.sendtext(script)

vban_cmd/packet/headers.py

@@ -1,8 +1,6 @@
-import struct
 from dataclasses import dataclass
 
 from vban_cmd.enums import NBS
-from vban_cmd.error import VBANCMDPacketError
 from vban_cmd.kinds import KindMapClass
 
 from .enums import ServiceTypes, StreamTypes, SubProtocols
@@ -11,15 +9,6 @@ PINGPONG_PACKET_SIZE = 704  # Size of the PING/PONG header + payload in bytes
 MAX_PACKET_SIZE = 1436
 HEADER_SIZE = 4 + 1 + 1 + 1 + 1 + 16
 
-STREAMNAME_MAX_LENGTH = 16
-# fmt: off
-BPS_OPTS = [
-    0, 110, 150, 300, 600, 1200, 2400, 4800, 9600, 14400, 19200, 31250,
-    38400, 57600, 115200, 128000, 230400, 250000, 256000, 460800, 921600,
-    1000000, 1500000, 2000000, 3000000,
-]
-# fmt: on
-
 
 @dataclass
 class VbanPingHeader:
@@ -38,25 +27,22 @@ class VbanPingHeader:
 
     @property
     def streamname(self) -> bytes:
-        return self.name.encode('ascii')[:STREAMNAME_MAX_LENGTH].ljust(
-            STREAMNAME_MAX_LENGTH, b'\x00'
-        )
+        return self.name.encode('ascii')[:16].ljust(16, b'\x00')
 
     @classmethod
     def to_bytes(cls, framecounter: int = 0) -> bytes:
         """Creates the PING header bytes only."""
         header = cls(framecounter=framecounter)
 
-        return struct.pack(
-            '<4s4B16sI',
-            header.vban,
-            header.format_sr,
-            header.format_nbs,
-            header.format_nbc,
-            header.format_bit,
-            header.streamname,
-            header.framecounter,
-        )
+        data = bytearray()
+        data.extend(header.vban)
+        data.extend(header.format_sr.to_bytes(1, 'little'))
+        data.extend(header.format_nbs.to_bytes(1, 'little'))
+        data.extend(header.format_nbc.to_bytes(1, 'little'))
+        data.extend(header.format_bit.to_bytes(1, 'little'))
+        data.extend(header.streamname)
+        data.extend(header.framecounter.to_bytes(4, 'little'))
+        return bytes(data)
 
 
 @dataclass
@@ -76,9 +62,7 @@ class VbanPongHeader:
 
     @property
     def streamname(self) -> bytes:
-        return self.name.encode('ascii')[:STREAMNAME_MAX_LENGTH].ljust(
-            STREAMNAME_MAX_LENGTH, b'\x00'
-        )
+        return self.name.encode('ascii')[:16].ljust(16, b'\x00')
 
     @classmethod
     def from_bytes(cls, data: bytes):
@@ -88,11 +72,7 @@ class VbanPongHeader:
         # PONG responses use the same service type as PING (0x00)
         # and are identified by having payload data
         if parsed['format_nbc'] != ServiceTypes.PONG.value:
-            raise VBANCMDPacketError(
-                f'Not a PONG response packet: {parsed["format_nbc"]:02x}',
-                protocol=SubProtocols(parsed['format_sr'] & SubProtocols.MASK.value),
-                type_=ServiceTypes(parsed['format_nbc']),
-            )
+            raise ValueError(f'Not a PONG response packet: {parsed["format_nbc"]:02x}')
 
         return cls(**parsed)
 
@@ -151,7 +131,7 @@ class VbanRTPacket:
 class VbanRTSubscribeHeader:
     """Represents the header of an RT subscription packet"""
 
-    _nbs: NBS = NBS.zero
+    nbs: NBS = NBS.zero
     name: str = 'Register-RTP'
     timeout: int = 15
 
@@ -160,41 +140,38 @@ class VbanRTSubscribeHeader:
         return b'VBAN'
 
     @property
-    def sr(self) -> int:
-        return SubProtocols.SERVICE.value
+    def format_sr(self) -> bytes:
+        return SubProtocols.SERVICE.value.to_bytes(1, 'little')
 
     @property
-    def nbs(self) -> int:
-        return self._nbs.value & 0xFF
+    def format_nbs(self) -> bytes:
+        return (self.nbs.value & 0xFF).to_bytes(1, 'little')
 
     @property
-    def nbc(self) -> int:
-        return ServiceTypes.RTPACKETREGISTER.value
+    def format_nbc(self) -> bytes:
+        return ServiceTypes.RTPACKETREGISTER.value.to_bytes(1, 'little')
 
     @property
-    def bit(self) -> int:
-        return self.timeout & 0xFF
+    def format_bit(self) -> bytes:
+        return (self.timeout & 0xFF).to_bytes(1, 'little')
 
     @property
     def streamname(self) -> bytes:
-        return self.name.encode()[:STREAMNAME_MAX_LENGTH].ljust(
-            STREAMNAME_MAX_LENGTH, b'\x00'
-        )
+        return self.name.encode('ascii') + bytes(16 - len(self.name))
 
     @classmethod
     def to_bytes(cls, nbs: NBS, framecounter: int) -> bytes:
-        header = cls(_nbs=nbs)
+        header = cls(nbs=nbs)
 
-        return struct.pack(
-            '<4s4B16sI',
-            header.vban,
-            header.sr,
-            header.nbs,
-            header.nbc,
-            header.bit,
-            header.streamname,
-            framecounter,
-        )
+        data = bytearray()
+        data.extend(header.vban)
+        data.extend(header.format_sr)
+        data.extend(header.format_nbs)
+        data.extend(header.format_nbc)
+        data.extend(header.format_bit)
+        data.extend(header.streamname)
+        data.extend(framecounter.to_bytes(4, 'little'))
+        return bytes(data)
 
 
 @dataclass
@@ -202,64 +179,58 @@ class VbanRTRequestHeader:
     """Represents the header of an RT request packet"""
 
     name: str
-    bps: int
+    bps_index: int
     channel: int
     framecounter: int = 0
 
-    def __post_init__(self):
-        if self.bps not in BPS_OPTS:
-            raise ValueError(
-                f'Invalid bps value: {self.bps}. Must be one of {BPS_OPTS}'
-            )
-        self.bps_index = BPS_OPTS.index(self.bps)
-
     @property
     def vban(self) -> bytes:
         return b'VBAN'
 
     @property
-    def sr(self) -> int:
-        return self.bps_index | SubProtocols.TEXT.value
+    def sr(self) -> bytes:
+        return (self.bps_index | SubProtocols.TEXT.value).to_bytes(1, 'little')
 
     @property
-    def nbs(self) -> int:
-        return 0
+    def nbs(self) -> bytes:
+        return (0).to_bytes(1, 'little')
 
     @property
-    def nbc(self) -> int:
-        return self.channel
+    def nbc(self) -> bytes:
+        return (self.channel).to_bytes(1, 'little')
 
     @property
-    def bit(self) -> int:
-        return StreamTypes.UTF8.value
+    def bit(self) -> bytes:
+        return (StreamTypes.UTF8.value).to_bytes(1, 'little')
 
     @property
     def streamname(self) -> bytes:
-        return self.name.encode()[:STREAMNAME_MAX_LENGTH].ljust(
-            STREAMNAME_MAX_LENGTH, b'\x00'
-        )
+        return self.name.encode()[:16].ljust(16, b'\x00')
 
     @classmethod
-    def to_bytes(cls, name: str, bps: int, channel: int, framecounter: int) -> bytes:
-        header = cls(name=name, bps=bps, channel=channel, framecounter=framecounter)
-
-        return struct.pack(
-            '<4s4B16sI',
-            header.vban,
-            header.sr,
-            header.nbs,
-            header.nbc,
-            header.bit,
-            header.streamname,
-            header.framecounter,
+    def to_bytes(
+        cls, name: str, bps_index: int, channel: int, framecounter: int
+    ) -> bytes:
+        header = cls(
+            name=name, bps_index=bps_index, channel=channel, framecounter=framecounter
         )
 
+        data = bytearray()
+        data.extend(header.vban)
+        data.extend(header.sr)
+        data.extend(header.nbs)
+        data.extend(header.nbc)
+        data.extend(header.bit)
+        data.extend(header.streamname)
+        data.extend(header.framecounter.to_bytes(4, 'little'))
+        return bytes(data)
+
     @classmethod
     def encode_with_payload(
-        cls, name: str, bps: int, channel: int, framecounter: int, payload: str
+        cls, name: str, bps_index: int, channel: int, framecounter: int, payload: str
     ) -> bytes:
         """Creates the complete packet with header and payload."""
-        return cls.to_bytes(name, bps, channel, framecounter) + payload.encode()
+        return cls.to_bytes(name, bps_index, channel, framecounter) + payload.encode()
 
 
 def _parse_vban_service_header(data: bytes) -> dict:
@@ -278,10 +249,7 @@ def _parse_vban_service_header(data: bytes) -> dict:
     # Verify this is a service protocol packet
     protocol = format_sr & SubProtocols.MASK.value
     if protocol != SubProtocols.SERVICE.value:
-        raise VBANCMDPacketError(
-            f'Invalid protocol in service header: {protocol:02x}',
-            protocol=SubProtocols(protocol),
-        )
+        raise ValueError(f'Not a service protocol packet: {protocol:02x}')
 
     # Extract stream name and frame counter
     name = data[8:24].rstrip(b'\x00').decode('utf-8', errors='ignore')
@@ -314,9 +282,7 @@ class VbanRTResponseHeader:
 
     @property
     def streamname(self) -> bytes:
-        return self.name.encode()[:STREAMNAME_MAX_LENGTH].ljust(
-            STREAMNAME_MAX_LENGTH, b'\x00'
-        )
+        return self.name.encode('ascii') + bytes(16 - len(self.name))
 
     @classmethod
     def from_bytes(cls, data: bytes):
@@ -325,10 +291,8 @@ class VbanRTResponseHeader:
 
         # Validate this is an RTPacket response
         if parsed['format_nbc'] != ServiceTypes.RTPACKET.value:
-            raise VBANCMDPacketError(
-                f'Not an RTPacket response packet: {parsed["format_nbc"]:02x}',
-                protocol=SubProtocols(parsed['format_sr'] & SubProtocols.MASK.value),
-                type_=ServiceTypes(parsed['format_nbc']),
+            raise ValueError(
+                f'Not an RTPacket response packet: {parsed["format_nbc"]:02x}'
             )
 
         return cls(**parsed)
@@ -351,29 +315,16 @@ class VbanMatrixResponseHeader:
 
     @property
     def streamname(self) -> bytes:
-        return self.name.encode()[:STREAMNAME_MAX_LENGTH].ljust(
-            STREAMNAME_MAX_LENGTH, b'\x00'
-        )
+        return self.name.encode('ascii')[:16].ljust(16, b'\x00')
 
     @classmethod
     def from_bytes(cls, data: bytes):
         """Parse a matrix response packet from bytes."""
         parsed = _parse_vban_service_header(data)
 
-        # Validate this is a service reply packet (dual encoding scheme)
+        # Validate this is a service reply packet
         if parsed['format_nbs'] != ServiceTypes.FNCT_REPLY.value:
-            raise VBANCMDPacketError(
-                f'Not a service reply packet: {parsed["format_nbs"]:02x}',
-                protocol=SubProtocols(parsed['format_sr'] & SubProtocols.MASK.value),
-                type_=ServiceTypes(parsed['format_nbs']),
-            )
-
-        if parsed['format_nbc'] != ServiceTypes.REQUESTREPLY.value:
-            raise VBANCMDPacketError(
-                f'Not a request reply packet: {parsed["format_nbc"]:02x}',
-                protocol=SubProtocols(parsed['format_sr'] & SubProtocols.MASK.value),
-                type_=ServiceTypes(parsed['format_nbc']),
-            )
+            raise ValueError(f'Not a service reply packet: {parsed["format_nbs"]:02x}')
 
         return cls(**parsed)
 

vban_cmd/packet/nbs0.py

@@ -1,6 +1,4 @@
-import struct
 from dataclasses import dataclass
-from functools import cached_property
 from typing import NamedTuple
 
 from vban_cmd.enums import NBS
@@ -23,13 +21,6 @@ class ChannelState:
         # Convert 4-byte state to integer once for efficient lookups
         self._state = int.from_bytes(state_bytes, 'little')
 
-    @classmethod
-    def from_int(cls, state_int: int):
-        """Create ChannelState directly from integer for efficiency"""
-        instance = cls.__new__(cls)
-        instance._state = state_int
-        return instance
-
     def get_mode(self, mode_value: int) -> bool:
         """Get boolean state for a specific mode"""
         return (self._state & mode_value) != 0
@@ -156,17 +147,32 @@ class VbanRTPacketNBS0(VbanRTPacket):
 
     def pdirty(self, other) -> bool:
         """True iff any defined parameter has changed"""
+
+        self_gains = (
+            self._stripGaindB100Layer1
+            + self._stripGaindB100Layer2
+            + self._stripGaindB100Layer3
+            + self._stripGaindB100Layer4
+            + self._stripGaindB100Layer5
+            + self._stripGaindB100Layer6
+            + self._stripGaindB100Layer7
+            + self._stripGaindB100Layer8
+        )
+        other_gains = (
+            other._stripGaindB100Layer1
+            + other._stripGaindB100Layer2
+            + other._stripGaindB100Layer3
+            + other._stripGaindB100Layer4
+            + other._stripGaindB100Layer5
+            + other._stripGaindB100Layer6
+            + other._stripGaindB100Layer7
+            + other._stripGaindB100Layer8
+        )
+
         return (
             self._stripState != other._stripState
             or self._busState != other._busState
-            or self._stripGaindB100Layer1 != other._stripGaindB100Layer1
-            or self._stripGaindB100Layer2 != other._stripGaindB100Layer2
-            or self._stripGaindB100Layer3 != other._stripGaindB100Layer3
-            or self._stripGaindB100Layer4 != other._stripGaindB100Layer4
-            or self._stripGaindB100Layer5 != other._stripGaindB100Layer5
-            or self._stripGaindB100Layer6 != other._stripGaindB100Layer6
-            or self._stripGaindB100Layer7 != other._stripGaindB100Layer7
-            or self._stripGaindB100Layer8 != other._stripGaindB100Layer8
+            or self_gains != other_gains
             or self._busGaindB100 != other._busGaindB100
             or self._stripLabelUTF8c60 != other._stripLabelUTF8c60
             or self._busLabelUTF8c60 != other._busLabelUTF8c60
@@ -180,54 +186,77 @@ class VbanRTPacketNBS0(VbanRTPacket):
         )
         return any(self._strip_comp) or any(self._bus_comp)
 
-    @cached_property
+    @property
     def strip_levels(self) -> tuple[float, ...]:
         """Returns strip levels in dB"""
-        strip_raw = struct.unpack('<34h', self._inputLeveldB100)
-        return tuple(round(val * 0.01, 1) for val in strip_raw)[
-            : self._kind.num_strip_levels
-        ]
+        return tuple(
+            round(
+                int.from_bytes(self._inputLeveldB100[i : i + 2], 'little', signed=True)
+                * 0.01,
+                1,
+            )
+            for i in range(0, len(self._inputLeveldB100), 2)
+        )[: self._kind.num_strip_levels]
 
-    @cached_property
+    @property
     def bus_levels(self) -> tuple[float, ...]:
         """Returns bus levels in dB"""
-        bus_raw = struct.unpack('<64h', self._outputLeveldB100)
-        return tuple(round(val * 0.01, 1) for val in bus_raw)[
-            : self._kind.num_bus_levels
-        ]
+        return tuple(
+            round(
+                int.from_bytes(self._outputLeveldB100[i : i + 2], 'little', signed=True)
+                * 0.01,
+                1,
+            )
+            for i in range(0, len(self._outputLeveldB100), 2)
+        )[: self._kind.num_bus_levels]
 
     @property
     def levels(self) -> Levels:
         """Returns strip and bus levels as a namedtuple"""
         return Levels(strip=self.strip_levels, bus=self.bus_levels)
 
-    @cached_property
+    @property
     def states(self) -> States:
         """returns States object with processed strip and bus channel states"""
-        strip_states = struct.unpack('<8I', self._stripState)
-        bus_states = struct.unpack('<8I', self._busState)
         return States(
-            strip=tuple(ChannelState.from_int(state) for state in strip_states),
-            bus=tuple(ChannelState.from_int(state) for state in bus_states),
+            strip=tuple(
+                ChannelState(self._stripState[i : i + 4]) for i in range(0, 32, 4)
+            ),
+            bus=tuple(ChannelState(self._busState[i : i + 4]) for i in range(0, 32, 4)),
         )
 
-    @cached_property
+    @property
     def gainlayers(self) -> tuple:
         """returns tuple of all strip gain layers as tuples"""
-        layer_data = []
-        for layer in range(1, 9):
-            layer_bytes = getattr(self, f'_stripGaindB100Layer{layer}')
-            layer_raw = struct.unpack('<8h', layer_bytes)
-            layer_data.append(tuple(round(val * 0.01, 2) for val in layer_raw))
-        return tuple(layer_data)
+        return tuple(
+            tuple(
+                round(
+                    int.from_bytes(
+                        getattr(self, f'_stripGaindB100Layer{layer}')[i : i + 2],
+                        'little',
+                        signed=True,
+                    )
+                    * 0.01,
+                    2,
+                )
+                for i in range(0, 16, 2)
+            )
+            for layer in range(1, 9)
+        )
 
-    @cached_property
+    @property
     def busgain(self) -> tuple:
         """returns tuple of bus gains"""
-        bus_gain_raw = struct.unpack('<8h', self._busGaindB100)
-        return tuple(round(val * 0.01, 2) for val in bus_gain_raw)
+        return tuple(
+            round(
+                int.from_bytes(self._busGaindB100[i : i + 2], 'little', signed=True)
+                * 0.01,
+                2,
+            )
+            for i in range(0, 16, 2)
+        )
 
-    @cached_property
+    @property
     def labels(self) -> Labels:
         """returns Labels namedtuple of strip and bus labels"""
 

vban_cmd/packet/nbs1.py

@@ -1,6 +1,5 @@
 import struct
 from dataclasses import dataclass
-from functools import cached_property
 from typing import NamedTuple
 
 from vban_cmd.enums import NBS
@@ -194,15 +193,11 @@ class VbanVMParamStrip:
             _Pitch_formant_high=data[172:174],
         )
 
-    @cached_property
+    @property
     def mode(self) -> int:
         return int.from_bytes(self._mode, 'little')
 
-    @cached_property
-    def karaoke(self) -> int:
-        return int.from_bytes(self._nKaraoke, 'little')
-
-    @cached_property
+    @property
     def audibility(self) -> Audibility:
         return Audibility(
             round(int.from_bytes(self._audibility, 'little', signed=True) * 0.01, 2),
@@ -211,7 +206,7 @@ class VbanVMParamStrip:
             round(int.from_bytes(self._audibility_d, 'little', signed=True) * 0.01, 2),
         )
 
-    @cached_property
+    @property
     def positions(self) -> Positions:
         return Positions(
             round(int.from_bytes(self._pos3D_x, 'little', signed=True) * 0.01, 2),
@@ -222,7 +217,7 @@ class VbanVMParamStrip:
             round(int.from_bytes(self._posMod_y, 'little', signed=True) * 0.01, 2),
         )
 
-    @cached_property
+    @property
     def eqgains(self) -> EqGains:
         return EqGains(
             *[
@@ -235,7 +230,7 @@ class VbanVMParamStrip:
             ]
         )
 
-    @cached_property
+    @property
     def parametric_eq(self) -> tuple[ParametricEQSettings, ...]:
         return tuple(
             ParametricEQSettings(
@@ -248,7 +243,7 @@ class VbanVMParamStrip:
             for i in range(6)
         )
 
-    @cached_property
+    @property
     def sends(self) -> Sends:
         return Sends(
             round(int.from_bytes(self._send_reverb, 'little', signed=True) * 0.01, 2),
@@ -257,7 +252,11 @@ class VbanVMParamStrip:
             round(int.from_bytes(self._send_fx2, 'little', signed=True) * 0.01, 2),
         )
 
-    @cached_property
+    @property
+    def karaoke(self) -> int:
+        return int.from_bytes(self._nKaraoke, 'little')
+
+    @property
     def compressor(self) -> CompressorSettings:
         return CompressorSettings(
             gain_in=round(
@@ -277,7 +276,7 @@ class VbanVMParamStrip:
             ),
         )
 
-    @cached_property
+    @property
     def gate(self) -> GateSettings:
         return GateSettings(
             threshold_in=round(
@@ -296,7 +295,7 @@ class VbanVMParamStrip:
             release_ms=round(int.from_bytes(self._GATE_release_ms, 'little') * 0.1, 2),
         )
 
-    @cached_property
+    @property
     def denoiser(self) -> DenoiserSettings:
         return DenoiserSettings(
             threshold=round(
@@ -304,7 +303,7 @@ class VbanVMParamStrip:
             )
         )
 
-    @cached_property
+    @property
     def pitch(self) -> PitchSettings:
         return PitchSettings(
             enabled=bool(int.from_bytes(self._PitchEnabled, 'little')),

vban_cmd/packet/ping0.py

@@ -1,4 +1,3 @@
-import struct
 from dataclasses import dataclass
 from enum import Enum
 
@@ -66,31 +65,30 @@ class VbanPing0Payload:
         """Convert payload to bytes"""
         payload = cls()
 
-        return struct.pack(
-            '<7I4s8s8s8s8s64s32s2H64s64s64s64s128s128s',
-            payload.bit_type,
-            payload.bit_feature,
-            payload.bit_feature_ex,
-            payload.preferred_rate,
-            payload.min_rate,
-            payload.max_rate,
-            payload.color_rgb,
-            payload.version,
-            payload.gps_position,
-            payload.user_position,
-            payload.lang_code,
-            payload.reserved,
-            payload.reserved_ex,
-            payload.distant_ip,
-            payload.distant_port,
-            payload.distant_reserved,
-            payload.device_name,
-            payload.manufacturer_name,
-            payload.application_name,
-            payload.host_name,
-            payload.user_name,
-            payload.user_comment,
-        )
+        data = bytearray()
+        data.extend(payload.bit_type.to_bytes(4, 'little'))
+        data.extend(payload.bit_feature.to_bytes(4, 'little'))
+        data.extend(payload.bit_feature_ex.to_bytes(4, 'little'))
+        data.extend(payload.preferred_rate.to_bytes(4, 'little'))
+        data.extend(payload.min_rate.to_bytes(4, 'little'))
+        data.extend(payload.max_rate.to_bytes(4, 'little'))
+        data.extend(payload.color_rgb.to_bytes(4, 'little'))
+        data.extend(payload.version)
+        data.extend(payload.gps_position)
+        data.extend(payload.user_position)
+        data.extend(payload.lang_code)
+        data.extend(payload.reserved)
+        data.extend(payload.reserved_ex)
+        data.extend(payload.distant_ip)
+        data.extend(payload.distant_port.to_bytes(2, 'little'))
+        data.extend(payload.distant_reserved.to_bytes(2, 'little'))
+        data.extend(payload.device_name)
+        data.extend(payload.manufacturer_name)
+        data.extend(payload.application_name)
+        data.extend(payload.host_name)
+        data.extend(payload.user_name)
+        data.extend(payload.user_comment)
+        return bytes(data)
 
     @classmethod
     def create_packet(cls, framecounter: int) -> bytes:

vban_cmd/util.py

@@ -5,12 +5,12 @@ from typing import Iterator
 from .error import VBANCMDConnectionError
 
 
-def script_ratelimit(func):
-    """script_ratelimit decorator for {VbanCmd}.sendtext, to prevent flooding the network with script requests."""
+def ratelimit(func):
+    """ratelimit decorator for {VbanCmd}.sendtext, to prevent flooding the network with script requests."""
 
     def wrapper(*args, **kwargs):
         self, *rem = args
-        if self.script_ratelimit:
+        if self.script_ratelimit > 0:
             now = time.time()
             elapsed = now - self._last_script_request_time
             if elapsed < self.script_ratelimit:
@@ -124,11 +124,16 @@ def comp(t0: tuple, t1: tuple) -> Iterator[bool]:
     """
     Generator function, accepts two tuples of dB values.
 
-    Returns True when levels are equal (no change), False when different.
+    Evaluates equality of each member in both tuples.
+    Only ignores changes when levels are very quiet (below -72 dB).
     """
 
     for a, b in zip(t0, t1):
-        yield a == b
+        # If both values are very quiet (below -72dB), ignore small changes
+        if a <= -72.0 and b <= -72.0:
+            yield a == b  # Both quiet, check if they're equal
+        else:
+            yield a != b  # At least one has significant level, detect changes
 
 
 def deep_merge(dict1, dict2):

vban_cmd/vbancmd.py

@@ -17,7 +17,7 @@ from .packet.headers import (
 )
 from .packet.ping0 import VbanPing0Payload, VbanServerType
 from .subject import Subject
-from .util import bump_framecounter, deep_merge, pong_timeout, script_ratelimit
+from .util import bump_framecounter, deep_merge, pong_timeout, ratelimit
 from .worker import Producer, Subscriber, Updater
 
 logger = logging.getLogger(__name__)
@@ -27,6 +27,13 @@ class VbanCmd(abc.ABC):
     """Abstract Base Class for Voicemeeter VBAN Command Interfaces"""
 
     DELAY = 0.001
+    # fmt: off
+    BPS_OPTS = [
+        0, 110, 150, 300, 600, 1200, 2400, 4800, 9600, 14400, 19200, 31250,
+        38400, 57600, 115200, 128000, 230400, 250000, 256000, 460800, 921600,
+        1000000, 1500000, 2000000, 3000000,
+    ]
+    # fmt: on
 
     def __init__(self, **kwargs):
         self.logger = logger.getChild(self.__class__.__name__)
@@ -36,13 +43,6 @@ class VbanCmd(abc.ABC):
         for attr, val in kwargs.items():
             setattr(self, attr, val)
 
-        try:
-            self._host_ip = socket.gethostbyname(self.host)
-        except socket.gaierror as e:
-            raise VBANCMDConnectionError(
-                f'Unable to resolve hostname {self.host}'
-            ) from e
-
         self._framecounter = 0
         self._framecounter_lock = threading.Lock()
         self.sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
@@ -56,10 +56,9 @@ class VbanCmd(abc.ABC):
         self.producer = None
         self._last_script_request_time = 0
 
-    @property
     @abc.abstractmethod
-    def steps(self):
-        """Steps required to build the interface for this Voicemeeter kind"""
+    def __str__(self):
+        """Ensure subclasses override str magic method"""
 
     def _conn_from_toml(self) -> dict:
         try:
@@ -144,10 +143,14 @@ class VbanCmd(abc.ABC):
         try:
             self.sock.sendto(
                 VbanPing0Payload.create_packet(self._get_next_framecounter()),
-                (self._host_ip, self.port),
+                (socket.gethostbyname(self.host), self.port),
             )
             self.logger.debug(f'PING sent to {self.host}:{self.port}')
 
+        except socket.gaierror as e:
+            raise VBANCMDConnectionError(
+                f'Unable to resolve hostname {self.host}'
+            ) from e
         except Exception as e:
             raise VBANCMDConnectionError(f'PING failed: {e}') from e
 
@@ -200,12 +203,12 @@ class VbanCmd(abc.ABC):
         self.sock.sendto(
             VbanRTRequestHeader.encode_with_payload(
                 name=self.streamname,
-                bps=self.bps,
+                bps_index=self.BPS_OPTS.index(self.bps),
                 channel=self.channel,
                 framecounter=self._get_next_framecounter(),
                 payload=payload,
             ),
-            (self._host_ip, self.port),
+            (socket.gethostbyname(self.host), self.port),
         )
 
     def _set_rt(self, cmd: str, val: Union[str, float]):
@@ -213,7 +216,7 @@ class VbanCmd(abc.ABC):
         self._send_request(f'{cmd}={val};')
         self.cache[cmd] = val
 
-    @script_ratelimit
+    @ratelimit
     def sendtext(self, script) -> str | None:
         """Sends a multiple parameter string over a network."""
         self._send_request(script)

vban_cmd/worker.py

@@ -3,8 +3,7 @@ import threading
 import time
 
 from .enums import NBS
-from .error import VBANCMDConnectionError, VBANCMDPacketError
-from .packet.enums import SubProtocols
+from .error import VBANCMDConnectionError
 from .packet.headers import (
     HEADER_SIZE,
     VbanRTPacket,
@@ -33,7 +32,7 @@ class Subscriber(threading.Thread):
                     nbs, self._remote._get_next_framecounter()
                 )
                 self._remote.sock.sendto(
-                    sub_packet, (self._remote._host_ip, self._remote.port)
+                    sub_packet, (self._remote.host, self._remote.port)
                 )
 
             self.wait_until_stopped(10)
@@ -82,12 +81,7 @@ class Producer(threading.Thread):
 
             try:
                 header = VbanRTResponseHeader.from_bytes(data[:HEADER_SIZE])
-            except VBANCMDPacketError as e:
-                match e.protocol:
-                    case SubProtocols.SERVICE:
-                        # Silently ignore periodic SERVICE packets unrelated to vban-cmd
-                        pass
-                    case _:
+            except ValueError as e:
                 self.logger.debug(f'Error parsing response packet: {e}')
                 continue