onyx_online/nvda-voicemeeter
1
0
Fork 0
mirror of https://github.com/onyx-and-iris/nvda-voicemeeter.git synced 2025-02-21 12:25:07 +00:00
Code Issues Packages Projects Releases Wiki Activity

re-run files through ruff formatter

Browse Source
This commit is contained in:
Onyx and Iris 2025-01-20 16:29:47 +00:00
parent b5ea41c604
commit fbd4962fb2
9 changed files with 1202 additions and 1202 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

196
src/nvda_voicemeeter/builder.py
View File

@ -16,7 +16,7 @@ class Builder:
menu = [[self.make_menu()]]
layout0 = []
if self.kind.name == "basic":
if self.kind.name == 'basic':
steps = (
self.make_tab0_row0,
self.make_tab0_row1,
@ -62,65 +62,65 @@ class Builder:
def _make_inner_tabgroup(layouts, identifier) -> psg.TabGroup:
inner_layout = []
for i, tabname in enumerate(("buttons", "sliders")):
inner_layout.append([psg.Tab(tabname.capitalize(), layouts[i], key=f"tab||{identifier}||{tabname}")])
for i, tabname in enumerate(('buttons', 'sliders')):
inner_layout.append([psg.Tab(tabname.capitalize(), layouts[i], key=f'tab||{identifier}||{tabname}')])
return psg.TabGroup(
inner_layout,
change_submits=True,
enable_events=True,
key=f"tabgroup||{identifier}",
key=f'tabgroup||{identifier}',
)
def _make_tabs(identifier) -> psg.Tab:
match identifier:
case "Settings":
return psg.Tab("Settings", layout0, key="tab||Settings")
case "Physical Strip":
case 'Settings':
return psg.Tab('Settings', layout0, key='tab||Settings')
case 'Physical Strip':
tabgroup = _make_inner_tabgroup((layout1_1, layout1_2), identifier)
case "Virtual Strip":
case 'Virtual Strip':
tabgroup = _make_inner_tabgroup((layout2_1, layout2_2), identifier)
case "Buses":
case 'Buses':
tabgroup = _make_inner_tabgroup((layout3_1, layout3_2), identifier)
return psg.Tab(identifier, [[tabgroup]], key=f"tab||{identifier}")
return psg.Tab(identifier, [[tabgroup]], key=f'tab||{identifier}')
tabs = []
for tab in util.get_tabs_labels():
tabs.append(_make_tabs(tab))
tab_group = psg.TabGroup([tabs], change_submits=True, enable_events=True, key="tabgroup")
tab_group = psg.TabGroup([tabs], change_submits=True, enable_events=True, key='tabgroup')
return [[menu], [tab_group]]
def make_menu(self) -> psg.Menu:
themes = [f"{theme}::MENU THEME" for theme in util.get_themes_list()]
themes.append("Default::MENU THEME")
themes = [f'{theme}::MENU THEME' for theme in util.get_themes_list()]
themes.append('Default::MENU THEME')
menu_def = [
[
"&Voicemeeter",
'&Voicemeeter',
[
"Restart Audio Engine::MENU",
"Save Settings::MENU",
"Load Settings::MENU",
"Load Settings on Startup ::MENU",
'Restart Audio Engine::MENU',
'Save Settings::MENU',
'Load Settings::MENU',
'Load Settings on Startup ::MENU',
],
],
["&Theme", themes],
['&Theme', themes],
]
return psg.Menu(menu_def, key="menus")
return psg.Menu(menu_def, key='menus')
def make_tab0_row0(self) -> psg.Frame:
"""tab0 row0 represents hardware ins"""
def add_physical_device_opts(layout):
devices = util.get_input_device_list(self.vm)
devices.append("- remove device selection -")
devices.append('- remove device selection -')
layout.append(
[
psg.ButtonMenu(
f"IN {i + 1}",
f'IN {i + 1}',
size=(6, 3),
menu_def=["", devices],
key=f"HARDWARE IN||{i + 1}",
menu_def=['', devices],
key=f'HARDWARE IN||{i + 1}',
)
for i in range(self.kind.phys_in)
]
@ -128,23 +128,23 @@ class Builder:
hardware_in = []
[step(hardware_in) for step in (add_physical_device_opts,)]
return psg.Frame("Hardware In", hardware_in)
return psg.Frame('Hardware In', hardware_in)
def make_tab0_row1(self) -> psg.Frame:
"""tab0 row1 represents hardware outs"""
def add_physical_device_opts(layout):
if self.kind.name == "basic":
if self.kind.name == 'basic':
num_outs = self.kind.phys_out + self.kind.virt_out
else:
num_outs = self.kind.phys_out
layout.append(
[
psg.ButtonMenu(
f"A{i + 1}",
f'A{i + 1}',
size=(6, 3),
menu_def=["", util.get_output_device_list(i, self.vm)],
key=f"HARDWARE OUT||A{i + 1}",
menu_def=['', util.get_output_device_list(i, self.vm)],
key=f'HARDWARE OUT||A{i + 1}',
)
for i in range(num_outs)
]
@ -152,7 +152,7 @@ class Builder:
hardware_out = []
[step(hardware_out) for step in (add_physical_device_opts,)]
return psg.Frame("Hardware Out", hardware_out)
return psg.Frame('Hardware Out', hardware_out)
def make_tab0_row3(self) -> psg.Frame:
"""tab0 row3 represents patch composite"""
@ -162,10 +162,10 @@ class Builder:
layout.append(
[
psg.ButtonMenu(
f"PC{i + 1}",
f'PC{i + 1}',
size=(5, 2),
menu_def=["", outputs],
key=f"PATCH COMPOSITE||PC{i + 1}",
menu_def=['', outputs],
key=f'PATCH COMPOSITE||PC{i + 1}',
)
for i in range(self.kind.composite)
]
@ -173,7 +173,7 @@ class Builder:
hardware_out = []
[step(hardware_out) for step in (add_physical_device_opts,)]
return psg.Frame("PATCH COMPOSITE", hardware_out)
return psg.Frame('PATCH COMPOSITE', hardware_out)
def make_tab0_row4(self) -> psg.Frame:
"""tab0 row4 represents patch insert"""
@ -185,28 +185,28 @@ class Builder:
[
psg.Checkbox(
text=channel,
default=self.window.cache["insert"][
f"INSERT CHECKBOX||{util.get_insert_checkbox_index(self.kind, j, i)}"
default=self.window.cache['insert'][
f'INSERT CHECKBOX||{util.get_insert_checkbox_index(self.kind, j, i)}'
],
enable_events=True,
key=f"INSERT CHECKBOX||IN{i} {j}",
key=f'INSERT CHECKBOX||IN{i} {j}',
)
],
)
for j, channel in enumerate(("LEFT", "RIGHT"))
for j, channel in enumerate(('LEFT', 'RIGHT'))
]
else:
layout.append(
[
psg.Checkbox(
text=channel,
default=self.window.cache["insert"][
f"INSERT CHECKBOX||{util.get_insert_checkbox_index(self.kind, j, i)}"
default=self.window.cache['insert'][
f'INSERT CHECKBOX||{util.get_insert_checkbox_index(self.kind, j, i)}'
],
enable_events=True,
key=f"INSERT CHECKBOX||IN{i} {j}",
key=f'INSERT CHECKBOX||IN{i} {j}',
)
for j, channel in enumerate(("LEFT", "RIGHT", "C", "LFE", "SL", "SR", "BL", "BR"))
for j, channel in enumerate(('LEFT', 'RIGHT', 'C', 'LFE', 'SL', 'SR', 'BL', 'BR'))
],
)
@ -216,29 +216,29 @@ class Builder:
for i, checkbox_list in enumerate(checkbox_lists):
if i < self.kind.phys_in:
[step(checkbox_list, i + 1) for step in (add_insert_checkboxes,)]
inner.append(psg.Frame(f"In#{i + 1}", checkbox_list))
inner.append(psg.Frame(f'In#{i + 1}', checkbox_list))
else:
[step(checkbox_list, i + 1) for step in (add_insert_checkboxes,)]
asio_checkboxes.append([psg.Frame(f"In#{i + 1}", checkbox_list)])
asio_checkboxes.append([psg.Frame(f'In#{i + 1}', checkbox_list)])
asio_checkboxes.insert(0, inner)
return psg.Frame("PATCH INSERT", asio_checkboxes)
return psg.Frame('PATCH INSERT', asio_checkboxes)
def make_tab0_row5(self) -> psg.Frame:
"""tab0 row5 represents advanced settings"""
return psg.Frame(
"ADVANCED SETTINGS",
'ADVANCED SETTINGS',
[
[
psg.Button(
"ADVANCED SETTINGS",
'ADVANCED SETTINGS',
size=(20, 2),
key="ADVANCED SETTINGS",
key='ADVANCED SETTINGS',
)
],
],
key="ADVANCED SETTINGS FRAME",
key='ADVANCED SETTINGS FRAME',
)
def make_tab1_button_row(self, i) -> psg.Frame:
@ -248,26 +248,26 @@ class Builder:
layout.append(
[
psg.Button(
f"A{j + 1}" if j < self.kind.phys_out else f"B{j - self.kind.phys_out + 1}",
f'A{j + 1}' if j < self.kind.phys_out else f'B{j - self.kind.phys_out + 1}',
size=(4, 2),
key=f"STRIP {i}||A{j + 1}"
key=f'STRIP {i}||A{j + 1}'
if j < self.kind.phys_out
else f"STRIP {i}||B{j - self.kind.phys_out + 1}",
else f'STRIP {i}||B{j - self.kind.phys_out + 1}',
)
for j in range(self.kind.phys_out + self.kind.virt_out)
],
)
layout.append(
[
psg.Button("Mono", size=(6, 2), key=f"STRIP {i}||MONO"),
psg.Button("Solo", size=(6, 2), key=f"STRIP {i}||SOLO"),
psg.Button("Mute", size=(6, 2), key=f"STRIP {i}||MUTE"),
psg.Button('Mono', size=(6, 2), key=f'STRIP {i}||MONO'),
psg.Button('Solo', size=(6, 2), key=f'STRIP {i}||SOLO'),
psg.Button('Mute', size=(6, 2), key=f'STRIP {i}||MUTE'),
],
)
outputs = []
[step(outputs) for step in (add_strip_outputs,)]
return psg.Frame(self.window.cache["labels"][f"STRIP {i}||LABEL"], outputs, key=f"STRIP {i}||LABEL")
return psg.Frame(self.window.cache['labels'][f'STRIP {i}||LABEL'], outputs, key=f'STRIP {i}||LABEL')
def make_tab1_button_rows(self) -> psg.Frame:
layout = [[self.make_tab1_button_row(i)] for i in range(self.kind.phys_in)]
@ -277,7 +277,7 @@ class Builder:
def add_gain_slider(layout):
layout.append(
[
psg.Text("Gain"),
psg.Text('Gain'),
psg.Slider(
range=(-60, 12),
default_value=self.vm.strip[i].gain,
@ -286,8 +286,8 @@ class Builder:
expand_x=True,
enable_events=True,
disabled=True,
orientation="horizontal",
key=f"STRIP {i}||SLIDER GAIN",
orientation='horizontal',
key=f'STRIP {i}||SLIDER GAIN',
),
]
)
@ -298,7 +298,7 @@ class Builder:
def add_limit_slider(layout):
layout.append(
[
psg.Text("Limit"),
psg.Text('Limit'),
psg.Slider(
range=(-40, 12),
default_value=self.vm.strip[i].limit,
@ -306,18 +306,18 @@ class Builder:
disable_number_display=True,
expand_x=True,
enable_events=True,
orientation="horizontal",
key=f"STRIP {i}||SLIDER LIMIT",
orientation='horizontal',
key=f'STRIP {i}||SLIDER LIMIT',
),
]
)
layout = []
steps = (add_gain_slider, add_param_sliders)
if self.kind.name in ("banana", "potato"):
if self.kind.name in ('banana', 'potato'):
steps += (add_limit_slider,)
[step(layout) for step in steps]
return psg.Frame(self.window.cache["labels"][f"STRIP {i}||LABEL"], layout, key=f"STRIP {i}||LABEL||SLIDER")
return psg.Frame(self.window.cache['labels'][f'STRIP {i}||LABEL'], layout, key=f'STRIP {i}||LABEL||SLIDER')
def make_tab1_slider_rows(self) -> psg.Frame:
layout = [[self.make_tab1_slider_row(i)] for i in range(self.kind.phys_in)]
@ -330,11 +330,11 @@ class Builder:
layout.append(
[
psg.Button(
f"A{j + 1}" if j < self.kind.phys_out else f"B{j - self.kind.phys_out + 1}",
f'A{j + 1}' if j < self.kind.phys_out else f'B{j - self.kind.phys_out + 1}',
size=(4, 2),
key=f"STRIP {i}||A{j + 1}"
key=f'STRIP {i}||A{j + 1}'
if j < self.kind.phys_out
else f"STRIP {i}||B{j - self.kind.phys_out + 1}",
else f'STRIP {i}||B{j - self.kind.phys_out + 1}',
)
for j in range(self.kind.phys_out + self.kind.virt_out)
]
@ -342,26 +342,26 @@ class Builder:
if i == self.kind.phys_in + 1:
layout.append(
[
psg.Button("K", size=(6, 2), key=f"STRIP {i}||KARAOKE"),
psg.Button("Solo", size=(6, 2), key=f"STRIP {i}||SOLO"),
psg.Button("Mute", size=(6, 2), key=f"STRIP {i}||MUTE"),
psg.Button('K', size=(6, 2), key=f'STRIP {i}||KARAOKE'),
psg.Button('Solo', size=(6, 2), key=f'STRIP {i}||SOLO'),
psg.Button('Mute', size=(6, 2), key=f'STRIP {i}||MUTE'),
],
)
else:
layout.append(
[
psg.Button("MC", size=(6, 2), key=f"STRIP {i}||MC"),
psg.Button("Solo", size=(6, 2), key=f"STRIP {i}||SOLO"),
psg.Button("Mute", size=(6, 2), key=f"STRIP {i}||MUTE"),
psg.Button('MC', size=(6, 2), key=f'STRIP {i}||MC'),
psg.Button('Solo', size=(6, 2), key=f'STRIP {i}||SOLO'),
psg.Button('Mute', size=(6, 2), key=f'STRIP {i}||MUTE'),
],
)
outputs = []
[step(outputs) for step in (add_strip_outputs,)]
return psg.Frame(
self.window.cache["labels"][f"STRIP {i}||LABEL"],
self.window.cache['labels'][f'STRIP {i}||LABEL'],
outputs,
key=f"STRIP {i}||LABEL",
key=f'STRIP {i}||LABEL',
)
def make_tab2_button_rows(self) -> psg.Frame:
@ -374,7 +374,7 @@ class Builder:
def add_gain_slider(layout):
layout.append(
[
psg.Text("Gain"),
psg.Text('Gain'),
psg.Slider(
range=(-60, 12),
default_value=self.vm.strip[i].gain,
@ -383,14 +383,14 @@ class Builder:
expand_x=True,
enable_events=True,
disabled=True,
orientation="horizontal",
key=f"STRIP {i}||SLIDER GAIN",
orientation='horizontal',
key=f'STRIP {i}||SLIDER GAIN',
),
]
)
def add_param_sliders(layout):
if self.kind.name in ("basic", "banana"):
if self.kind.name in ('basic', 'banana'):
for param in util.get_slider_params(i, self.kind):
layout.append([LabelSlider(self.window, i, param, range_=(-12, 12))])
else:
@ -404,7 +404,7 @@ class Builder:
def add_limit_slider(layout):
layout.append(
[
psg.Text("Limit"),
psg.Text('Limit'),
psg.Slider(
range=(-40, 12),
default_value=self.vm.strip[i].limit,
@ -412,21 +412,21 @@ class Builder:
disable_number_display=True,
expand_x=True,
enable_events=True,
orientation="horizontal",
key=f"STRIP {i}||SLIDER LIMIT",
orientation='horizontal',
key=f'STRIP {i}||SLIDER LIMIT',
),
]
)
layout = []
steps = (add_gain_slider, add_param_sliders)
if self.kind.name in ("banana", "potato"):
if self.kind.name in ('banana', 'potato'):
steps += (add_limit_slider,)
[step(layout) for step in steps]
return psg.Frame(
self.window.cache["labels"][f"STRIP {i}||LABEL"],
self.window.cache['labels'][f'STRIP {i}||LABEL'],
layout,
key=f"STRIP {i}||LABEL||SLIDER",
key=f'STRIP {i}||LABEL||SLIDER',
)
def make_tab2_slider_rows(self) -> psg.Frame:
@ -439,9 +439,9 @@ class Builder:
"""tab3 row represents bus composite toggle"""
def add_strip_outputs(layout):
params = ["MONO", "EQ", "MUTE"]
if self.kind.name == "basic":
params.remove("EQ")
params = ['MONO', 'EQ', 'MUTE']
if self.kind.name == 'basic':
params.remove('EQ')
busmodes = [util._bus_mode_map[mode] for mode in util.get_bus_modes(self.vm)]
layout.append(
[
@ -449,15 +449,15 @@ class Builder:
psg.Button(
param.capitalize(),
size=(6, 2),
key=f"BUS {i}||{param}",
key=f'BUS {i}||{param}',
)
for param in params
],
psg.ButtonMenu(
"BUSMODE",
'BUSMODE',
size=(12, 2),
menu_def=["", busmodes],
key=f"BUS {i}||MODE",
menu_def=['', busmodes],
key=f'BUS {i}||MODE',
),
]
)
@ -465,9 +465,9 @@ class Builder:
outputs = []
[step(outputs) for step in (add_strip_outputs,)]
return psg.Frame(
self.window.cache["labels"][f"BUS {i}||LABEL"],
self.window.cache['labels'][f'BUS {i}||LABEL'],
outputs,
key=f"BUS {i}||LABEL",
key=f'BUS {i}||LABEL',
)
def make_tab3_button_rows(self) -> psg.Frame:
@ -478,7 +478,7 @@ class Builder:
def add_gain_slider(layout):
layout.append(
[
psg.Text("Gain"),
psg.Text('Gain'),
psg.Slider(
range=(-60, 12),
default_value=self.vm.bus[i].gain,
@ -487,15 +487,15 @@ class Builder:
expand_x=True,
enable_events=True,
disabled=True,
orientation="horizontal",
key=f"BUS {i}||SLIDER GAIN",
orientation='horizontal',
key=f'BUS {i}||SLIDER GAIN',
),
]
)
outputs = []
[step(outputs) for step in (add_gain_slider,)]
return psg.Frame(self.window.cache["labels"][f"BUS {i}||LABEL"], outputs, key=f"BUS {i}||LABEL||SLIDER")
return psg.Frame(self.window.cache['labels'][f'BUS {i}||LABEL'], outputs, key=f'BUS {i}||LABEL||SLIDER')
def make_tab3_slider_rows(self) -> psg.Frame:
layout = [[self.make_tab3_slider_row(i)] for i in range(self.kind.num_bus)]

152
src/nvda_voicemeeter/compound.py
View File

@ -10,10 +10,10 @@ class LabelSlider(psg.Frame):
def __init__(self, parent, i, param, range_=(0, 10), *args, **kwargs):
self.parent = parent
if param in ("AUDIBILITY", "DENOISER"):
if param in ('AUDIBILITY', 'DENOISER'):
size = 7
else:
if psg.theme() == "HighContrast":
if psg.theme() == 'HighContrast':
size = 5
else:
size = 4
@ -28,8 +28,8 @@ class LabelSlider(psg.Frame):
size=(12, 16),
expand_x=True,
enable_events=True,
orientation="horizontal",
key=f"STRIP {i}||SLIDER {param}",
orientation='horizontal',
key=f'STRIP {i}||SLIDER {param}',
),
]
]
@ -37,7 +37,7 @@ class LabelSlider(psg.Frame):
def default_value(self, i, param):
target = getattr(self.parent.vm.strip[i], param.lower())
if param in ("COMP", "GATE", "DENOISER"):
if param in ('COMP', 'GATE', 'DENOISER'):
return target.knob
return target
@ -52,70 +52,70 @@ class CompSlider(psg.Slider):
disable_number_display=True,
expand_x=True,
enable_events=True,
orientation="horizontal",
key=f"COMPRESSOR||SLIDER {param}",
orientation='horizontal',
key=f'COMPRESSOR||SLIDER {param}',
**self.default_params(param),
)
def default_params(self, param):
match param:
case "INPUT GAIN":
case 'INPUT GAIN':
return {
"range": (-24, 24),
"default_value": self.vm.strip[self.index].comp.gainin,
"resolution": 0.1,
"disabled": True,
'range': (-24, 24),
'default_value': self.vm.strip[self.index].comp.gainin,
'resolution': 0.1,
'disabled': True,
}
case "RATIO":
case 'RATIO':
return {
"range": (1, 8),
"default_value": self.vm.strip[self.index].comp.ratio,
"resolution": 0.1,
'range': (1, 8),
'default_value': self.vm.strip[self.index].comp.ratio,
'resolution': 0.1,
}
case "THRESHOLD":
case 'THRESHOLD':
return {
"range": (-40, -3),
"default_value": self.vm.strip[self.index].comp.threshold,
"resolution": 0.1,
'range': (-40, -3),
'default_value': self.vm.strip[self.index].comp.threshold,
'resolution': 0.1,
}
case "ATTACK":
case 'ATTACK':
return {
"range": (0, 200),
"default_value": self.vm.strip[self.index].comp.attack,
"resolution": 0.1,
'range': (0, 200),
'default_value': self.vm.strip[self.index].comp.attack,
'resolution': 0.1,
}
case "RELEASE":
case 'RELEASE':
return {
"range": (0, 5000),
"default_value": self.vm.strip[self.index].comp.release,
"resolution": 0.1,
'range': (0, 5000),
'default_value': self.vm.strip[self.index].comp.release,
'resolution': 0.1,
}
case "KNEE":
case 'KNEE':
return {
"range": (0, 1),
"default_value": self.vm.strip[self.index].comp.knee,
"resolution": 0.01,
'range': (0, 1),
'default_value': self.vm.strip[self.index].comp.knee,
'resolution': 0.01,
}
case "OUTPUT GAIN":
case 'OUTPUT GAIN':
return {
"range": (-24, 24),
"default_value": self.vm.strip[self.index].comp.gainout,
"resolution": 0.1,
"disabled": True,
'range': (-24, 24),
'default_value': self.vm.strip[self.index].comp.gainout,
'resolution': 0.1,
'disabled': True,
}
@staticmethod
def check_bounds(param, val):
match param:
case "RATIO":
case 'RATIO':
val = util.check_bounds(val, (1, 8))
case "THRESHOLD":
case 'THRESHOLD':
val = util.check_bounds(val, (-40, -3))
case "ATTACK":
case 'ATTACK':
val = util.check_bounds(val, (0, 200))
case "RELEASE":
case 'RELEASE':
val = util.check_bounds(val, (0, 5000))
case "KNEE":
case 'KNEE':
val = util.check_bounds(val, (0, 1))
return val
@ -128,64 +128,64 @@ class GateSlider(psg.Slider):
disable_number_display=True,
expand_x=True,
enable_events=True,
orientation="horizontal",
key=f"GATE||SLIDER {param}",
orientation='horizontal',
key=f'GATE||SLIDER {param}',
**self.default_params(param),
)
def default_params(self, param):
match param:
case "THRESHOLD":
case 'THRESHOLD':
return {
"range": (-60, -10),
"default_value": self.vm.strip[self.index].gate.threshold,
"resolution": 0.1,
'range': (-60, -10),
'default_value': self.vm.strip[self.index].gate.threshold,
'resolution': 0.1,
}
case "DAMPING":
case 'DAMPING':
return {
"range": (-60, -10),
"default_value": self.vm.strip[self.index].gate.damping,
"resolution": 0.1,
'range': (-60, -10),
'default_value': self.vm.strip[self.index].gate.damping,
'resolution': 0.1,
}
case "BPSIDECHAIN":
case 'BPSIDECHAIN':
return {
"range": (100, 4000),
"default_value": self.vm.strip[self.index].gate.bpsidechain,
"resolution": 1,
'range': (100, 4000),
'default_value': self.vm.strip[self.index].gate.bpsidechain,
'resolution': 1,
}
case "ATTACK":
case 'ATTACK':
return {
"range": (0, 1000),
"default_value": self.vm.strip[self.index].gate.attack,
"resolution": 0.1,
'range': (0, 1000),
'default_value': self.vm.strip[self.index].gate.attack,
'resolution': 0.1,
}
case "HOLD":
case 'HOLD':
return {
"range": (0, 5000),
"default_value": self.vm.strip[self.index].gate.hold,
"resolution": 0.1,
'range': (0, 5000),
'default_value': self.vm.strip[self.index].gate.hold,
'resolution': 0.1,
}
case "RELEASE":
case 'RELEASE':
return {
"range": (0, 5000),
"default_value": self.vm.strip[self.index].gate.release,
"resolution": 0.1,
'range': (0, 5000),
'default_value': self.vm.strip[self.index].gate.release,
'resolution': 0.1,
}
@staticmethod
def check_bounds(param, val):
match param:
case "THRESHOLD":
case 'THRESHOLD':
val = util.check_bounds(val, (-60, -10))
case "DAMPING MAX":
case 'DAMPING MAX':
val = util.check_bounds(val, (-60, -10))
case "BPSIDECHAIN":
case 'BPSIDECHAIN':
val = util.check_bounds(val, (100, 4000))
case "ATTACK":
case 'ATTACK':
val = util.check_bounds(val, (0, 1000))
case "HOLD":
case 'HOLD':
val = util.check_bounds(val, (0, 5000))
case "RELEASE":
case 'RELEASE':
val = util.check_bounds(val, (0, 5000))
return val
@ -195,8 +195,8 @@ class LabelSliderAdvanced(psg.Frame):
def __init__(self, parent, index, param, slider_cls: Union[CompSlider, GateSlider], *args, **kwargs):
label_map = {
"DAMPING": "Damping Max",
"BPSIDECHAIN": "BP Sidechain",
'DAMPING': 'Damping Max',
'BPSIDECHAIN': 'BP Sidechain',
}
layout = [

8
src/nvda_voicemeeter/configuration.py
View File

@ -1,14 +1,14 @@
import json
from pathlib import Path
SETTINGS = Path.cwd() / "settings.json"
SETTINGS = Path.cwd() / 'settings.json'
def config_from_json():
data = {}
if not SETTINGS.exists():
return data
with open(SETTINGS, "r") as f:
with open(SETTINGS, 'r') as f:
data = json.load(f)
return data
@ -24,11 +24,11 @@ def get(key, default=None):
def set(key, value):
config[key] = value
with open(SETTINGS, "w") as f:
with open(SETTINGS, 'w') as f:
json.dump(config, f)
def delete(key):
del config[key]
with open(SETTINGS, "w") as f:
with open(SETTINGS, 'w') as f:
json.dump(config, f)

2
src/nvda_voicemeeter/errors.py
View File

@ -8,4 +8,4 @@ class NVDAVMCAPIError(NVDAVMError):
def __init__(self, fn_name, code):
self.fn_name = fn_name
self.code = code
super().__init__(f"{self.fn_name} returned {self.code}")
super().__init__(f'{self.fn_name} returned {self.code}')

84
src/nvda_voicemeeter/models.py
View File

@ -1,58 +1,58 @@
def _make_hardware_ins_cache(vm) -> dict:
return {**{f"HARDWARE IN||{i + 1}": vm.strip[i].device.name for i in range(vm.kind.phys_in)}}
return {**{f'HARDWARE IN||{i + 1}': vm.strip[i].device.name for i in range(vm.kind.phys_in)}}
def _make_hardware_outs_cache(vm) -> dict:
hw_outs = {**{f"HARDWARE OUT||A{i + 1}": vm.bus[i].device.name for i in range(vm.kind.phys_out)}}
if vm.kind.name == "basic":
hw_outs |= {"HARDWARE OUT||A2": vm.bus[1].device.name}
hw_outs = {**{f'HARDWARE OUT||A{i + 1}': vm.bus[i].device.name for i in range(vm.kind.phys_out)}}
if vm.kind.name == 'basic':
hw_outs |= {'HARDWARE OUT||A2': vm.bus[1].device.name}
return hw_outs
def _make_param_cache(vm, channel_type) -> dict:
params = {}
if channel_type == "strip":
if channel_type == 'strip':
match vm.kind.name:
case "basic":
case 'basic':
params |= {
**{f"STRIP {i}||A1": vm.strip[i].A1 for i in range(vm.kind.num_strip)},
**{f"STRIP {i}||B1": vm.strip[i].B1 for i in range(vm.kind.num_strip)},
**{f'STRIP {i}||A1': vm.strip[i].A1 for i in range(vm.kind.num_strip)},
**{f'STRIP {i}||B1': vm.strip[i].B1 for i in range(vm.kind.num_strip)},
}
case "banana":
case 'banana':
params |= {
**{f"STRIP {i}||A1": vm.strip[i].A1 for i in range(vm.kind.num_strip)},
**{f"STRIP {i}||A2": vm.strip[i].A2 for i in range(vm.kind.num_strip)},
**{f"STRIP {i}||A3": vm.strip[i].A3 for i in range(vm.kind.num_strip)},
**{f"STRIP {i}||B1": vm.strip[i].B1 for i in range(vm.kind.num_strip)},
**{f"STRIP {i}||B2": vm.strip[i].B2 for i in range(vm.kind.num_strip)},
**{f'STRIP {i}||A1': vm.strip[i].A1 for i in range(vm.kind.num_strip)},
**{f'STRIP {i}||A2': vm.strip[i].A2 for i in range(vm.kind.num_strip)},
**{f'STRIP {i}||A3': vm.strip[i].A3 for i in range(vm.kind.num_strip)},
**{f'STRIP {i}||B1': vm.strip[i].B1 for i in range(vm.kind.num_strip)},
**{f'STRIP {i}||B2': vm.strip[i].B2 for i in range(vm.kind.num_strip)},
}
case "potato":
case 'potato':
params |= {
**{f"STRIP {i}||A1": vm.strip[i].A1 for i in range(vm.kind.num_strip)},
**{f"STRIP {i}||A2": vm.strip[i].A2 for i in range(vm.kind.num_strip)},
**{f"STRIP {i}||A3": vm.strip[i].A3 for i in range(vm.kind.num_strip)},
**{f"STRIP {i}||A4": vm.strip[i].A4 for i in range(vm.kind.num_strip)},
**{f"STRIP {i}||A5": vm.strip[i].A5 for i in range(vm.kind.num_strip)},
**{f"STRIP {i}||B1": vm.strip[i].B1 for i in range(vm.kind.num_strip)},
**{f"STRIP {i}||B2": vm.strip[i].B2 for i in range(vm.kind.num_strip)},
**{f"STRIP {i}||B3": vm.strip[i].B3 for i in range(vm.kind.num_strip)},
**{f'STRIP {i}||A1': vm.strip[i].A1 for i in range(vm.kind.num_strip)},
**{f'STRIP {i}||A2': vm.strip[i].A2 for i in range(vm.kind.num_strip)},
**{f'STRIP {i}||A3': vm.strip[i].A3 for i in range(vm.kind.num_strip)},
**{f'STRIP {i}||A4': vm.strip[i].A4 for i in range(vm.kind.num_strip)},
**{f'STRIP {i}||A5': vm.strip[i].A5 for i in range(vm.kind.num_strip)},
**{f'STRIP {i}||B1': vm.strip[i].B1 for i in range(vm.kind.num_strip)},
**{f'STRIP {i}||B2': vm.strip[i].B2 for i in range(vm.kind.num_strip)},
**{f'STRIP {i}||B3': vm.strip[i].B3 for i in range(vm.kind.num_strip)},
}
params |= {
**{f"STRIP {i}||MONO": vm.strip[i].mono for i in range(vm.kind.phys_in)},
**{f"STRIP {i}||SOLO": vm.strip[i].solo for i in range(vm.kind.num_strip)},
**{f"STRIP {i}||MUTE": vm.strip[i].mute for i in range(vm.kind.num_strip)},
**{f'STRIP {i}||MONO': vm.strip[i].mono for i in range(vm.kind.phys_in)},
**{f'STRIP {i}||SOLO': vm.strip[i].solo for i in range(vm.kind.num_strip)},
**{f'STRIP {i}||MUTE': vm.strip[i].mute for i in range(vm.kind.num_strip)},
}
for i in range(vm.kind.phys_in, vm.kind.phys_in + vm.kind.virt_in):
if i == vm.kind.phys_in + 1:
params[f"STRIP {i}||KARAOKE"] = vm.strip[i].k
params[f'STRIP {i}||KARAOKE'] = vm.strip[i].k
else:
params[f"STRIP {i}||MC"] = vm.strip[i].mc
params[f'STRIP {i}||MC'] = vm.strip[i].mc
else:
params |= {
**{f"BUS {i}||MONO": vm.bus[i].mono for i in range(vm.kind.num_bus)},
**{f"BUS {i}||EQ": vm.bus[i].eq.on for i in range(vm.kind.num_bus)},
**{f"BUS {i}||MUTE": vm.bus[i].mute for i in range(vm.kind.num_bus)},
**{f"BUS {i}||MODE": vm.bus[i].mode.get() for i in range(vm.kind.num_bus)},
**{f'BUS {i}||MONO': vm.bus[i].mono for i in range(vm.kind.num_bus)},
**{f'BUS {i}||EQ': vm.bus[i].eq.on for i in range(vm.kind.num_bus)},
**{f'BUS {i}||MUTE': vm.bus[i].mute for i in range(vm.kind.num_bus)},
**{f'BUS {i}||MODE': vm.bus[i].mode.get() for i in range(vm.kind.num_bus)},
}
return params
@ -60,19 +60,19 @@ def _make_param_cache(vm, channel_type) -> dict:
def _make_label_cache(vm) -> dict:
return {
**{
f"STRIP {i}||LABEL": vm.strip[i].label if vm.strip[i].label else f"Hardware Input {i + 1}"
f'STRIP {i}||LABEL': vm.strip[i].label if vm.strip[i].label else f'Hardware Input {i + 1}'
for i in range(vm.kind.phys_in)
},
**{
f"STRIP {i}||LABEL": vm.strip[i].label if vm.strip[i].label else f"Virtual Input {i - vm.kind.phys_in + 1}"
f'STRIP {i}||LABEL': vm.strip[i].label if vm.strip[i].label else f'Virtual Input {i - vm.kind.phys_in + 1}'
for i in range(vm.kind.phys_in, vm.kind.phys_in + vm.kind.virt_in)
},
**{
f"BUS {i}||LABEL": vm.bus[i].label if vm.bus[i].label else f"Physical Bus {i + 1}"
f'BUS {i}||LABEL': vm.bus[i].label if vm.bus[i].label else f'Physical Bus {i + 1}'
for i in range(vm.kind.phys_out)
},
**{
f"BUS {i}||LABEL": vm.bus[i].label if vm.bus[i].label else f"Virtual Bus {i - vm.kind.phys_out + 1}"
f'BUS {i}||LABEL': vm.bus[i].label if vm.bus[i].label else f'Virtual Bus {i - vm.kind.phys_out + 1}'
for i in range(vm.kind.phys_out, vm.kind.phys_out + vm.kind.virt_out)
},
}
@ -80,16 +80,16 @@ def _make_label_cache(vm) -> dict:
def _make_patch_asio_cache(vm) -> dict:
params = {}
if vm.kind.name != "basic":
params |= {**{f"ASIO INPUT SPINBOX||{i}": vm.patch.asio[i].get() for i in range(vm.kind.phys_out * 2)}}
if vm.kind.name != 'basic':
params |= {**{f'ASIO INPUT SPINBOX||{i}': vm.patch.asio[i].get() for i in range(vm.kind.phys_out * 2)}}
for i in range(vm.kind.phys_out - 1):
target = getattr(vm.patch, f"A{i + 2}")
params |= {**{f"ASIO OUTPUT A{i + 2} SPINBOX||{j}": target[j].get() for j in range(vm.kind.num_bus)}}
target = getattr(vm.patch, f'A{i + 2}')
params |= {**{f'ASIO OUTPUT A{i + 2} SPINBOX||{j}': target[j].get() for j in range(vm.kind.num_bus)}}
return params
def _make_patch_insert_cache(vm) -> dict:
params = {}
if vm.kind.name != "basic":
params |= {**{f"INSERT CHECKBOX||{i}": vm.patch.insert[i].on for i in range(vm.kind.num_strip_levels)}}
if vm.kind.name != 'basic':
params |= {**{f'INSERT CHECKBOX||{i}': vm.patch.insert[i].on for i in range(vm.kind.num_strip_levels)}}
return params

4
src/nvda_voicemeeter/parser.py
View File

@ -4,10 +4,10 @@ from pyparsing import Group, OneOrMore, Optional, Suppress, Word, alphanums, res
class Parser:
def __init__(self):
self.widget = Group(OneOrMore(Word(alphanums)))
self.widget_token = Suppress("||")
self.widget_token = Suppress('||')
self.identifier = Group(OneOrMore(Word(alphanums)))
self.event = Group(OneOrMore(Word(alphanums)))
self.menu_token = Suppress("::")
self.menu_token = Suppress('::')
self.match = (
self.widget + self.widget_token + self.identifier + Optional(self.widget_token) + Optional(self.event)
| self.identifier + self.menu_token + self.event

648
src/nvda_voicemeeter/popup.py
View File

File diff suppressed because it is too large Load Diff

218
src/nvda_voicemeeter/util.py
View File

@ -18,9 +18,9 @@ def get_insert_checkbox_index(kind, channel, num) -> int:
_rejected_ids = (
"VBAudio100VMVAIO3",
"{F5735BD4-6EAF-4758-9710-9886E5AD0FF3}",
"{0239BE07-CEEF-4236-A900-AA778D432FD4}",
'VBAudio100VMVAIO3',
'{F5735BD4-6EAF-4758-9710-9886E5AD0FF3}',
'{0239BE07-CEEF-4236-A900-AA778D432FD4}',
)
@ -28,8 +28,8 @@ def get_input_device_list(vm) -> list:
devices = []
for j in range(vm.device.ins):
device = vm.device.input(j)
if device["id"] not in _rejected_ids:
devices.append("{type}: {name}".format(**device))
if device['id'] not in _rejected_ids:
devices.append('{type}: {name}'.format(**device))
return devices
@ -37,37 +37,37 @@ def get_output_device_list(i, vm) -> list:
devices = []
for j in range(vm.device.outs):
device = vm.device.output(j)
if device["id"] not in _rejected_ids:
devices.append("{type}: {name}".format(**device))
if device['id'] not in _rejected_ids:
devices.append('{type}: {name}'.format(**device))
if i == 0:
return devices
devices.append("- remove device selection -")
return [device for device in devices if not device.startswith("asio")]
devices.append('- remove device selection -')
return [device for device in devices if not device.startswith('asio')]
def get_patch_composite_list(kind) -> list:
temp = []
for i in range(kind.phys_out):
[temp.append(f"IN#{i + 1} {channel}") for channel in ("Left", "Right")]
[temp.append(f'IN#{i + 1} {channel}') for channel in ('Left', 'Right')]
for i in range(kind.phys_out, kind.phys_out + kind.virt_out):
[
temp.append(f"IN#{i + 1} {channel}")
for channel in ("Left", "Right", "Center", "LFE", "SL", "SR", "BL", "BR")
temp.append(f'IN#{i + 1} {channel}')
for channel in ('Left', 'Right', 'Center', 'LFE', 'SL', 'SR', 'BL', 'BR')
]
temp.append("BUS Channel")
temp.append('BUS Channel')
return temp
def get_patch_insert_channels() -> list:
return [
"left",
"right",
"center",
"low frequency effect",
"surround left",
"surround right",
"back left",
"back right",
'left',
'right',
'center',
'low frequency effect',
'surround left',
'surround right',
'back left',
'back right',
]
@ -75,8 +75,8 @@ _patch_insert_channels = get_patch_insert_channels()
def get_asio_samples_list(driver) -> list:
if driver == "MME":
samples = ["2048", "1536", "1024", "896", "768", "704", "640", "576", "512", "480", "441"]
if driver == 'MME':
samples = ['2048', '1536', '1024', '896', '768', '704', '640', '576', '512', '480', '441']
else:
# fmt: off
samples = [
@ -84,14 +84,14 @@ def get_asio_samples_list(driver) -> list:
"352", "320", "288", "256", "224", "192", "160", "128"
]
# fmt: on
if driver == "ASIO":
samples = [x for x in samples if x not in ("2048", "1536")]
samples.append("Default")
if driver == 'ASIO':
samples = [x for x in samples if x not in ('2048', '1536')]
samples.append('Default')
return samples
def get_tabs_labels() -> list:
return ["Settings", "Physical Strip", "Virtual Strip", "Buses"]
return ['Settings', 'Physical Strip', 'Virtual Strip', 'Buses']
def open_context_menu_for_buttonmenu(window, identifier) -> None:
@ -106,52 +106,52 @@ def get_channel_identifier_list(vm) -> list:
identifiers = []
for i in range(vm.kind.phys_in):
for j in range(2):
identifiers.append(f"IN{i + 1} {j}")
identifiers.append(f'IN{i + 1} {j}')
for i in range(vm.kind.phys_in, vm.kind.phys_in + vm.kind.virt_in):
for j in range(8):
identifiers.append(f"IN{i + 1} {j}")
identifiers.append(f'IN{i + 1} {j}')
return identifiers
_bus_mode_map = {
"normal": "Normal",
"amix": "Mix Down A",
"bmix": "Mix Down B",
"repeat": "Stereo Repeat",
"composite": "Composite",
"tvmix": "Up Mix TV",
"upmix21": "Up Mix 2.1",
"upmix41": "Up Mix 4.1",
"upmix61": "Up Mix 6.1",
"centeronly": "Center Only",
"lfeonly": "Low Frequency Effect Only",
"rearonly": "Rear Only",
'normal': 'Normal',
'amix': 'Mix Down A',
'bmix': 'Mix Down B',
'repeat': 'Stereo Repeat',
'composite': 'Composite',
'tvmix': 'Up Mix TV',
'upmix21': 'Up Mix 2.1',
'upmix41': 'Up Mix 4.1',
'upmix61': 'Up Mix 6.1',
'centeronly': 'Center Only',
'lfeonly': 'Low Frequency Effect Only',
'rearonly': 'Rear Only',
}
_bus_mode_map_reversed = dict((reversed(item) for item in _bus_mode_map.items()))
def get_bus_modes(vm) -> list:
if vm.kind.name == "basic":
if vm.kind.name == 'basic':
return [
"normal",
"amix",
"repeat",
"composite",
'normal',
'amix',
'repeat',
'composite',
]
return [
"normal",
"amix",
"bmix",
"repeat",
"composite",
"tvmix",
"upmix21",
"upmix41",
"upmix61",
"centeronly",
"lfeonly",
"rearonly",
'normal',
'amix',
'bmix',
'repeat',
'composite',
'tvmix',
'upmix21',
'upmix41',
'upmix61',
'centeronly',
'lfeonly',
'rearonly',
]
@ -166,77 +166,77 @@ def check_bounds(val, bounds: tuple) -> int | float:
def get_slider_params(i, kind) -> Iterable:
if i < kind.phys_in:
if kind.name == "basic":
return ("AUDIBILITY",)
if kind.name == "banana":
return ("COMP", "GATE")
if kind.name == "potato":
return ("COMP", "GATE", "DENOISER")
return ("BASS", "MID", "TREBLE")
if kind.name == 'basic':
return ('AUDIBILITY',)
if kind.name == 'banana':
return ('COMP', 'GATE')
if kind.name == 'potato':
return ('COMP', 'GATE', 'DENOISER')
return ('BASS', 'MID', 'TREBLE')
def get_full_slider_params(i, kind) -> Iterable:
params = list(get_slider_params(i, kind) + ("GAIN", "LIMIT"))
if kind.name == "basic":
params.remove("LIMIT")
params = list(get_slider_params(i, kind) + ('GAIN', 'LIMIT'))
if kind.name == 'basic':
params.remove('LIMIT')
return params
def get_slider_modes() -> Iterable:
return (
"GAIN MODE",
"BASS MODE",
"MID MODE",
"TREBLE MODE",
"AUDIBILITY MODE",
"COMP MODE",
"GATE MODE",
"DENOISER MODE",
"LIMIT MODE",
'GAIN MODE',
'BASS MODE',
'MID MODE',
'TREBLE MODE',
'AUDIBILITY MODE',
'COMP MODE',
'GATE MODE',
'DENOISER MODE',
'LIMIT MODE',
)
def _get_bus_assignments(kind) -> list:
return [f"A{i}" for i in range(1, kind.phys_out + 1)] + [f"B{i}" for i in range(1, kind.virt_out + 1)]
return [f'A{i}' for i in range(1, kind.phys_out + 1)] + [f'B{i}' for i in range(1, kind.virt_out + 1)]
psg.theme_add_new(
"HighContrast",
'HighContrast',
{
"BACKGROUND": "#FFFFFF",
"TEXT": "#000000",
"INPUT": "#FAF9F6",
"TEXT_INPUT": "#000000",
"SCROLL": "#FAF9F6",
"BUTTON": ("#000000", "#FFFFFF"),
"PROGRESS": ("#000000", "#FFFFFF"),
"BORDER": 2,
"SLIDER_DEPTH": 3,
"PROGRESS_DEPTH": 0,
'BACKGROUND': '#FFFFFF',
'TEXT': '#000000',
'INPUT': '#FAF9F6',
'TEXT_INPUT': '#000000',
'SCROLL': '#FAF9F6',
'BUTTON': ('#000000', '#FFFFFF'),
'PROGRESS': ('#000000', '#FFFFFF'),
'BORDER': 2,
'SLIDER_DEPTH': 3,
'PROGRESS_DEPTH': 0,
},
)
def get_themes_list() -> list:
return [
"Bright Colors",
"Dark Blue 14",
"Dark Brown 2",
"Dark Brown 3",
"Dark Green 2",
"Dark Grey 2",
"Dark Teal1",
"Dark Teal6",
"Kayak",
"Light Blue 2",
"Light Brown 2",
"Light Brown 5",
"Light Green",
"Light Green 3",
"Light Grey 2",
"Light Purple",
"Neutral Blue",
"Reds",
"Sandy Beach",
"High Contrast",
'Bright Colors',
'Dark Blue 14',
'Dark Brown 2',
'Dark Brown 3',
'Dark Green 2',
'Dark Grey 2',
'Dark Teal1',
'Dark Teal6',
'Kayak',
'Light Blue 2',
'Light Brown 2',
'Light Brown 5',
'Light Green',
'Light Green 3',
'Light Grey 2',
'Light Purple',
'Neutral Blue',
'Reds',
'Sandy Beach',
'High Contrast',
]

1092
src/nvda_voicemeeter/window.py
View File

File diff suppressed because it is too large Load Diff