onyx_online/voicemeeter-api-python
1
0
Fork 0
mirror of https://github.com/onyx-and-iris/voicemeeter-api-python.git synced 2025-01-18 00:50:48 +00:00
Code Issues Packages Projects Releases Wiki Activity

re-run through ruff formatter

Browse Source
This commit is contained in:
Onyx and Iris 2025-01-15 12:40:31 +00:00
parent 7b725a51e3
commit da1d5132a8
28 changed files with 608 additions and 609 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

51
README.md
View File

@ -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 4 eq has been set to {self.vm.bus[4].eq.on}",
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}',
)
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},
"bus-2": {"mute": True, "eq": {"on": True}},
"button-0": {"state": True},
"vban-in-0": {"on": True},
"vban-out-1": {"name": "streamname"},
'strip-2': {'A1': True, 'B1': True, 'gain': -6.0},
'bus-2': {'mute': True, 'eq': {'on': True}},
'button-0': {'state': True},
'vban-in-0': {'on': True},
'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].appgain("Spotify", 0.5)
vm.strip[5].appmute('Spotify', True)
vm.strip[5].appgain('Spotify', 0.5)
```
#### Strip.Comp
@ -366,7 +365,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.
@ -425,7 +424,7 @@ vm.recorder.B2 = False
vm.recorder.load(r'C:\music\mytune.mp3')
# set the goto time to 1m 30s
vm.recorder.goto("00:01:30")
vm.recorder.goto('00:01:30')
```
#### Recorder.Mode
@ -679,11 +678,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},
"bus-2": {"mute": True, "eq": {"on": True}},
"button-0": {"state": True},
"vban-in-0": {"on": True},
"vban-out-1": {"name": "streamname"},
'strip-2': {'A1': True, 'B1': True, 'gain': -6.0},
'bus-2': {'mute': True, 'eq': {'on': True}},
'button-0': {'state': True},
'vban-in-0': {'on': True},
'vban-out-1': {'name': 'streamname'},
}
)
```
@ -691,8 +690,8 @@ vm.apply(
Or for each class you may do:
```python
vm.strip[0].apply({"mute": True, "gain": 3.2, "A1": True})
vm.vban.outstream[0].apply({"on": True, "name": "streamname", "bit": 24})
vm.strip[0].apply({'mute': True, 'gain': 3.2, 'A1': True})
vm.vban.outstream[0].apply({'on': True, 'name': 'streamname', 'bit': 24})
```
## Config Files
@ -793,7 +792,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())
@ -863,7 +862,7 @@ import voicemeeterlib
logging.basicConfig(level=logging.DEBUG)
with voicemeeterlib.api("banana") as vm:
with voicemeeterlib.api('banana') as vm:
...
```

24
__main__.py
View File

@ -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 4 eq has been set to {self.vm.bus[4].eq.on}",
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}',
)
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},
"bus-2": {"mute": True, "eq": {"on": True}},
"button-0": {"state": True},
"vban-in-0": {"on": True},
"vban-out-1": {"name": "streamname"},
'strip-2': {'A1': True, 'B1': True, 'gain': -6.0},
'bus-2': {'mute': True, 'eq': {'on': True}},
'button-0': {'state': True},
'vban-in-0': {'on': True},
'vban-out-1': {'name': 'streamname'},
}
)
if __name__ == "__main__":
if __name__ == '__main__':
main()

36
examples/dsl/__main__.py
View File

@ -21,14 +21,14 @@ logging.basicConfig(level=logging.DEBUG)
logger = logging.getLogger(__name__)
argparser = argparse.ArgumentParser(description="creates a basic dsl")
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",
'ParamKinds',
'bool float string',
)
@ -51,12 +51,12 @@ class BoolStrategy(Strategy):
"""Convert a string representation of truth to it's numeric form."""
val = val.lower()
if val in ("y", "yes", "t", "true", "on", "1"):
if val in ('y', 'yes', 't', 'true', 'on', '1'):
return 1
elif val in ("n", "no", "f", "false", "off", "0"):
elif val in ('n', 'no', 'f', 'false', 'off', '0'):
return 0
else:
raise ValueError("invalid truth value %r" % (val,))
raise ValueError('invalid truth value %r' % (val,))
class FloatStrategy(Strategy):
@ -66,7 +66,7 @@ class FloatStrategy(Strategy):
class StringStrategy(Strategy):
def run(self):
setattr(self.target, self.param, " ".join(self.val))
setattr(self.target, self.param, ' '.join(self.val))
class Context:
@ -86,16 +86,16 @@ class Context:
class Parser:
IS_STRING = ("label",)
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 = 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
@ -110,7 +110,7 @@ class Parser:
res = list()
for cmd in cmds:
self.logger.debug(f"running command: {cmd}")
self.logger.debug(f'running command: {cmd}')
match cmd_parsed := self.event.parseString(cmd):
case [[kls, index], [param]]:
target = getattr(self.vm, kls)[int(index)]
@ -125,7 +125,7 @@ class Parser:
context = self._get_context(ParamKinds.bool, target, param, val)
context.run()
except ValueError as e:
self.logger.error(f"{e}... switching to float strategy")
self.logger.error(f'{e}... switching to float strategy')
context.strategy = FloatStrategy(target, param, val)
context.run()
case [
@ -140,12 +140,12 @@ class Parser:
context = self._get_context(ParamKinds.bool, target, param, val)
context.run()
except ValueError as e:
self.logger.error(f"{e}... switching to float strategy")
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}"
f'unable to determine the kind of parameter from {cmd_parsed}'
)
time.sleep(0.05)
return res
@ -166,7 +166,7 @@ class Parser:
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 res := parser.parse((cmd,)):
print(res)
@ -184,7 +184,7 @@ def main():
)
# fmt: on
with voicemeeterlib.api("potato") as vm:
with voicemeeterlib.api('potato') as vm:
parser = Parser(vm)
if args.i:
interactive_mode(parser)
@ -194,5 +194,5 @@ def main():
print(res)
if __name__ == "__main__":
if __name__ == '__main__':
main()

14
examples/events/__main__.py
View File

@ -22,10 +22,10 @@ class App:
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:
@ -34,20 +34,20 @@ class App:
def on_midi(self):
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):
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()

26
examples/gui/__main__.py
View File

@ -13,7 +13,7 @@ class App(tk.Tk):
def __init__(self, vm):
super().__init__()
self.vm = vm
self.title(f"{vm} - version {vm.version}")
self.title(f'{vm} - version {vm.version}')
self.vm.observer.add(self.on_ldirty)
# create widget variables
@ -24,10 +24,10 @@ 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",
foreground="#cd5c5c" if vm.strip[self.INDEX].mute else "#5a5a5a",
'Mute.TButton',
foreground='#cd5c5c' if vm.strip[self.INDEX].mute else '#5a5a5a',
)
# create labelframe and grid it onto the mainframe
@ -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",
style="Mute.TButton",
text='Mute',
style='Mute.TButton',
command=lambda: self.on_button_press(),
)
button.grid(column=0, row=2, columnspan=2, padx=1, pady=2)
@ -83,7 +83,7 @@ class App(tk.Tk):
self.button_var.set(not 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):
@ -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()

10
examples/levels/__main__.py
View File

@ -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.bus[0]}: {vm.bus[0].levels.all}",
f'{vm.strip[5]}: {vm.strip[5].levels.postmute}',
f'{vm.bus[0]}: {vm.bus[0].levels.all}',
]
)
)
@ -24,5 +24,5 @@ def main():
vm.logout()
if __name__ == "__main__":
if __name__ == '__main__':
main()

10
examples/midi/__main__.py
View File

@ -19,7 +19,7 @@ class App:
def get_info(self):
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):
@ -30,7 +30,7 @@ class App:
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
else:
@ -38,14 +38,14 @@ class App:
def main():
KIND_ID = "banana"
KIND_ID = 'banana'
with voicemeeterlib.api(KIND_ID, midi=True) as vm:
App(vm)
while _ := input("Press <Enter> to exit\n"):
while _ := input('Press <Enter> to exit\n'):
pass
if __name__ == "__main__":
if __name__ == '__main__':
main()

2
voicemeeterlib/__init__.py
View File

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

108
voicemeeterlib/bus.py
View File

@ -9,8 +9,8 @@ from .iremote import IRemote
from .meta import bus_mode_prop, device_prop, float_prop
BusModes = IntEnum(
"BusModes",
"normal amix bmix repeat composite tvmix upmix21 upmix41 upmix61 centeronly lfeonly rearonly",
'BusModes',
'normal amix bmix repeat composite tvmix upmix21 upmix41 upmix61 centeronly lfeonly rearonly',
start=0,
)
@ -28,85 +28,85 @@ class Bus(IRemote):
@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:
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 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):
@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 PhysicalBus(Bus):
@ -118,19 +118,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 +142,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",
"ks",
"mme",
"asio",
'wdm',
'ks',
'mme',
'asio',
]
},
},
@ -160,15 +160,15 @@ 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):
@ -182,21 +182,21 @@ class VirtualBus(Bus):
Returns a VirtualBus class.
"""
kls = (cls,)
if kind.name == "basic":
if kind.name == 'basic':
return type(
"VirtualBus",
'VirtualBus',
kls,
{
"device": BusDevice.make(remote, i),
'device': BusDevice.make(remote, i),
},
)
elif kind.name == "potato":
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):
@ -217,7 +217,7 @@ class BusLevel(IRemote):
return round(20 * log(x, 10), 1) if x > 0 else -200.0
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)]
@ -225,7 +225,7 @@ class BusLevel(IRemote):
@property
def identifier(self) -> str:
return f"Bus[{self.index}]"
return f'Bus[{self.index}]'
@property
def all(self) -> tuple:
@ -255,7 +255,7 @@ 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)
@ -276,15 +276,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,
},
)
@ -292,12 +292,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}")
for param in ["reverb", "delay", "fx1", "fx2"]
f'return{param}': float_prop(f'return{param}')
for param in ['reverb', 'delay', 'fx1', 'fx2']
},
},
)
@ -316,12 +316,12 @@ def bus_factory(is_phys_bus, remote, i) -> Union[PhysicalBus, VirtualBus]:
)
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),
"mode": BUSMODEMIXIN_cls(remote, i),
"eq": BusEQ(remote, i),
'levels': BusLevel(remote, i),
'mode': BUSMODEMIXIN_cls(remote, i),
'eq': BusEQ(remote, i),
},
)(remote, i)

10
voicemeeterlib/cbindings.py
View File

@ -16,7 +16,7 @@ class CBindings(metaclass=ABCMeta):
Maps expected ctype argument and res types for each binding.
"""
logger_cbindings = logger.getChild("CBindings")
logger_cbindings = logger.getChild('CBindings')
bind_login = libc.VBVMR_Login
bind_login.restype = LONG
@ -38,17 +38,17 @@ class CBindings(metaclass=ABCMeta):
bind_get_voicemeeter_version.restype = LONG
bind_get_voicemeeter_version.argtypes = [ct.POINTER(LONG)]
if hasattr(libc, "VBVMR_MacroButton_IsDirty"):
if hasattr(libc, 'VBVMR_MacroButton_IsDirty'):
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"):
if hasattr(libc, 'VBVMR_MacroButton_GetStatus'):
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"):
if hasattr(libc, 'VBVMR_MacroButton_SetStatus'):
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]
@ -121,5 +121,5 @@ class CBindings(metaclass=ABCMeta):
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

16
voicemeeterlib/command.py
View File

@ -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')

84
voicemeeterlib/config.py
View File

@ -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"bus-{i}" for i in range(kind.num_bus)],
[f'strip-{i}' for i in range(kind.num_strip)],
[f'bus-{i}' for i in range(kind.num_bus)],
)
def init_config(self, profile=None):
self.virt_strip_params = (
[
"mute = false",
"mono = false",
"solo = false",
"gain = 0.0",
'mute = false',
'mono = false',
'solo = false',
'gain = 0.0',
]
+ [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'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)]
)
self.phys_strip_params = self.virt_strip_params + [
"comp.knob = 0.0",
"gate.knob = 0.0",
"denoiser.knob = 0.0",
"eq.on = false",
'comp.knob = 0.0',
'gate.knob = 0.0',
'denoiser.knob = 0.0',
'eq.on = false',
]
self.bus_params = [
"mono = false",
"eq.on = false",
"mute = false",
"gain = 0.0",
'mono = false',
'eq.on = false',
'mute = false',
'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":
toml_str += ("\n").join(
case 'strip':
toml_str += ('\n').join(
self.phys_strip_params
if int(index) < self.kind.phys_in
else self.virt_strip_params
)
case "bus":
toml_str += ("\n").join(self.bus_params)
case 'bus':
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,25 +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
try:
self.parser = dataextraction_factory(data)
except tomllib.TOMLDecodeError as e:
ERR_MSG = (str(e), f"When attempting to load {identifier}.toml")
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()
@ -181,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.home() / ".config" / "voicemeeter" / kind.name,
Path.home() / "Documents" / "Voicemeeter" / "configs" / kind.name,
Path.cwd() / 'configs' / kind.name,
Path.home() / '.config' / 'voicemeeter' / kind.name,
Path.home() / 'Documents' / 'Voicemeeter' / 'configs' / kind.name,
):
if path.is_dir():
logger_loader.info(f"Checking [{path}] for TOML config files:")
for file in path.glob("*.toml"):
identifier = file.with_suffix("").stem
logger_loader.info(f'Checking [{path}] for TOML config files:')
for file in path.glob('*.toml'):
identifier = file.with_suffix('').stem
if loader.parse(identifier, file):
loader.register(identifier)
return loader.configs
@ -207,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

20
voicemeeterlib/device.py
View File

@ -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"}
return {"name": vals[0], "type": types[vals[1]], "id": vals[2]}
types = {1: 'mme', 3: 'wdm', 4: 'ks', 5: 'asio'}
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),
"outs": property(num_outs),
'ins': property(num_ins),
'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')

8
voicemeeterlib/error.py
View File

@ -13,12 +13,12 @@ class CAPIError(VMError):
self.fn_name = fn_name
self.code = code
if self.code == -9:
message = " ".join(
message = ' '.join(
(
f"no bind for {self.fn_name}.",
"are you using an old version of the API?",
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}"
message = f'{self.fn_name} returned {self.code}'
super().__init__(message)

22
voicemeeterlib/event.py
View File

@ -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 += ("not listening for any events",)
self.logger.info(", ".join(info))
info += ('not listening for any events',)
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:

60
voicemeeterlib/factory.py
View File

@ -29,8 +29,8 @@ class FactoryBuilder:
"""
BuilderProgress = IntEnum(
"BuilderProgress",
"strip bus command macrobutton vban device option recorder patch fx",
'BuilderProgress',
'strip bus command macrobutton vban device option recorder patch fx',
start=0,
)
@ -38,22 +38,22 @@ class FactoryBuilder:
self._factory = factory
self.kind = kind
self._info = (
f"Finished building strips for {self._factory}",
f"Finished building buses for {self._factory}",
f"Finished building commands for {self._factory}",
f"Finished building macrobuttons for {self._factory}",
f"Finished building vban in/out streams for {self._factory}",
f"Finished building device for {self._factory}",
f"Finished building option for {self._factory}",
f"Finished building recorder for {self._factory}",
f"Finished building patch for {self._factory}",
f"Finished building fx for {self._factory}",
f'Finished building strips for {self._factory}',
f'Finished building buses for {self._factory}',
f'Finished building commands for {self._factory}',
f'Finished building macrobuttons for {self._factory}',
f'Finished building vban in/out streams for {self._factory}',
f'Finished building device for {self._factory}',
f'Finished building option for {self._factory}',
f'Finished building recorder for {self._factory}',
f'Finished building patch for {self._factory}',
f'Finished building fx for {self._factory}',
)
self.logger = logger.getChild(self.__class__.__name__)
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,17 +108,17 @@ class FactoryBase(Remote):
def __init__(self, kind_id: str, **kwargs):
defaultkwargs = {
"sync": False,
"ratelimit": 0.033,
"pdirty": False,
"mdirty": False,
"midi": False,
"ldirty": False,
"timeout": 2,
"bits": 64,
'sync': False,
'ratelimit': 0.033,
'pdirty': False,
'mdirty': False,
'midi': False,
'ldirty': False,
'timeout': 2,
'bits': 64,
}
if "subs" in kwargs:
defaultkwargs |= kwargs.pop("subs") # for backwards compatibility
if 'subs' in kwargs:
defaultkwargs |= kwargs.pop('subs') # for backwards compatibility
kwargs = defaultkwargs | kwargs
self.kind = kindmap(kind_id)
super().__init__(**kwargs)
@ -135,7 +135,7 @@ class FactoryBase(Remote):
self._configs = None
def __str__(self) -> str:
return f"Voicemeeter {self.kind}"
return f'Voicemeeter {self.kind}'
@property
@abstractmethod
@ -225,15 +225,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:
@ -243,12 +243,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

28
voicemeeterlib/inst.py
View File

@ -7,21 +7,21 @@ from .error import InstallError
BITS = 64 if ct.sizeof(ct.c_void_p) == 8 else 32
if platform.system() != "Windows":
raise InstallError("Only Windows OS supported")
if platform.system() != 'Windows':
raise InstallError('Only Windows OS supported')
VM_KEY = "VB:Voicemeeter {17359A74-1236-5467}"
REG_KEY = "\\".join(
VM_KEY = 'VB:Voicemeeter {17359A74-1236-5467}'
REG_KEY = '\\'.join(
filter(
None,
(
"SOFTWARE",
"WOW6432Node" if BITS == 64 else "",
"Microsoft",
"Windows",
"CurrentVersion",
"Uninstall",
'SOFTWARE',
'WOW6432Node' if BITS == 64 else '',
'Microsoft',
'Windows',
'CurrentVersion',
'Uninstall',
),
)
)
@ -29,20 +29,20 @@ REG_KEY = "\\".join(
def get_vmpath():
with winreg.OpenKey(
winreg.HKEY_LOCAL_MACHINE, r"{}".format("\\".join((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].strip('"')
return winreg.QueryValueEx(vm_key, r'UninstallString')[0].strip('"')
try:
vm_parent = Path(get_vmpath()).parent
except FileNotFoundError as e:
raise InstallError("Unable to fetch DLL path from the registry") from e
raise InstallError('Unable to fetch DLL path from the registry') from e
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))

12
voicemeeterlib/iremote.py
View File

@ -19,19 +19,19 @@ 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}",)
return "".join(cmd)
cmd += (f'.{param}',)
return ''.join(cmd)
@abstractmethod
def identifier(self):
@ -39,7 +39,7 @@ class IRemote(metaclass=ABCMeta):
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)

8
voicemeeterlib/kinds.py
View File

@ -100,14 +100,14 @@ class PotatoMap(KindMapClass):
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)

10
voicemeeterlib/macrobutton.py
View File

@ -3,8 +3,8 @@ from enum import IntEnum
from .iremote import IRemote
ButtonModes = IntEnum(
"ButtonModes",
"state stateonly trigger",
'ButtonModes',
'state stateonly trigger',
start=1,
)
@ -16,12 +16,12 @@ class Adapter(IRemote):
pass
def getter(self, mode):
self.logger.debug(f"getter: button[{self.index}].{ButtonModes(mode).name}")
self.logger.debug(f'getter: button[{self.index}].{ButtonModes(mode).name}')
return self._remote.get_buttonstatus(self.index, mode)
def setter(self, mode, val):
self.logger.debug(
f"setter: button[{self.index}].{ButtonModes(mode).name}={val}"
f'setter: button[{self.index}].{ButtonModes(mode).name}={val}'
)
self._remote.set_buttonstatus(self.index, val, mode)
@ -30,7 +30,7 @@ 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:

96
voicemeeterlib/misc.py
View File

@ -6,43 +6,43 @@ from .iremote import IRemote
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):
@ -57,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)),
"insert": tuple(Insert(remote, i) for i in range(remote.kind.insert)),
'composite': tuple(Composite(remote, i) for i in range(8)),
'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 "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 "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):
@ -109,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):
@ -120,13 +120,13 @@ 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']
},
},
)
@ -139,27 +139,27 @@ def _make_asio_mixins(remote):
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):
@ -173,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:
self.logger.warning(f"sr got: {val} but expected a value in {opts}")
self.setter("sr", val)
self.logger.warning(f'sr got: {val} but expected a value in {opts}')
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:

102
voicemeeterlib/recorder.py
View File

@ -23,91 +23,91 @@ class Recorder(IRemote):
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, ARMCHANNELMIXIN_cls),
{
**{
param: action_fn(param)
for param in [
"play",
"stop",
"pause",
"replay",
"record",
"ff",
"rew",
'play',
'stop',
'pause',
'replay',
'record',
'ff',
'rew',
]
},
"mode": RecorderMode(remote),
'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"))
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)
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"))
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}"
f'bitresolution got: {val} but expected a value in {opts}'
)
self.setter("bitresolution", val)
self.setter('bitresolution', 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:
self.logger.warning(f"channel got: {val} but expected a value from 1 to 8")
self.setter("channel", val)
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"))
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)
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)
return round(self.getter('gain'), 1)
@gain.setter
def gain(self, val: float):
self.setter("gain", val)
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')
# loop forwarder methods, for backwards compatibility
@property
@ -121,69 +121,69 @@ class Recorder(IRemote):
def goto(self, time_str):
def get_sec():
"""Get seconds from time string"""
h, m, s = time_str.split(":")
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)$",
r'^(?:[01]\d|2[0123]):(?:[012345]\d):(?:[012345]\d)$',
time_str,
)
is not None
):
self.setter("goto", get_sec())
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}
opts = {'wav': 1, 'aiff': 2, 'bwf': 3, 'mp3': 100}
try:
self.setter("filetype", opts[val.lower()])
self.setter('filetype', opts[val.lower()])
except KeyError:
self.logger.warning(
f"filetype got: {val} but expected a value in {list(opts.keys())}"
f'filetype got: {val} but expected a value in {list(opts.keys())}'
)
class RecorderMode(IRemote):
@property
def identifier(self):
return "recorder.mode"
return 'recorder.mode'
@property
def recbus(self) -> bool:
return self.getter("recbus") == 1
return self.getter('recbus') == 1
@recbus.setter
def recbus(self, val: bool):
self.setter("recbus", 1 if val else 0)
self.setter('recbus', 1 if val else 0)
@property
def playonload(self) -> bool:
return self.getter("playonload") == 1
return self.getter('playonload') == 1
@playonload.setter
def playonload(self, val: bool):
self.setter("playonload", 1 if val else 0)
self.setter('playonload', 1 if val else 0)
@property
def loop(self) -> bool:
return self.getter("loop") == 1
return self.getter('loop') == 1
@loop.setter
def loop(self, val: bool):
self.setter("loop", 1 if val else 0)
self.setter('loop', 1 if val else 0)
@property
def multitrack(self) -> bool:
return self.getter("multitrack") == 1
return self.getter('multitrack') == 1
@multitrack.setter
def multitrack(self, val: bool):
self.setter("multitrack", 1 if val else 0)
self.setter('multitrack', 1 if val else 0)
class RecorderArmChannel(IRemote):
@ -192,31 +192,31 @@ class RecorderArmChannel(IRemote):
self._i = i
def set(self, val: bool):
self.setter("", 1 if val else 0)
self.setter('', 1 if val else 0)
class RecorderArmStrip(RecorderArmChannel):
@property
def identifier(self):
return f"recorder.armstrip[{self._i}]"
return f'recorder.armstrip[{self._i}]'
class RecorderArmBus(RecorderArmChannel):
@property
def identifier(self):
return f"recorder.armbus[{self._i}]"
return f'recorder.armbus[{self._i}]'
def _make_armchannel_mixin(remote, kind):
"""Creates an armchannel out mixin"""
return type(
f"ArmChannelMixin{kind}",
f'ArmChannelMixin{kind}',
(),
{
"armstrip": tuple(
'armstrip': tuple(
RecorderArmStrip(remote, i) for i in range(kind.num_strip)
),
"armbus": tuple(RecorderArmBus(remote, i) for i in range(kind.num_bus)),
'armbus': tuple(RecorderArmBus(remote, i) for i in range(kind.num_bus)),
},
)
@ -228,11 +228,11 @@ def _make_armchannel_mixins(remote):
def _make_channelout_mixin(kind):
"""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"B{i}": bool_prop(f"B{i}") for i in range(1, kind.virt_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)},
},
)

80
voicemeeterlib/remote.py
View File

@ -30,7 +30,7 @@ class Remote(CBindings):
self.midi = Midi()
self.subject = self.observer = Subject()
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
@ -41,7 +41,7 @@ class Remote(CBindings):
if self.bits not in (32, 64):
self.logger.warning(
f"kwarg bits got {self.bits}, expected either 32 or 64, defaulting to 64"
f'kwarg bits got {self.bits}, expected either 32 or 64, defaulting to 64'
)
self.bits = 64
@ -61,7 +61,7 @@ class Remote(CBindings):
"""Starts updates thread."""
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()
@ -79,7 +79,7 @@ class Remote(CBindings):
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."
'Voicemeeter engine running but GUI not launched. Launching the GUI now.'
)
self.run_voicemeeter(self.kind.name)
@ -103,7 +103,7 @@ class Remote(CBindings):
"""Returns Voicemeeter's version as a string"""
ver = ct.c_long()
self.call(self.bind_get_voicemeeter_version, ct.byref(ver))
return "{}.{}.{}.{}".format(
return '{}.{}.{}.{}'.format(
(ver.value & 0xFF000000) >> 24,
(ver.value & 0x00FF0000) >> 16,
(ver.value & 0x0000FF00) >> 8,
@ -121,16 +121,16 @@ class Remote(CBindings):
try:
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}")
raise CAPIError("VBVMR_MacroButton_IsDirty", -9) from e
self.logger.exception(f'{type(e).__name__}: {e}')
raise CAPIError('VBVMR_MacroButton_IsDirty', -9) 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
and self.cache.get("bus_level") == self._bus_buf
self.cache.get('strip_level') == self._strip_buf
and self.cache.get('bus_level') == self._bus_buf
)
def clear_dirty(self) -> None:
@ -138,9 +138,9 @@ class Remote(CBindings):
while self.pdirty or self.mdirty:
pass
except CAPIError as e:
if not (e.fn_name == "VBVMR_MacroButton_IsDirty" and e.code == -9):
if not (e.fn_name == 'VBVMR_MacroButton_IsDirty' and e.code == -9):
raise
self.logger.error(f"{e} clearing pdirty only.")
self.logger.error(f'{e} clearing pdirty only.')
while self.pdirty:
pass
@ -159,7 +159,7 @@ class Remote(CBindings):
"""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.bind_set_parameter_string_w, param.encode(), ct.c_wchar_p(val)
)
@ -181,8 +181,8 @@ class Remote(CBindings):
ct.c_long(mode),
)
except AttributeError as e:
self.logger.exception(f"{type(e).__name__}: {e}")
raise CAPIError("VBVMR_MacroButton_GetStatus", -9) from e
self.logger.exception(f'{type(e).__name__}: {e}')
raise CAPIError('VBVMR_MacroButton_GetStatus', -9) from e
return int(c_state.value)
def set_buttonstatus(self, id_: int, val: int, mode: int) -> None:
@ -196,26 +196,26 @@ class Remote(CBindings):
ct.c_long(mode),
)
except AttributeError as e:
self.logger.exception(f"{type(e).__name__}: {e}")
raise CAPIError("VBVMR_MacroButton_SetStatus", -9) from e
self.cache[f"mb_{id_}_{mode}"] = int(c_state.value)
self.logger.exception(f'{type(e).__name__}: {e}')
raise CAPIError('VBVMR_MacroButton_SetStatus', -9) 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"):
raise VMError("Expected a direction: in or out")
func = getattr(self, f"bind_{direction}put_get_device_number")
if direction not in ('in', 'out'):
raise VMError('Expected a direction: in or out')
func = getattr(self, f'bind_{direction}put_get_device_number')
res = self.call(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"):
raise VMError("Expected a direction: in or out")
if direction not in ('in', '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"bind_{direction}put_get_device_desc_w")
func = getattr(self, f'bind_{direction}put_get_device_desc_w')
self.call(
func,
ct.c_long(index),
@ -257,7 +257,7 @@ class Remote(CBindings):
)
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
@ -271,7 +271,7 @@ 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.bind_set_parameters, script.encode())
time.sleep(self.DELAY * 5)
@ -283,15 +283,15 @@ class Remote(CBindings):
"""
def target(key):
match key.split("-"):
case ["strip" | "bus" | "button" as kls, index] if index.isnumeric():
match key.split('-'):
case ['strip' | 'bus' | 'button' as kls, index] if index.isnumeric():
target = getattr(self, kls)
case [
"vban",
"in"
| "instream"
| "out"
| "outstream" as direction,
'vban',
'in'
| 'instream'
| 'out'
| 'outstream' as direction,
index,
] if index.isnumeric():
target = getattr(
@ -309,20 +309,20 @@ class Remote(CBindings):
"""applies a config from memory"""
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:
config = self.configs[name]
except KeyError as e:
self.logger.error(("\n").join(ERR_MSG))
raise VMError(("\n").join(ERR_MSG)) from e
self.logger.error(('\n').join(ERR_MSG))
raise VMError(('\n').join(ERR_MSG)) from e
if "extends" in config:
extended = config["extends"]
if 'extends' in config:
extended = config['extends']
config = {
k: v
for k, v in deep_merge(self.configs[extended], config)
if k not in ("extends")
if k not in ('extends')
}
self.logger.debug(
f"profile '{name}' extends '{extended}', profiles merged.."
@ -332,7 +332,7 @@ class Remote(CBindings):
def end_thread(self):
if not self.stopped():
self.logger.debug("events thread shutdown started")
self.logger.debug('events thread shutdown started')
self.stop_event.set()
self.producer.join() # wait for producer thread to complete cycle
@ -340,7 +340,7 @@ class Remote(CBindings):
"""Logout of the API"""
time.sleep(0.1)
self.call(self.bind_logout)
self.logger.info(f"{type(self).__name__}: Successfully logged out of {self}")
self.logger.info(f'{type(self).__name__}: Successfully logged out of {self}')
def __exit__(self, exc_type, exc_value, exc_traceback) -> None:
"""teardown procedures"""

230
voicemeeterlib/strip.py
View File

@ -21,62 +21,62 @@ class Strip(IRemote):
@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,203 @@ class PhysicalStrip(Strip):
"""
EFFECTS_cls = _make_effects_mixins(is_phys)[remote.kind.name]
return type(
"PhysicalStrip",
'PhysicalStrip',
(cls, EFFECTS_cls),
{
"comp": StripComp(remote, i),
"gate": StripGate(remote, i),
"denoiser": StripDenoiser(remote, i),
"eq": StripEQ(remote, i),
"device": StripDevice.make(remote, i),
'comp': StripComp(remote, i),
'gate': StripGate(remote, i),
'denoiser': StripDenoiser(remote, i),
'eq': StripEQ(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"), 2)
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):
@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 StripDevice(IRemote):
@ -298,16 +298,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",
"ks",
"mme",
"asio",
'wdm',
'ks',
'mme',
'asio',
]
},
},
@ -316,15 +316,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 +337,65 @@ class VirtualStrip(Strip):
"""
EFFECTS_cls = _make_effects_mixins(is_phys)[remote.kind.name]
return type(
"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) -> 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) -> 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) -> 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):
@ -416,7 +416,7 @@ class StripLevel(IRemote):
return round(20 * log(x, 10), 1) if x > 0 else -200.0
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 +424,7 @@ class StripLevel(IRemote):
@property
def identifier(self) -> str:
return f"Strip[{self.index}]"
return f'Strip[{self.index}]'
@property
def prefader(self) -> tuple:
@ -477,24 +477,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(
"GainlayerMixin",
'GainlayerMixin',
(),
{
"gainlayer": tuple(
'gainlayer': tuple(
GainLayer(remote, index, i) for i in range(remote.kind.num_bus)
)
},
@ -504,11 +504,11 @@ 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"B{i}": bool_prop(f"B{i}") for i in range(1, kind.virt_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)},
},
)
@ -522,12 +522,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"]}
color = {param: float_prop(param) for param in ["color_x", "color_y"]}
fx = {param: float_prop(param) for param in ["fx_x", "fx_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']}
fx = {param: float_prop(param) for param in ['fx_x', 'fx_y']}
if is_phys:
return type(
"XYPhys",
'XYPhys',
(),
{
**pan,
@ -536,7 +536,7 @@ def _make_effects_mixin(kind, is_phys):
},
)
return type(
"XYVirt",
'XYVirt',
(),
{**pan},
)
@ -544,28 +544,28 @@ 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}")
for param in ["reverb", "delay", "fx1", "fx2"]
f'post{param}': bool_prop(f'post{param}')
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):
@ -588,14 +588,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)

20
voicemeeterlib/subject.py
View File

@ -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

36
voicemeeterlib/updater.py
View File

@ -11,7 +11,7 @@ class Producer(threading.Thread):
"""Continously send job queue to the Updater thread at a rate of self._remote.ratelimit."""
def __init__(self, remote, queue, stop_event):
super().__init__(name="producer", daemon=False)
super().__init__(name='producer', daemon=False)
self._remote = remote
self.queue = queue
self.stop_event = stop_event
@ -23,35 +23,35 @@ class Producer(threading.Thread):
def run(self):
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.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"],
self._remote.cache['strip_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["bus_level"], bus_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)),
)
def run(self):
@ -61,15 +61,15 @@ class Updater(threading.Thread):
Generate _strip_comp, _bus_comp and update level cache if ldirty.
"""
while event := self.queue.get():
if event == "pdirty" and self._remote.pdirty:
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["bus_level"] = self._remote._bus_buf
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")
self.logger.debug(f'terminating {self.name} thread')

20
voicemeeterlib/util.py
View File

@ -22,16 +22,16 @@ def timeout(func):
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}"
f'{type(remote).__name__}: Successfully logged into {remote} version {remote.version}'
)
remote.logger.debug(f"login time: {round(time.time() - start, 2)}")
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")
raise VMError('Timeout logging into the api')
remote.clear_dirty()
return wrapper
@ -48,15 +48,15 @@ def polling(func):
@functools.wraps(func)
def wrapper(*args, **kwargs):
get = func.__name__ == "get"
mb_get = func.__name__ == "get_buttonstatus"
get = func.__name__ == 'get'
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)
@ -73,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)

72
voicemeeterlib/vban.py
View File

@ -17,94 +17,94 @@ class VbanStream(IRemote):
@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:
self.logger.warning(
f"port got: {val} but expected a value from 1024 to 65535"
f'port got: {val} but expected a value from 1024 to 65535'
)
self.setter("port", val)
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:
self.logger.warning(f"sr got: {val} but expected a value in {opts}")
self.setter("sr", val)
self.logger.warning(f'sr got: {val} but expected a value in {opts}')
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:
self.logger.warning(f"channel got: {val} but expected a value from 1 to 8")
self.setter("channel", val)
self.logger.warning(f'channel got: {val} but expected a value from 1 to 8')
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):
self.logger.warning(f"bit got: {val} but expected value 16 or 24")
self.setter("bit", 1 if (val == 16) else 2)
self.logger.warning(f'bit got: {val} but expected value 16 or 24')
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:
self.logger.warning(f"quality got: {val} but expected a value from 0 to 4")
self.setter("quality", val)
self.logger.warning(f'quality got: {val} but expected a value from 0 to 4')
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:
self.logger.warning(f"route got: {val} but expected a value from 0 to 8")
self.setter("route", val)
self.logger.warning(f'route got: {val} but expected a value from 0 to 8')
self.setter('route', val)
class VbanInstream(VbanStream):
@ -115,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:
@ -154,11 +154,11 @@ 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):
@ -174,22 +174,22 @@ def _make_stream_pair(remote, kind):
def _make_cls(i, direction):
match direction:
case "in":
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":
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)),
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)),
)
@ -209,10 +209,10 @@ class Vban:
self.instream, self.outstream = _make_stream_pairs(remote)[remote.kind.name]
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:
@ -222,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: