diff --git a/src/nvda_voicemeeter/builder.py b/src/nvda_voicemeeter/builder.py index ffdf2b8..65edbae 100644 --- a/src/nvda_voicemeeter/builder.py +++ b/src/nvda_voicemeeter/builder.py @@ -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)] diff --git a/src/nvda_voicemeeter/compound.py b/src/nvda_voicemeeter/compound.py index 1f246f7..5c1a65c 100644 --- a/src/nvda_voicemeeter/compound.py +++ b/src/nvda_voicemeeter/compound.py @@ -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 = [ diff --git a/src/nvda_voicemeeter/configuration.py b/src/nvda_voicemeeter/configuration.py index 06f52c8..570d4d6 100644 --- a/src/nvda_voicemeeter/configuration.py +++ b/src/nvda_voicemeeter/configuration.py @@ -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) diff --git a/src/nvda_voicemeeter/errors.py b/src/nvda_voicemeeter/errors.py index a0b7ccc..134aed2 100644 --- a/src/nvda_voicemeeter/errors.py +++ b/src/nvda_voicemeeter/errors.py @@ -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}') diff --git a/src/nvda_voicemeeter/models.py b/src/nvda_voicemeeter/models.py index 6f04205..2f2a5e1 100644 --- a/src/nvda_voicemeeter/models.py +++ b/src/nvda_voicemeeter/models.py @@ -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 diff --git a/src/nvda_voicemeeter/parser.py b/src/nvda_voicemeeter/parser.py index b1ea9d9..4130f71 100644 --- a/src/nvda_voicemeeter/parser.py +++ b/src/nvda_voicemeeter/parser.py @@ -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 diff --git a/src/nvda_voicemeeter/popup.py b/src/nvda_voicemeeter/popup.py index 15eb29c..090ea45 100644 --- a/src/nvda_voicemeeter/popup.py +++ b/src/nvda_voicemeeter/popup.py @@ -19,101 +19,101 @@ class Popup: layout = [ [psg.Text(message)], [ - psg.FileSaveAs("Browse", initial_folder=str(initial_folder), file_types=(("XML", ".xml"),)), - psg.Button("Cancel"), + psg.FileSaveAs('Browse', initial_folder=str(initial_folder), file_types=(('XML', '.xml'),)), + psg.Button('Cancel'), ], ] popup = psg.Window(title, layout, finalize=True) - popup["Browse"].bind("", "||FOCUS IN") - popup["Browse"].bind("", "||KEY ENTER") - popup["Cancel"].bind("", "||FOCUS IN") - popup["Cancel"].bind("", "||KEY ENTER") + popup['Browse'].bind('', '||FOCUS IN') + popup['Browse'].bind('', '||KEY ENTER') + popup['Cancel'].bind('', '||FOCUS IN') + popup['Cancel'].bind('', '||KEY ENTER') filepath = None while True: event, values = popup.read() - self.logger.debug(f"event::{event}") - self.logger.debug(f"values::{values}") - if event in (psg.WIN_CLOSED, "Cancel"): + self.logger.debug(f'event::{event}') + self.logger.debug(f'values::{values}') + if event in (psg.WIN_CLOSED, 'Cancel'): break match parsed_cmd := self.window.parser.match.parseString(event): - case [[button], ["FOCUS", "IN"]]: - if values["Browse"]: - filepath = values["Browse"] + case [[button], ['FOCUS', 'IN']]: + if values['Browse']: + filepath = values['Browse'] break self.window.nvda.speak(button) - case [_, ["KEY", "ENTER"]]: + case [_, ['KEY', 'ENTER']]: popup.find_element_with_focus().click() - self.logger.debug(f"parsed::{parsed_cmd}") + self.logger.debug(f'parsed::{parsed_cmd}') popup.close() if filepath: return Path(filepath) def on_pdirty(self): - if self.popup.Title == "Advanced Settings": - if self.kind.name != "basic": - for key, value in self.window.cache["asio"].items(): - if "INPUT" in key: - identifier, i = key.split("||") + if self.popup.Title == 'Advanced Settings': + if self.kind.name != 'basic': + for key, value in self.window.cache['asio'].items(): + if 'INPUT' in key: + identifier, i = key.split('||') partial = util.get_channel_identifier_list(self.window.vm)[int(i)] - self.popup[f"{identifier}||{partial}"].update(value=value) - elif "OUTPUT" in key: + self.popup[f'{identifier}||{partial}'].update(value=value) + elif 'OUTPUT' in key: self.popup[key].update(value=value) - if self.popup.Title == "Advanced Compressor": - for param in ("RATIO", "THRESHOLD", "ATTACK", "RELEASE", "KNEE"): - self.popup[f"COMPRESSOR||SLIDER {param}"].update( + if self.popup.Title == 'Advanced Compressor': + for param in ('RATIO', 'THRESHOLD', 'ATTACK', 'RELEASE', 'KNEE'): + self.popup[f'COMPRESSOR||SLIDER {param}'].update( value=getattr(self.window.vm.strip[self.index].comp, param.lower()) ) - self.popup["COMPRESSOR||SLIDER INPUT GAIN"].update(value=self.window.vm.strip[self.index].comp.gainin) - self.popup["COMPRESSOR||SLIDER OUTPUT GAIN"].update(value=self.window.vm.strip[self.index].comp.gainout) - elif self.popup.Title == "Advanced Gate": - for param in ("THRESHOLD", "DAMPING", "BPSIDECHAIN", "ATTACK", "HOLD", "RELEASE"): - self.popup[f"GATE||SLIDER {param}"].update( + self.popup['COMPRESSOR||SLIDER INPUT GAIN'].update(value=self.window.vm.strip[self.index].comp.gainin) + self.popup['COMPRESSOR||SLIDER OUTPUT GAIN'].update(value=self.window.vm.strip[self.index].comp.gainout) + elif self.popup.Title == 'Advanced Gate': + for param in ('THRESHOLD', 'DAMPING', 'BPSIDECHAIN', 'ATTACK', 'HOLD', 'RELEASE'): + self.popup[f'GATE||SLIDER {param}'].update( value=getattr(self.window.vm.strip[self.index].gate, param.lower()) ) def rename(self, message, index, title=None, tab=None): - if "Strip" in tab: + if 'Strip' in tab: if index < self.kind.phys_in: - title += f" Physical Strip {index + 1}" + title += f' Physical Strip {index + 1}' else: - title += f" Virtual Strip {index - self.kind.phys_in + 1}" + title += f' Virtual Strip {index - self.kind.phys_in + 1}' else: if index < self.kind.phys_out: - title += f" Physical Bus {index + 1}" + title += f' Physical Bus {index + 1}' else: - title += f" Virtual Bus {index - self.kind.phys_out + 1}" + title += f' Virtual Bus {index - self.kind.phys_out + 1}' layout = [ [psg.Text(message)], [ [ - psg.Input(key="Edit"), + psg.Input(key='Edit'), ], - [psg.Button("Ok"), psg.Button("Cancel")], + [psg.Button('Ok'), psg.Button('Cancel')], ], ] popup = psg.Window(title, layout, finalize=True) - popup["Edit"].bind("", "||FOCUS IN") - popup["Ok"].bind("", "||FOCUS IN") - popup["Ok"].bind("", "||KEY ENTER") - popup["Cancel"].bind("", "||FOCUS IN") - popup["Cancel"].bind("", "||KEY ENTER") + popup['Edit'].bind('', '||FOCUS IN') + popup['Ok'].bind('', '||FOCUS IN') + popup['Ok'].bind('', '||KEY ENTER') + popup['Cancel'].bind('', '||FOCUS IN') + popup['Cancel'].bind('', '||KEY ENTER') data = {} while True: event, values = popup.read() - self.logger.debug(f"event::{event}") - self.logger.debug(f"values::{values}") - if event in (psg.WIN_CLOSED, "Cancel"): + self.logger.debug(f'event::{event}') + self.logger.debug(f'values::{values}') + if event in (psg.WIN_CLOSED, 'Cancel'): break match parsed_cmd := self.window.parser.match.parseString(event): - case [[button], ["FOCUS", "IN"]]: + case [[button], ['FOCUS', 'IN']]: self.window.nvda.speak(button) - case [_, ["KEY", "ENTER"]]: + case [_, ['KEY', 'ENTER']]: popup.find_element_with_focus().click() - case ["Ok"]: + case ['Ok']: data = values break - self.logger.debug(f"parsed::{parsed_cmd}") + self.logger.debug(f'parsed::{parsed_cmd}') popup.close() return data @@ -124,12 +124,12 @@ class Popup: [ psg.Spin( nums, - initial_value=self.window.cache["asio"][ - f"ASIO INPUT SPINBOX||{util.get_asio_input_spinbox_index(0, i)}" + initial_value=self.window.cache['asio'][ + f'ASIO INPUT SPINBOX||{util.get_asio_input_spinbox_index(0, i)}' ], size=2, enable_events=True, - key=f"ASIO INPUT SPINBOX||IN{i} 0", + key=f'ASIO INPUT SPINBOX||IN{i} 0', ) ], ) @@ -137,12 +137,12 @@ class Popup: [ psg.Spin( nums, - initial_value=self.window.cache["asio"][ - f"ASIO INPUT SPINBOX||{util.get_asio_input_spinbox_index(1, i)}" + initial_value=self.window.cache['asio'][ + f'ASIO INPUT SPINBOX||{util.get_asio_input_spinbox_index(1, i)}' ], size=2, enable_events=True, - key=f"ASIO INPUT SPINBOX||IN{i} 1", + key=f'ASIO INPUT SPINBOX||IN{i} 1', ) ], ) @@ -153,10 +153,10 @@ class Popup: [ psg.Spin( nums, - initial_value=self.window.cache["asio"][f"ASIO OUTPUT A{i} SPINBOX||{j}"], + initial_value=self.window.cache['asio'][f'ASIO OUTPUT A{i} SPINBOX||{j}'], size=2, enable_events=True, - key=f"ASIO OUTPUT A{i} SPINBOX||{j}", + key=f'ASIO OUTPUT A{i} SPINBOX||{j}', ) for j in range(self.kind.num_bus) ], @@ -168,113 +168,113 @@ class Popup: psg.ButtonMenu( driver, size=(14, 2), - menu_def=["", util.get_asio_samples_list(driver)], - key=f"BUFFER {driver}", + menu_def=['', util.get_asio_samples_list(driver)], + key=f'BUFFER {driver}', ) - for driver in ("MME", "WDM", "KS", "ASIO") + for driver in ('MME', 'WDM', 'KS', 'ASIO') ], ] - return psg.Frame("BUFFERING", buffer) + return psg.Frame('BUFFERING', buffer) layout = [] - if self.kind.name != "basic": + if self.kind.name != 'basic': inner = [] patch_input_to_strips = ([] for _ in range(self.kind.phys_in)) for i, checkbox_list in enumerate(patch_input_to_strips): [step(checkbox_list, i + 1) for step in (add_patch_asio_input_to_strips,)] - inner.append(psg.Frame(f"In#{i + 1}", checkbox_list)) - layout.append([psg.Frame("PATCH ASIO Inputs to Strips", [inner])]) + inner.append(psg.Frame(f'In#{i + 1}', checkbox_list)) + layout.append([psg.Frame('PATCH ASIO Inputs to Strips', [inner])]) inner_2 = [] patch_output_to_bus = ([] for _ in range(self.kind.phys_out - 1)) for i, checkbox_list in enumerate(patch_output_to_bus): [step(checkbox_list, i + 2) for step in (add_patch_bus_to_asio_outputs,)] - inner_2.append([psg.Frame(f"OutA{i + 2}", checkbox_list)]) - layout.append([psg.Frame("PATCH BUS to A1 ASIO Outputs", [*inner_2])]) + inner_2.append([psg.Frame(f'OutA{i + 2}', checkbox_list)]) + layout.append([psg.Frame('PATCH BUS to A1 ASIO Outputs', [*inner_2])]) steps = (_make_buffering_frame,) for step in steps: layout.append([step()]) - layout.append([psg.Button("Exit", size=(8, 2))]) + layout.append([psg.Button('Exit', size=(8, 2))]) self.popup = psg.Window(title, layout, finalize=True) - if self.kind.name != "basic": + if self.kind.name != 'basic': for i in range(self.kind.phys_out): - self.popup[f"ASIO INPUT SPINBOX||IN{i + 1} 0"].Widget.config(state="readonly") - self.popup[f"ASIO INPUT SPINBOX||IN{i + 1} 1"].Widget.config(state="readonly") + self.popup[f'ASIO INPUT SPINBOX||IN{i + 1} 0'].Widget.config(state='readonly') + self.popup[f'ASIO INPUT SPINBOX||IN{i + 1} 1'].Widget.config(state='readonly') for i in range(self.kind.phys_out - 1): for j in range(self.kind.num_bus): - self.popup[f"ASIO OUTPUT A{i + 2} SPINBOX||{j}"].Widget.config(state="readonly") - if self.kind.name != "basic": + self.popup[f'ASIO OUTPUT A{i + 2} SPINBOX||{j}'].Widget.config(state='readonly') + if self.kind.name != 'basic': for i in range(self.kind.phys_out): - self.popup[f"ASIO INPUT SPINBOX||IN{i + 1} 0"].bind("", "||FOCUS IN") - self.popup[f"ASIO INPUT SPINBOX||IN{i + 1} 1"].bind("", "||FOCUS IN") + self.popup[f'ASIO INPUT SPINBOX||IN{i + 1} 0'].bind('', '||FOCUS IN') + self.popup[f'ASIO INPUT SPINBOX||IN{i + 1} 1'].bind('', '||FOCUS IN') for i in range(self.kind.phys_out - 1): for j in range(self.kind.num_bus): - self.popup[f"ASIO OUTPUT A{i + 2} SPINBOX||{j}"].bind("", "||FOCUS IN") - buttonmenu_opts = {"takefocus": 1, "highlightthickness": 1} - for driver in ("MME", "WDM", "KS", "ASIO"): - self.popup[f"BUFFER {driver}"].Widget.config(**buttonmenu_opts) - self.popup[f"BUFFER {driver}"].bind("", "||FOCUS IN") - self.popup[f"BUFFER {driver}"].bind("", "||KEY SPACE", propagate=False) - self.popup[f"BUFFER {driver}"].bind("", "||KEY ENTER", propagate=False) - self.popup["Exit"].bind("", "||FOCUS IN") - self.popup["Exit"].bind("", "||KEY ENTER") + self.popup[f'ASIO OUTPUT A{i + 2} SPINBOX||{j}'].bind('', '||FOCUS IN') + buttonmenu_opts = {'takefocus': 1, 'highlightthickness': 1} + for driver in ('MME', 'WDM', 'KS', 'ASIO'): + self.popup[f'BUFFER {driver}'].Widget.config(**buttonmenu_opts) + self.popup[f'BUFFER {driver}'].bind('', '||FOCUS IN') + self.popup[f'BUFFER {driver}'].bind('', '||KEY SPACE', propagate=False) + self.popup[f'BUFFER {driver}'].bind('', '||KEY ENTER', propagate=False) + self.popup['Exit'].bind('', '||FOCUS IN') + self.popup['Exit'].bind('', '||KEY ENTER') self.window.vm.observer.add(self.on_pdirty) while True: event, values = self.popup.read() - self.logger.debug(f"event::{event}") - self.logger.debug(f"values::{values}") - if event in (psg.WIN_CLOSED, "Exit"): + self.logger.debug(f'event::{event}') + self.logger.debug(f'values::{values}') + if event in (psg.WIN_CLOSED, 'Exit'): break match parsed_cmd := self.window.parser.match.parseString(event): - case [["ASIO", "INPUT", "SPINBOX"], [in_num, channel]]: + case [['ASIO', 'INPUT', 'SPINBOX'], [in_num, channel]]: index = util.get_asio_input_spinbox_index(int(channel), int(in_num[-1])) - val = values[f"ASIO INPUT SPINBOX||{in_num} {channel}"] + val = values[f'ASIO INPUT SPINBOX||{in_num} {channel}'] self.window.vm.patch.asio[index].set(val) - channel = ("left", "right")[int(channel)] + channel = ('left', 'right')[int(channel)] self.window.nvda.speak(str(val)) - case [["ASIO", "INPUT", "SPINBOX"], [in_num, channel], ["FOCUS", "IN"]]: + case [['ASIO', 'INPUT', 'SPINBOX'], [in_num, channel], ['FOCUS', 'IN']]: if self.popup.find_element_with_focus() is not None: - val = values[f"ASIO INPUT SPINBOX||{in_num} {channel}"] - channel = ("left", "right")[int(channel)] + val = values[f'ASIO INPUT SPINBOX||{in_num} {channel}'] + channel = ('left', 'right')[int(channel)] num = int(in_num[-1]) - self.window.nvda.speak(f"Patch ASIO inputs to strips IN#{num} {channel} {val}") - case [["ASIO", "OUTPUT", param, "SPINBOX"], [index]]: + self.window.nvda.speak(f'Patch ASIO inputs to strips IN#{num} {channel} {val}') + case [['ASIO', 'OUTPUT', param, 'SPINBOX'], [index]]: target = getattr(self.window.vm.patch, param)[int(index)] target.set(values[event]) self.window.nvda.speak(str(values[event])) - case [["ASIO", "OUTPUT", param, "SPINBOX"], [index], ["FOCUS", "IN"]]: + case [['ASIO', 'OUTPUT', param, 'SPINBOX'], [index], ['FOCUS', 'IN']]: if self.popup.find_element_with_focus() is not None: - val = values[f"ASIO OUTPUT {param} SPINBOX||{index}"] + val = values[f'ASIO OUTPUT {param} SPINBOX||{index}'] self.window.nvda.speak( - f"Patch BUS to A1 ASIO Outputs OUT {param} channel {int(index) + 1} {val}" + f'Patch BUS to A1 ASIO Outputs OUT {param} channel {int(index) + 1} {val}' ) - case ["BUFFER MME" | "BUFFER WDM" | "BUFFER KS" | "BUFFER ASIO"]: - if values[event] == "Default": - if "MME" in event: + case ['BUFFER MME' | 'BUFFER WDM' | 'BUFFER KS' | 'BUFFER ASIO']: + if values[event] == 'Default': + if 'MME' in event: val = 1024 - elif "WDM" in event or "KS" in event: + elif 'WDM' in event or 'KS' in event: val = 512 else: val = 0 else: val = int(values[event]) driver = event.split()[1] - self.window.vm.set(f"option.buffer.{driver.lower()}", val) + self.window.vm.set(f'option.buffer.{driver.lower()}', val) self.window.TKroot.after( - 200, self.window.nvda.speak, f"{driver} BUFFER {val if val else 'default'}" + 200, self.window.nvda.speak, f'{driver} BUFFER {val if val else "default"}' ) - case [["BUFFER", driver], ["FOCUS", "IN"]]: - val = int(self.window.vm.get(f"option.buffer.{driver.lower()}")) - self.window.nvda.speak(f"{driver} BUFFER {val if val else 'default'}") - case [["BUFFER", driver], ["KEY", "SPACE" | "ENTER"]]: - util.open_context_menu_for_buttonmenu(self.popup, f"BUFFER {driver}") - case [[button], ["FOCUS", "IN"]]: + case [['BUFFER', driver], ['FOCUS', 'IN']]: + val = int(self.window.vm.get(f'option.buffer.{driver.lower()}')) + self.window.nvda.speak(f'{driver} BUFFER {val if val else "default"}') + case [['BUFFER', driver], ['KEY', 'SPACE' | 'ENTER']]: + util.open_context_menu_for_buttonmenu(self.popup, f'BUFFER {driver}') + case [[button], ['FOCUS', 'IN']]: self.window.nvda.speak(button) - case [_, ["KEY", "ENTER"]]: + case [_, ['KEY', 'ENTER']]: self.popup.find_element_with_focus().click() - self.logger.debug(f"parsed::{parsed_cmd}") + self.logger.debug(f'parsed::{parsed_cmd}') self.window.vm.observer.remove(self.on_pdirty) self.popup.close() @@ -284,75 +284,75 @@ class Popup: def _make_comp_frame() -> psg.Frame: comp_layout = [ [LabelSliderAdvanced(self.window, index, param, CompSlider)] - for param in ("INPUT GAIN", "RATIO", "THRESHOLD", "ATTACK", "RELEASE", "KNEE", "OUTPUT GAIN") + for param in ('INPUT GAIN', 'RATIO', 'THRESHOLD', 'ATTACK', 'RELEASE', 'KNEE', 'OUTPUT GAIN') ] - return psg.Frame("ADVANCED COMPRESSOR", comp_layout) + return psg.Frame('ADVANCED COMPRESSOR', comp_layout) layout = [] steps = (_make_comp_frame,) for step in steps: layout.append([step()]) - layout.append([psg.Button("MAKEUP", size=(12, 1)), psg.Button("Exit", size=(8, 1))]) + layout.append([psg.Button('MAKEUP', size=(12, 1)), psg.Button('Exit', size=(8, 1))]) self.popup = psg.Window(title, layout, return_keyboard_events=False, finalize=True) - buttonmenu_opts = {"takefocus": 1, "highlightthickness": 1} - for param in ("INPUT GAIN", "RATIO", "THRESHOLD", "ATTACK", "RELEASE", "KNEE", "OUTPUT GAIN"): - self.popup[f"COMPRESSOR||SLIDER {param}"].Widget.config(**buttonmenu_opts) - self.popup[f"COMPRESSOR||SLIDER {param}"].bind("", "||FOCUS IN") - self.popup[f"COMPRESSOR||SLIDER {param}"].bind("", "||FOCUS OUT") - for event in ("KeyPress", "KeyRelease"): - event_id = event.removeprefix("Key").upper() - for direction in ("Left", "Right", "Up", "Down"): - self.popup[f"COMPRESSOR||SLIDER {param}"].bind( - f"<{event}-{direction}>", f"||KEY {direction.upper()} {event_id}" + buttonmenu_opts = {'takefocus': 1, 'highlightthickness': 1} + for param in ('INPUT GAIN', 'RATIO', 'THRESHOLD', 'ATTACK', 'RELEASE', 'KNEE', 'OUTPUT GAIN'): + self.popup[f'COMPRESSOR||SLIDER {param}'].Widget.config(**buttonmenu_opts) + self.popup[f'COMPRESSOR||SLIDER {param}'].bind('', '||FOCUS IN') + self.popup[f'COMPRESSOR||SLIDER {param}'].bind('', '||FOCUS OUT') + for event in ('KeyPress', 'KeyRelease'): + event_id = event.removeprefix('Key').upper() + for direction in ('Left', 'Right', 'Up', 'Down'): + self.popup[f'COMPRESSOR||SLIDER {param}'].bind( + f'<{event}-{direction}>', f'||KEY {direction.upper()} {event_id}' ) - self.popup[f"COMPRESSOR||SLIDER {param}"].bind( - f"", f"||KEY SHIFT {direction.upper()} {event_id}" + self.popup[f'COMPRESSOR||SLIDER {param}'].bind( + f'', f'||KEY SHIFT {direction.upper()} {event_id}' ) - self.popup[f"COMPRESSOR||SLIDER {param}"].bind( - f"", f"||KEY CTRL {direction.upper()} {event_id}" + self.popup[f'COMPRESSOR||SLIDER {param}'].bind( + f'', f'||KEY CTRL {direction.upper()} {event_id}' ) - if param == "RELEASE": - self.popup[f"COMPRESSOR||SLIDER {param}"].bind( - f"", f"||KEY ALT {direction.upper()} {event_id}" + if param == 'RELEASE': + self.popup[f'COMPRESSOR||SLIDER {param}'].bind( + f'', f'||KEY ALT {direction.upper()} {event_id}' ) - self.popup[f"COMPRESSOR||SLIDER {param}"].bind( - f"", f"||KEY CTRL ALT {direction.upper()} {event_id}" + self.popup[f'COMPRESSOR||SLIDER {param}'].bind( + f'', f'||KEY CTRL ALT {direction.upper()} {event_id}' ) - self.popup[f"COMPRESSOR||SLIDER {param}"].bind("", "||KEY CTRL SHIFT R") - self.popup["MAKEUP"].bind("", "||FOCUS IN") - self.popup["MAKEUP"].bind("", "||KEY ENTER") - self.popup["Exit"].bind("", "||FOCUS IN") - self.popup["Exit"].bind("", "||KEY ENTER") + self.popup[f'COMPRESSOR||SLIDER {param}'].bind('', '||KEY CTRL SHIFT R') + self.popup['MAKEUP'].bind('', '||FOCUS IN') + self.popup['MAKEUP'].bind('', '||KEY ENTER') + self.popup['Exit'].bind('', '||FOCUS IN') + self.popup['Exit'].bind('', '||KEY ENTER') self.window.vm.observer.add(self.on_pdirty) while True: event, values = self.popup.read() - self.logger.debug(f"event::{event}") - self.logger.debug(f"values::{values}") - if event in (psg.WIN_CLOSED, "Exit"): + self.logger.debug(f'event::{event}') + self.logger.debug(f'values::{values}') + if event in (psg.WIN_CLOSED, 'Exit'): break match parsed_cmd := self.window.parser.match.parseString(event): - case [["COMPRESSOR"], ["SLIDER", param]]: + case [['COMPRESSOR'], ['SLIDER', param]]: setattr(self.window.vm.strip[index].comp, param.lower(), values[event]) - case [["COMPRESSOR"], ["SLIDER", param], ["FOCUS", "IN"]]: - self.window.nvda.speak(f"{param} {values[f'COMPRESSOR||SLIDER {param}']}") + case [['COMPRESSOR'], ['SLIDER', param], ['FOCUS', 'IN']]: + self.window.nvda.speak(f'{param} {values[f"COMPRESSOR||SLIDER {param}"]}') case [ - ["COMPRESSOR"], - ["SLIDER", param], - ["KEY", "LEFT" | "RIGHT" | "UP" | "DOWN" as input_direction, "PRESS" | "RELEASE" as e], + ['COMPRESSOR'], + ['SLIDER', param], + ['KEY', 'LEFT' | 'RIGHT' | 'UP' | 'DOWN' as input_direction, 'PRESS' | 'RELEASE' as e], ]: - if e == "PRESS": + if e == 'PRESS': self.window.vm.event.pdirty = False val = getattr(self.window.vm.strip[index].comp, param.lower()) match input_direction: - case "RIGHT" | "UP": - if param == "KNEE": + case 'RIGHT' | 'UP': + if param == 'KNEE': val += 0.1 else: val += 1 - case "LEFT" | "DOWN": - if param == "KNEE": + case 'LEFT' | 'DOWN': + if param == 'KNEE': val -= 0.1 else: val -= 1 @@ -360,34 +360,34 @@ class Popup: val = CompSlider.check_bounds(param, val) setattr(self.window.vm.strip[index].comp, param.lower(), val) - self.popup[f"COMPRESSOR||SLIDER {param}"].update(value=val) - if param == "KNEE": + self.popup[f'COMPRESSOR||SLIDER {param}'].update(value=val) + if param == 'KNEE': self.window.nvda.speak(str(round(val, 2))) else: self.window.nvda.speak(str(round(val, 1))) else: self.window.vm.event.pdirty = True case [ - ["COMPRESSOR"], - ["SLIDER", param], - ["KEY", "CTRL", "LEFT" | "RIGHT" | "UP" | "DOWN" as input_direction, "PRESS" | "RELEASE" as e], + ['COMPRESSOR'], + ['SLIDER', param], + ['KEY', 'CTRL', 'LEFT' | 'RIGHT' | 'UP' | 'DOWN' as input_direction, 'PRESS' | 'RELEASE' as e], ]: - if e == "PRESS": + if e == 'PRESS': self.window.vm.event.pdirty = False val = getattr(self.window.vm.strip[index].comp, param.lower()) match input_direction: - case "RIGHT" | "UP": - if param == "KNEE": + case 'RIGHT' | 'UP': + if param == 'KNEE': val += 0.3 - elif param == "RELEASE": + elif param == 'RELEASE': val += 5 else: val += 3 - case "LEFT" | "DOWN": - if param == "KNEE": + case 'LEFT' | 'DOWN': + if param == 'KNEE': val -= 0.3 - elif param == "RELEASE": + elif param == 'RELEASE': val -= 5 else: val -= 3 @@ -395,30 +395,30 @@ class Popup: val = CompSlider.check_bounds(param, val) setattr(self.window.vm.strip[index].comp, param.lower(), val) - self.popup[f"COMPRESSOR||SLIDER {param}"].update(value=val) - if param == "KNEE": + self.popup[f'COMPRESSOR||SLIDER {param}'].update(value=val) + if param == 'KNEE': self.window.nvda.speak(str(round(val, 2))) else: self.window.nvda.speak(str(round(val, 1))) else: self.window.vm.event.pdirty = True case [ - ["COMPRESSOR"], - ["SLIDER", param], - ["KEY", "SHIFT", "LEFT" | "RIGHT" | "UP" | "DOWN" as input_direction, "PRESS" | "RELEASE" as e], + ['COMPRESSOR'], + ['SLIDER', param], + ['KEY', 'SHIFT', 'LEFT' | 'RIGHT' | 'UP' | 'DOWN' as input_direction, 'PRESS' | 'RELEASE' as e], ]: - if e == "PRESS": + if e == 'PRESS': self.window.vm.event.pdirty = False val = getattr(self.window.vm.strip[index].comp, param.lower()) match input_direction: - case "RIGHT" | "UP": - if param == "KNEE": + case 'RIGHT' | 'UP': + if param == 'KNEE': val += 0.01 else: val += 0.1 - case "LEFT" | "DOWN": - if param == "KNEE": + case 'LEFT' | 'DOWN': + if param == 'KNEE': val -= 0.01 else: val -= 0.1 @@ -426,187 +426,187 @@ class Popup: val = CompSlider.check_bounds(param, val) setattr(self.window.vm.strip[index].comp, param.lower(), val) - self.popup[f"COMPRESSOR||SLIDER {param}"].update(value=val) - if param == "KNEE": + self.popup[f'COMPRESSOR||SLIDER {param}'].update(value=val) + if param == 'KNEE': self.window.nvda.speak(str(round(val, 2))) else: self.window.nvda.speak(str(round(val, 1))) else: self.window.vm.event.pdirty = True case [ - ["COMPRESSOR"], - ["SLIDER", "RELEASE"], - ["KEY", "ALT", "LEFT" | "RIGHT" as input_direction, "PRESS" | "RELEASE" as e], + ['COMPRESSOR'], + ['SLIDER', 'RELEASE'], + ['KEY', 'ALT', 'LEFT' | 'RIGHT' as input_direction, 'PRESS' | 'RELEASE' as e], ]: - if e == "PRESS": + if e == 'PRESS': self.window.vm.event.pdirty = False val = self.window.vm.strip[index].comp.release match input_direction: - case "RIGHT" | "UP": + case 'RIGHT' | 'UP': val += 10 - case "LEFT" | "DOWN": + case 'LEFT' | 'DOWN': val -= 10 val = util.check_bounds(val, (0, 5000)) self.window.vm.strip[index].comp.release = val - self.popup[f"COMPRESSOR||SLIDER {param}"].update(value=val) + self.popup[f'COMPRESSOR||SLIDER {param}'].update(value=val) self.window.nvda.speak(str(round(val, 1))) else: self.window.vm.event.pdirty = True case [ - ["COMPRESSOR"], - ["SLIDER", "RELEASE"], - ["KEY", "CTRL", "ALT", "LEFT" | "RIGHT" as input_direction, "PRESS" | "RELEASE" as e], + ['COMPRESSOR'], + ['SLIDER', 'RELEASE'], + ['KEY', 'CTRL', 'ALT', 'LEFT' | 'RIGHT' as input_direction, 'PRESS' | 'RELEASE' as e], ]: - if e == "PRESS": + if e == 'PRESS': self.window.vm.event.pdirty = False val = self.window.vm.strip[index].comp.release match input_direction: - case "RIGHT" | "UP": + case 'RIGHT' | 'UP': val += 50 - case "LEFT" | "DOWN": + case 'LEFT' | 'DOWN': val -= 50 val = util.check_bounds(val, (0, 5000)) self.window.vm.strip[index].comp.release = val - self.popup[f"COMPRESSOR||SLIDER {param}"].update(value=val) + self.popup[f'COMPRESSOR||SLIDER {param}'].update(value=val) self.window.nvda.speak(str(round(val, 1))) else: self.window.vm.event.pdirty = True - case [["COMPRESSOR"], ["SLIDER", "INPUT" | "OUTPUT" as direction, "GAIN"]]: - if direction == "INPUT": + case [['COMPRESSOR'], ['SLIDER', 'INPUT' | 'OUTPUT' as direction, 'GAIN']]: + if direction == 'INPUT': self.window.vm.strip[index].comp.gainin = values[event] else: self.window.vm.strip[index].comp.gainout = values[event] - case [["COMPRESSOR"], ["SLIDER", "INPUT" | "OUTPUT" as direction, "GAIN"], ["FOCUS", "IN"]]: - label = f"{direction} GAIN" - self.window.nvda.speak(f"{label} {values[f'COMPRESSOR||SLIDER {label}']}") + case [['COMPRESSOR'], ['SLIDER', 'INPUT' | 'OUTPUT' as direction, 'GAIN'], ['FOCUS', 'IN']]: + label = f'{direction} GAIN' + self.window.nvda.speak(f'{label} {values[f"COMPRESSOR||SLIDER {label}"]}') case [ - ["COMPRESSOR"], - ["SLIDER", "INPUT" | "OUTPUT" as direction, "GAIN"], - ["KEY", "LEFT" | "RIGHT" | "UP" | "DOWN" as input_direction, "PRESS" | "RELEASE" as e], + ['COMPRESSOR'], + ['SLIDER', 'INPUT' | 'OUTPUT' as direction, 'GAIN'], + ['KEY', 'LEFT' | 'RIGHT' | 'UP' | 'DOWN' as input_direction, 'PRESS' | 'RELEASE' as e], ]: - if e == "PRESS": + if e == 'PRESS': self.window.vm.event.pdirty = False - if direction == "INPUT": + if direction == 'INPUT': val = self.window.vm.strip[index].comp.gainin else: val = self.window.vm.strip[index].comp.gainout match input_direction: - case "RIGHT" | "UP": + case 'RIGHT' | 'UP': val += 1 - case "LEFT" | "DOWN": + case 'LEFT' | 'DOWN': val -= 1 val = util.check_bounds(val, (-24, 24)) - if direction == "INPUT": + if direction == 'INPUT': self.window.vm.strip[index].comp.gainin = val else: self.window.vm.strip[index].comp.gainout = val - self.popup[f"COMPRESSOR||SLIDER {direction} GAIN"].update(value=val) + self.popup[f'COMPRESSOR||SLIDER {direction} GAIN'].update(value=val) self.window.nvda.speak(str(round(val, 1))) else: self.window.vm.event.pdirty = True case [ - ["COMPRESSOR"], - ["SLIDER", "INPUT" | "OUTPUT" as direction, "GAIN"], - ["KEY", "CTRL", "LEFT" | "RIGHT" | "UP" | "DOWN" as input_direction, "PRESS" | "RELEASE" as e], + ['COMPRESSOR'], + ['SLIDER', 'INPUT' | 'OUTPUT' as direction, 'GAIN'], + ['KEY', 'CTRL', 'LEFT' | 'RIGHT' | 'UP' | 'DOWN' as input_direction, 'PRESS' | 'RELEASE' as e], ]: - if e == "PRESS": + if e == 'PRESS': self.window.vm.event.pdirty = False - if direction == "INPUT": + if direction == 'INPUT': val = self.window.vm.strip[index].comp.gainin else: val = self.window.vm.strip[index].comp.gainout match input_direction: - case "RIGHT" | "UP": + case 'RIGHT' | 'UP': val += 3 - case "LEFT" | "DOWN": + case 'LEFT' | 'DOWN': val -= 3 val = util.check_bounds(val, (-24, 24)) - if direction == "INPUT": + if direction == 'INPUT': self.window.vm.strip[index].comp.gainin = val else: self.window.vm.strip[index].comp.gainout = val - self.popup[f"COMPRESSOR||SLIDER {direction} GAIN"].update(value=val) + self.popup[f'COMPRESSOR||SLIDER {direction} GAIN'].update(value=val) self.window.nvda.speak(str(round(val, 1))) else: self.window.vm.event.pdirty = True case [ - ["COMPRESSOR"], - ["SLIDER", "INPUT" | "OUTPUT" as direction, "GAIN"], - ["KEY", "SHIFT", "LEFT" | "RIGHT" | "UP" | "DOWN" as input_direction, "PRESS" | "RELEASE" as e], + ['COMPRESSOR'], + ['SLIDER', 'INPUT' | 'OUTPUT' as direction, 'GAIN'], + ['KEY', 'SHIFT', 'LEFT' | 'RIGHT' | 'UP' | 'DOWN' as input_direction, 'PRESS' | 'RELEASE' as e], ]: - if e == "PRESS": + if e == 'PRESS': self.window.vm.event.pdirty = False - if direction == "INPUT": + if direction == 'INPUT': val = self.window.vm.strip[index].comp.gainin else: val = self.window.vm.strip[index].comp.gainout match input_direction: - case "RIGHT" | "UP": + case 'RIGHT' | 'UP': val += 0.1 - case "LEFT" | "DOWN": + case 'LEFT' | 'DOWN': val -= 0.1 val = util.check_bounds(val, (-24, 24)) - if direction == "INPUT": + if direction == 'INPUT': self.window.vm.strip[index].comp.gainin = val else: self.window.vm.strip[index].comp.gainout = val - self.popup[f"COMPRESSOR||SLIDER {direction} GAIN"].update(value=val) + self.popup[f'COMPRESSOR||SLIDER {direction} GAIN'].update(value=val) self.window.nvda.speak(str(round(val, 1))) else: self.window.vm.event.pdirty = True case [ - ["COMPRESSOR"], - ["SLIDER", "INPUT" | "OUTPUT" as direction, "GAIN"], - ["KEY", "CTRL", "SHIFT", "R"], + ['COMPRESSOR'], + ['SLIDER', 'INPUT' | 'OUTPUT' as direction, 'GAIN'], + ['KEY', 'CTRL', 'SHIFT', 'R'], ]: - if direction == "INPUT": + if direction == 'INPUT': self.window.vm.strip[index].comp.gainin = 0 else: self.window.vm.strip[index].comp.gainout = 0 - self.popup[f"COMPRESSOR||SLIDER {direction} GAIN"].update(value=0) + self.popup[f'COMPRESSOR||SLIDER {direction} GAIN'].update(value=0) self.window.nvda.speak(str(0)) - case [["COMPRESSOR"], ["SLIDER", param], ["KEY", "CTRL", "SHIFT", "R"]]: + case [['COMPRESSOR'], ['SLIDER', param], ['KEY', 'CTRL', 'SHIFT', 'R']]: match param: - case "RATIO": + case 'RATIO': val = 1 - case "THRESHOLD": + case 'THRESHOLD': val = -20 - case "ATTACK": + case 'ATTACK': val = 10 - case "RELEASE": + case 'RELEASE': val = 50 - case "KNEE": + case 'KNEE': val = 0.5 setattr(self.window.vm.strip[index].comp, param.lower(), val) - self.popup[f"COMPRESSOR||SLIDER {param}"].update(value=val) + self.popup[f'COMPRESSOR||SLIDER {param}'].update(value=val) self.window.nvda.speak(str(round(val, 1))) - case ["MAKEUP"]: + case ['MAKEUP']: val = not self.window.vm.strip[index].comp.makeup self.window.vm.strip[index].comp.makeup = val - self.window.nvda.speak("on" if val else "off") - case [[button], ["FOCUS", "IN"]]: - if button == "MAKEUP": + self.window.nvda.speak('on' if val else 'off') + case [[button], ['FOCUS', 'IN']]: + if button == 'MAKEUP': self.window.nvda.speak( - f"{button} {'on' if self.window.vm.strip[index].comp.makeup else 'off'}" + f'{button} {"on" if self.window.vm.strip[index].comp.makeup else "off"}' ) else: self.window.nvda.speak(button) - case [_, ["KEY", "ENTER"]]: + case [_, ['KEY', 'ENTER']]: self.popup.find_element_with_focus().click() - self.logger.debug(f"parsed::{parsed_cmd}") + self.logger.debug(f'parsed::{parsed_cmd}') self.window.vm.observer.remove(self.on_pdirty) self.popup.close() @@ -616,207 +616,207 @@ class Popup: def _make_gate_frame() -> psg.Frame: gate_layout = [ [LabelSliderAdvanced(self.window, index, param, GateSlider)] - for param in ("THRESHOLD", "DAMPING", "BPSIDECHAIN", "ATTACK", "HOLD", "RELEASE") + for param in ('THRESHOLD', 'DAMPING', 'BPSIDECHAIN', 'ATTACK', 'HOLD', 'RELEASE') ] - return psg.Frame("ADVANCED GATE", gate_layout) + return psg.Frame('ADVANCED GATE', gate_layout) layout = [] steps = (_make_gate_frame,) for step in steps: layout.append([step()]) - layout.append([psg.Button("Exit", size=(8, 1))]) + layout.append([psg.Button('Exit', size=(8, 1))]) self.popup = psg.Window(title, layout, return_keyboard_events=False, finalize=True) - buttonmenu_opts = {"takefocus": 1, "highlightthickness": 1} - for param in ("THRESHOLD", "DAMPING", "BPSIDECHAIN", "ATTACK", "HOLD", "RELEASE"): - self.popup[f"GATE||SLIDER {param}"].Widget.config(**buttonmenu_opts) - self.popup[f"GATE||SLIDER {param}"].bind("", "||FOCUS IN") - self.popup[f"GATE||SLIDER {param}"].bind("", "||FOCUS OUT") - for event in ("KeyPress", "KeyRelease"): - event_id = event.removeprefix("Key").upper() - for direction in ("Left", "Right", "Up", "Down"): - self.popup[f"GATE||SLIDER {param}"].bind( - f"<{event}-{direction}>", f"||KEY {direction.upper()} {event_id}" + buttonmenu_opts = {'takefocus': 1, 'highlightthickness': 1} + for param in ('THRESHOLD', 'DAMPING', 'BPSIDECHAIN', 'ATTACK', 'HOLD', 'RELEASE'): + self.popup[f'GATE||SLIDER {param}'].Widget.config(**buttonmenu_opts) + self.popup[f'GATE||SLIDER {param}'].bind('', '||FOCUS IN') + self.popup[f'GATE||SLIDER {param}'].bind('', '||FOCUS OUT') + for event in ('KeyPress', 'KeyRelease'): + event_id = event.removeprefix('Key').upper() + for direction in ('Left', 'Right', 'Up', 'Down'): + self.popup[f'GATE||SLIDER {param}'].bind( + f'<{event}-{direction}>', f'||KEY {direction.upper()} {event_id}' ) - self.popup[f"GATE||SLIDER {param}"].bind( - f"", f"||KEY SHIFT {direction.upper()} {event_id}" + self.popup[f'GATE||SLIDER {param}'].bind( + f'', f'||KEY SHIFT {direction.upper()} {event_id}' ) - self.popup[f"GATE||SLIDER {param}"].bind( - f"", f"||KEY CTRL {direction.upper()} {event_id}" + self.popup[f'GATE||SLIDER {param}'].bind( + f'', f'||KEY CTRL {direction.upper()} {event_id}' ) - if param in ("BPSIDECHAIN", "ATTACK", "HOLD", "RELEASE"): - self.popup[f"GATE||SLIDER {param}"].bind( - f"", f"||KEY ALT {direction.upper()} {event_id}" + if param in ('BPSIDECHAIN', 'ATTACK', 'HOLD', 'RELEASE'): + self.popup[f'GATE||SLIDER {param}'].bind( + f'', f'||KEY ALT {direction.upper()} {event_id}' ) - self.popup[f"GATE||SLIDER {param}"].bind( - f"", f"||KEY CTRL ALT {direction.upper()} {event_id}" + self.popup[f'GATE||SLIDER {param}'].bind( + f'', f'||KEY CTRL ALT {direction.upper()} {event_id}' ) - self.popup[f"GATE||SLIDER {param}"].bind("", "||KEY CTRL SHIFT R") - self.popup["Exit"].bind("", "||FOCUS IN") - self.popup["Exit"].bind("", "||KEY ENTER") + self.popup[f'GATE||SLIDER {param}'].bind('', '||KEY CTRL SHIFT R') + self.popup['Exit'].bind('', '||FOCUS IN') + self.popup['Exit'].bind('', '||KEY ENTER') self.window.vm.observer.add(self.on_pdirty) while True: event, values = self.popup.read() - self.logger.debug(f"event::{event}") - self.logger.debug(f"values::{values}") - if event in (psg.WIN_CLOSED, "Exit"): + self.logger.debug(f'event::{event}') + self.logger.debug(f'values::{values}') + if event in (psg.WIN_CLOSED, 'Exit'): break match parsed_cmd := self.window.parser.match.parseString(event): - case [["GATE"], ["SLIDER", param]]: + case [['GATE'], ['SLIDER', param]]: setattr(self.window.vm.strip[index].gate, param.lower(), values[event]) - case [["GATE"], ["SLIDER", param], ["FOCUS", "IN"]]: + case [['GATE'], ['SLIDER', param], ['FOCUS', 'IN']]: label_map = { - "DAMPING": "Damping Max", - "BPSIDECHAIN": "BP Sidechain", + 'DAMPING': 'Damping Max', + 'BPSIDECHAIN': 'BP Sidechain', } - self.window.nvda.speak(f"{label_map.get(param, param)} {values[f'GATE||SLIDER {param}']}") + self.window.nvda.speak(f'{label_map.get(param, param)} {values[f"GATE||SLIDER {param}"]}') case [ - ["GATE"], - ["SLIDER", param], - ["KEY", "LEFT" | "RIGHT" | "UP" | "DOWN" as input_direction, "PRESS" | "RELEASE" as e], + ['GATE'], + ['SLIDER', param], + ['KEY', 'LEFT' | 'RIGHT' | 'UP' | 'DOWN' as input_direction, 'PRESS' | 'RELEASE' as e], ]: - if e == "PRESS": + if e == 'PRESS': self.window.vm.event.pdirty = False val = getattr(self.window.vm.strip[index].gate, param.lower()) match input_direction: - case "RIGHT" | "UP": + case 'RIGHT' | 'UP': val += 1 - case "LEFT" | "DOWN": + case 'LEFT' | 'DOWN': val -= 1 val = GateSlider.check_bounds(param, val) setattr(self.window.vm.strip[index].gate, param.lower(), val) - self.popup[f"GATE||SLIDER {param}"].update(value=val) - if param == "BPSIDECHAIN": + self.popup[f'GATE||SLIDER {param}'].update(value=val) + if param == 'BPSIDECHAIN': self.window.nvda.speak(str(int(val))) else: self.window.nvda.speak(str(round(val, 1))) else: self.window.vm.event.pdirty = True case [ - ["GATE"], - ["SLIDER", param], - ["KEY", "CTRL", "LEFT" | "RIGHT" | "UP" | "DOWN" as input_direction, "PRESS" | "RELEASE" as e], + ['GATE'], + ['SLIDER', param], + ['KEY', 'CTRL', 'LEFT' | 'RIGHT' | 'UP' | 'DOWN' as input_direction, 'PRESS' | 'RELEASE' as e], ]: - if e == "PRESS": + if e == 'PRESS': self.window.vm.event.pdirty = False val = getattr(self.window.vm.strip[index].gate, param.lower()) match input_direction: - case "RIGHT" | "UP": + case 'RIGHT' | 'UP': val += 3 - case "LEFT" | "DOWN": + case 'LEFT' | 'DOWN': val -= 3 val = GateSlider.check_bounds(param, val) setattr(self.window.vm.strip[index].gate, param.lower(), val) - self.popup[f"GATE||SLIDER {param}"].update(value=val) - if param == "BPSIDECHAIN": + self.popup[f'GATE||SLIDER {param}'].update(value=val) + if param == 'BPSIDECHAIN': self.window.nvda.speak(str(int(val))) else: self.window.nvda.speak(str(round(val, 1))) else: self.window.vm.event.pdirty = True case [ - ["GATE"], - ["SLIDER", param], - ["KEY", "SHIFT", "LEFT" | "RIGHT" | "UP" | "DOWN" as input_direction, "PRESS" | "RELEASE" as e], + ['GATE'], + ['SLIDER', param], + ['KEY', 'SHIFT', 'LEFT' | 'RIGHT' | 'UP' | 'DOWN' as input_direction, 'PRESS' | 'RELEASE' as e], ]: - if e == "PRESS": + if e == 'PRESS': self.window.vm.event.pdirty = False val = getattr(self.window.vm.strip[index].gate, param.lower()) match input_direction: - case "RIGHT" | "UP": + case 'RIGHT' | 'UP': val += 0.1 - case "LEFT" | "DOWN": + case 'LEFT' | 'DOWN': val -= 0.1 val = GateSlider.check_bounds(param, val) setattr(self.window.vm.strip[index].gate, param.lower(), val) - self.popup[f"GATE||SLIDER {param}"].update(value=val) - if param == "BPSIDECHAIN": + self.popup[f'GATE||SLIDER {param}'].update(value=val) + if param == 'BPSIDECHAIN': self.window.nvda.speak(str(int(val))) else: self.window.nvda.speak(str(round(val, 1))) else: self.window.vm.event.pdirty = True case [ - ["GATE"], - ["SLIDER", "BPSIDECHAIN" | "ATTACK" | "HOLD" | "RELEASE" as param], - ["KEY", "ALT", "LEFT" | "RIGHT" as input_direction, "PRESS" | "RELEASE" as e], + ['GATE'], + ['SLIDER', 'BPSIDECHAIN' | 'ATTACK' | 'HOLD' | 'RELEASE' as param], + ['KEY', 'ALT', 'LEFT' | 'RIGHT' as input_direction, 'PRESS' | 'RELEASE' as e], ]: - if e == "PRESS": + if e == 'PRESS': self.window.vm.event.pdirty = False val = getattr(self.window.vm.strip[index].gate, param.lower()) match input_direction: - case "RIGHT" | "UP": + case 'RIGHT' | 'UP': val += 10 - case "LEFT" | "DOWN": + case 'LEFT' | 'DOWN': val -= 10 val = GateSlider.check_bounds(param, val) setattr(self.window.vm.strip[index].gate, param.lower(), val) - self.popup[f"GATE||SLIDER {param}"].update(value=val) - if param == "BPSIDECHAIN": + self.popup[f'GATE||SLIDER {param}'].update(value=val) + if param == 'BPSIDECHAIN': self.window.nvda.speak(str(int(val))) else: self.window.nvda.speak(str(round(val, 1))) else: self.window.vm.event.pdirty = True case [ - ["GATE"], - ["SLIDER", "BPSIDECHAIN" | "ATTACK" | "HOLD" | "RELEASE" as param], - ["KEY", "CTRL", "ALT", "LEFT" | "RIGHT" as input_direction, "PRESS" | "RELEASE" as e], + ['GATE'], + ['SLIDER', 'BPSIDECHAIN' | 'ATTACK' | 'HOLD' | 'RELEASE' as param], + ['KEY', 'CTRL', 'ALT', 'LEFT' | 'RIGHT' as input_direction, 'PRESS' | 'RELEASE' as e], ]: - if e == "PRESS": + if e == 'PRESS': self.window.vm.event.pdirty = False val = getattr(self.window.vm.strip[index].gate, param.lower()) match input_direction: - case "RIGHT" | "UP": + case 'RIGHT' | 'UP': val += 50 - case "LEFT" | "DOWN": + case 'LEFT' | 'DOWN': val -= 50 val = GateSlider.check_bounds(param, val) setattr(self.window.vm.strip[index].gate, param.lower(), val) - self.popup[f"GATE||SLIDER {param}"].update(value=val) - if param == "BPSIDECHAIN": + self.popup[f'GATE||SLIDER {param}'].update(value=val) + if param == 'BPSIDECHAIN': self.window.nvda.speak(str(int(val))) else: self.window.nvda.speak(str(round(val, 1))) else: self.window.vm.event.pdirty = True - case [["GATE"], ["SLIDER", param], ["KEY", "CTRL", "SHIFT", "R"]]: + case [['GATE'], ['SLIDER', param], ['KEY', 'CTRL', 'SHIFT', 'R']]: match param: - case "THRESHOLD": + case 'THRESHOLD': val = -60 - case "DAMPING": + case 'DAMPING': val = -60 - case "BPSIDECHAIN": + case 'BPSIDECHAIN': val = 100 - case "ATTACK": + case 'ATTACK': val = 0 - case "HOLD": + case 'HOLD': val = 500 - case "RELEASE": + case 'RELEASE': val = 1000 setattr(self.window.vm.strip[index].gate, param.lower(), val) - self.popup[f"GATE||SLIDER {param}"].update(value=val) + self.popup[f'GATE||SLIDER {param}'].update(value=val) self.window.nvda.speak(str(round(val, 1))) - case [[button], ["FOCUS", "IN"]]: + case [[button], ['FOCUS', 'IN']]: self.window.nvda.speak(button) - case [_, ["KEY", "ENTER"]]: + case [_, ['KEY', 'ENTER']]: self.popup.find_element_with_focus().click() - self.logger.debug(f"parsed::{parsed_cmd}") + self.logger.debug(f'parsed::{parsed_cmd}') self.window.vm.observer.remove(self.on_pdirty) self.popup.close() diff --git a/src/nvda_voicemeeter/util.py b/src/nvda_voicemeeter/util.py index 5f50a55..a1c2dff 100644 --- a/src/nvda_voicemeeter/util.py +++ b/src/nvda_voicemeeter/util.py @@ -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', ] diff --git a/src/nvda_voicemeeter/window.py b/src/nvda_voicemeeter/window.py index 85266e0..dcd5a6d 100644 --- a/src/nvda_voicemeeter/window.py +++ b/src/nvda_voicemeeter/window.py @@ -12,9 +12,9 @@ from .popup import Popup logger = logging.getLogger(__name__) -psg.theme(configuration.get("default_theme", "Dark Blue 3")) -if psg.theme() == "HighContrast": - psg.set_options(font=("Arial", 14)) +psg.theme(configuration.get('default_theme', 'Dark Blue 3')) +if psg.theme() == 'HighContrast': + psg.set_options(font=('Arial', 14)) class NVDAVMWindow(psg.Window): @@ -24,15 +24,15 @@ class NVDAVMWindow(psg.Window): self.vm = vm self.kind = self.vm.kind self.logger = logger.getChild(type(self).__name__) - self.logger.debug(f"loaded with theme: {psg.theme()}") + self.logger.debug(f'loaded with theme: {psg.theme()}') self.cache = { - "hw_ins": models._make_hardware_ins_cache(self.vm), - "hw_outs": models._make_hardware_outs_cache(self.vm), - "strip": models._make_param_cache(self.vm, "strip"), - "bus": models._make_param_cache(self.vm, "bus"), - "labels": models._make_label_cache(self.vm), - "asio": models._make_patch_asio_cache(self.vm), - "insert": models._make_patch_insert_cache(self.vm), + 'hw_ins': models._make_hardware_ins_cache(self.vm), + 'hw_outs': models._make_hardware_outs_cache(self.vm), + 'strip': models._make_param_cache(self.vm, 'strip'), + 'bus': models._make_param_cache(self.vm, 'bus'), + 'labels': models._make_label_cache(self.vm), + 'asio': models._make_patch_asio_cache(self.vm), + 'insert': models._make_patch_insert_cache(self.vm), } self.nvda = Nvda() self.parser = Parser() @@ -40,44 +40,44 @@ class NVDAVMWindow(psg.Window): self.builder = Builder(self) layout = self.builder.run() super().__init__(title, layout, return_keyboard_events=False, finalize=True) - buttonmenu_opts = {"takefocus": 1, "highlightthickness": 1} + buttonmenu_opts = {'takefocus': 1, 'highlightthickness': 1} for i in range(self.kind.phys_in): - self[f"HARDWARE IN||{i + 1}"].Widget.config(**buttonmenu_opts) + self[f'HARDWARE IN||{i + 1}'].Widget.config(**buttonmenu_opts) for i in range(self.kind.phys_out): - self[f"HARDWARE OUT||A{i + 1}"].Widget.config(**buttonmenu_opts) - if self.kind.name == "basic": - self["HARDWARE OUT||A2"].Widget.config(**buttonmenu_opts) - if self.kind.name != "basic": - [self[f"PATCH COMPOSITE||PC{i + 1}"].Widget.config(**buttonmenu_opts) for i in range(self.kind.composite)] - slider_opts = {"takefocus": 1, "highlightthickness": 1} + self[f'HARDWARE OUT||A{i + 1}'].Widget.config(**buttonmenu_opts) + if self.kind.name == 'basic': + self['HARDWARE OUT||A2'].Widget.config(**buttonmenu_opts) + if self.kind.name != 'basic': + [self[f'PATCH COMPOSITE||PC{i + 1}'].Widget.config(**buttonmenu_opts) for i in range(self.kind.composite)] + slider_opts = {'takefocus': 1, 'highlightthickness': 1} for i in range(self.kind.num_strip): for param in util.get_slider_params(i, self.kind): - self[f"STRIP {i}||SLIDER {param}"].Widget.config(**slider_opts) - self[f"STRIP {i}||SLIDER GAIN"].Widget.config(**slider_opts) - if self.kind.name != "basic": - self[f"STRIP {i}||SLIDER LIMIT"].Widget.config(**slider_opts) + self[f'STRIP {i}||SLIDER {param}'].Widget.config(**slider_opts) + self[f'STRIP {i}||SLIDER GAIN'].Widget.config(**slider_opts) + if self.kind.name != 'basic': + self[f'STRIP {i}||SLIDER LIMIT'].Widget.config(**slider_opts) for i in range(self.kind.num_bus): - self[f"BUS {i}||SLIDER GAIN"].Widget.config(**slider_opts) - self[f"BUS {i}||MODE"].Widget.config(**buttonmenu_opts) + self[f'BUS {i}||SLIDER GAIN'].Widget.config(**slider_opts) + self[f'BUS {i}||MODE'].Widget.config(**buttonmenu_opts) self.register_events() - self["tabgroup"].set_focus() + self['tabgroup'].set_focus() def __enter__(self): settings_path = configuration.SETTINGS if settings_path.exists(): try: - defaultconfig = Path(configuration.get("default_config", "")) # coerce the type + defaultconfig = Path(configuration.get('default_config', '')) # coerce the type if defaultconfig.is_file() and defaultconfig.exists(): - self.vm.set("command.load", str(defaultconfig)) - self.logger.debug(f"config {defaultconfig} loaded") + self.vm.set('command.load', str(defaultconfig)) + self.logger.debug(f'config {defaultconfig} loaded') self.TKroot.after( 200, self.nvda.speak, - f"config {defaultconfig.stem} has been loaded", + f'config {defaultconfig.stem} has been loaded', ) except json.JSONDecodeError: - self.logger.debug("no default_config in settings.json. silently continuing...") + self.logger.debug('no default_config in settings.json. silently continuing...') self.vm.init_thread() self.vm.observer.add(self.on_pdirty) @@ -94,191 +94,191 @@ class NVDAVMWindow(psg.Window): def on_pdirty(self): self.cache = { - "hw_ins": models._make_hardware_ins_cache(self.vm), - "hw_outs": models._make_hardware_outs_cache(self.vm), - "strip": models._make_param_cache(self.vm, "strip"), - "bus": models._make_param_cache(self.vm, "bus"), - "labels": models._make_label_cache(self.vm), - "asio": models._make_patch_asio_cache(self.vm), - "insert": models._make_patch_insert_cache(self.vm), + 'hw_ins': models._make_hardware_ins_cache(self.vm), + 'hw_outs': models._make_hardware_outs_cache(self.vm), + 'strip': models._make_param_cache(self.vm, 'strip'), + 'bus': models._make_param_cache(self.vm, 'bus'), + 'labels': models._make_label_cache(self.vm), + 'asio': models._make_patch_asio_cache(self.vm), + 'insert': models._make_patch_insert_cache(self.vm), } - for key, value in self.cache["labels"].items(): + for key, value in self.cache['labels'].items(): self[key].update(value=value) - self[f"{key}||SLIDER"].update(value=value) + self[f'{key}||SLIDER'].update(value=value) for i in range(self.kind.num_strip): - self[f"STRIP {i}||SLIDER GAIN"].update(value=self.vm.strip[i].gain) - if self.kind.name != "basic": - self[f"STRIP {i}||SLIDER LIMIT"].update(value=self.vm.strip[i].limit) + self[f'STRIP {i}||SLIDER GAIN'].update(value=self.vm.strip[i].gain) + if self.kind.name != 'basic': + self[f'STRIP {i}||SLIDER LIMIT'].update(value=self.vm.strip[i].limit) for param in util.get_slider_params(i, self.kind): - if param in ("AUDIBILITY", "BASS", "MID", "TREBLE"): + if param in ('AUDIBILITY', 'BASS', 'MID', 'TREBLE'): val = getattr(self.vm.strip[i], param.lower()) else: target = getattr(self.vm.strip[i], param.lower()) val = target.knob - self[f"STRIP {i}||SLIDER {param}"].update(value=val) + self[f'STRIP {i}||SLIDER {param}'].update(value=val) for i in range(self.kind.num_bus): - self[f"BUS {i}||SLIDER GAIN"].update(value=self.vm.bus[i].gain) - if self.kind.name != "basic": - for key, value in self.cache["insert"].items(): - identifier, i = key.split("||") + self[f'BUS {i}||SLIDER GAIN'].update(value=self.vm.bus[i].gain) + if self.kind.name != 'basic': + for key, value in self.cache['insert'].items(): + identifier, i = key.split('||') partial = util.get_channel_identifier_list(self.vm)[int(i)] - self[f"{identifier}||{partial}"].update(value=value) + self[f'{identifier}||{partial}'].update(value=value) def register_events(self): """Registers events for widgets""" # TABS - self["tabgroup"].bind("", "||FOCUS IN") + self['tabgroup'].bind('', '||FOCUS IN') for tabname in util.get_tabs_labels()[1:]: - self[f"tabgroup||{tabname}"].bind("", "||FOCUS IN") - self[f"tabgroup||{tabname}"].bind("", "||KEY SHIFT TAB") - self.bind("", "CTRL-TAB") - self.bind("", "CTRL-SHIFT-TAB") - self.bind("", "F2") + self[f'tabgroup||{tabname}'].bind('', '||FOCUS IN') + self[f'tabgroup||{tabname}'].bind('', '||KEY SHIFT TAB') + self.bind('', 'CTRL-TAB') + self.bind('', 'CTRL-SHIFT-TAB') + self.bind('', 'F2') # NAV - self.bind("", "CTRL-A") + self.bind('', 'CTRL-A') for i in range(1, 10): - self.bind(f"", f"CTRL-{i}") + self.bind(f'', f'CTRL-{i}') for i in range(1, 10): - self.bind(f"", f"ALT-{i}") - self.bind("", "CTRL-O") - self.bind("", "CTRL-S") - self.bind("", "CTRL-M") + self.bind(f'', f'ALT-{i}') + self.bind('', 'CTRL-O') + self.bind('', 'CTRL-S') + self.bind('', 'CTRL-M') - self.bind("", "GAIN MODE") - self.bind("", "BASS MODE") - self.bind("", "MID MODE") - self.bind("", "TREBLE MODE") - if self.kind.name == "basic": - self.bind("", "AUDIBILITY MODE") - elif self.kind.name == "banana": - self.bind("", "COMP MODE") - self.bind("", "GATE MODE") - self.bind("", "LIMIT MODE") + self.bind('', 'GAIN MODE') + self.bind('', 'BASS MODE') + self.bind('', 'MID MODE') + self.bind('', 'TREBLE MODE') + if self.kind.name == 'basic': + self.bind('', 'AUDIBILITY MODE') + elif self.kind.name == 'banana': + self.bind('', 'COMP MODE') + self.bind('', 'GATE MODE') + self.bind('', 'LIMIT MODE') else: - self.bind("", "COMP MODE") - self.bind("", "GATE MODE") - self.bind("", "DENOISER MODE") - self.bind("", "LIMIT MODE") - self.bind("", "ESCAPE") + self.bind('', 'COMP MODE') + self.bind('', 'GATE MODE') + self.bind('', 'DENOISER MODE') + self.bind('', 'LIMIT MODE') + self.bind('', 'ESCAPE') - for event in ("KeyPress", "KeyRelease"): - event_id = event.removeprefix("Key").upper() - for direction in ("Left", "Right", "Up", "Down"): - self.bind(f"", f"ALT {direction.upper()}||{event_id}") - self.bind(f"", f"ALT SHIFT {direction.upper()}||{event_id}") - self.bind(f"", f"ALT CTRL {direction.upper()}||{event_id}") + for event in ('KeyPress', 'KeyRelease'): + event_id = event.removeprefix('Key').upper() + for direction in ('Left', 'Right', 'Up', 'Down'): + self.bind(f'', f'ALT {direction.upper()}||{event_id}') + self.bind(f'', f'ALT SHIFT {direction.upper()}||{event_id}') + self.bind(f'', f'ALT CTRL {direction.upper()}||{event_id}') # Hardware In for i in range(self.kind.phys_in): - self[f"HARDWARE IN||{i + 1}"].bind("", "||FOCUS IN") - self[f"HARDWARE IN||{i + 1}"].bind("", "||KEY SPACE", propagate=False) - self[f"HARDWARE IN||{i + 1}"].bind("", "||KEY ENTER", propagate=False) + self[f'HARDWARE IN||{i + 1}'].bind('', '||FOCUS IN') + self[f'HARDWARE IN||{i + 1}'].bind('', '||KEY SPACE', propagate=False) + self[f'HARDWARE IN||{i + 1}'].bind('', '||KEY ENTER', propagate=False) # Hardware Out for i in range(self.kind.phys_out): - self[f"HARDWARE OUT||A{i + 1}"].bind("", "||FOCUS IN") - self[f"HARDWARE OUT||A{i + 1}"].bind("", "||KEY SPACE", propagate=False) - self[f"HARDWARE OUT||A{i + 1}"].bind("", "||KEY ENTER", propagate=False) - if self.kind.name == "basic": - self["HARDWARE OUT||A2"].bind("", "||FOCUS IN") - self["HARDWARE OUT||A2"].bind("", "||KEY SPACE", propagate=False) - self["HARDWARE OUT||A2"].bind("", "||KEY ENTER", propagate=False) + self[f'HARDWARE OUT||A{i + 1}'].bind('', '||FOCUS IN') + self[f'HARDWARE OUT||A{i + 1}'].bind('', '||KEY SPACE', propagate=False) + self[f'HARDWARE OUT||A{i + 1}'].bind('', '||KEY ENTER', propagate=False) + if self.kind.name == 'basic': + self['HARDWARE OUT||A2'].bind('', '||FOCUS IN') + self['HARDWARE OUT||A2'].bind('', '||KEY SPACE', propagate=False) + self['HARDWARE OUT||A2'].bind('', '||KEY ENTER', propagate=False) # Patch Composite - if self.kind.name != "basic": + if self.kind.name != 'basic': for i in range(self.kind.composite): - self[f"PATCH COMPOSITE||PC{i + 1}"].bind("", "||FOCUS IN") - self[f"PATCH COMPOSITE||PC{i + 1}"].bind("", "||KEY SPACE", propagate=False) - self[f"PATCH COMPOSITE||PC{i + 1}"].bind("", "||KEY ENTER", propagate=False) + self[f'PATCH COMPOSITE||PC{i + 1}'].bind('', '||FOCUS IN') + self[f'PATCH COMPOSITE||PC{i + 1}'].bind('', '||KEY SPACE', propagate=False) + self[f'PATCH COMPOSITE||PC{i + 1}'].bind('', '||KEY ENTER', propagate=False) # Patch Insert - if self.kind.name != "basic": + if self.kind.name != 'basic': for i in range(self.kind.num_strip): if i < self.kind.phys_in: - self[f"INSERT CHECKBOX||IN{i + 1} 0"].bind("", "||FOCUS IN") - self[f"INSERT CHECKBOX||IN{i + 1} 1"].bind("", "||FOCUS IN") - self[f"INSERT CHECKBOX||IN{i + 1} 0"].bind("", "||KEY ENTER") - self[f"INSERT CHECKBOX||IN{i + 1} 1"].bind("", "||KEY ENTER") + self[f'INSERT CHECKBOX||IN{i + 1} 0'].bind('', '||FOCUS IN') + self[f'INSERT CHECKBOX||IN{i + 1} 1'].bind('', '||FOCUS IN') + self[f'INSERT CHECKBOX||IN{i + 1} 0'].bind('', '||KEY ENTER') + self[f'INSERT CHECKBOX||IN{i + 1} 1'].bind('', '||KEY ENTER') else: - [self[f"INSERT CHECKBOX||IN{i + 1} {j}"].bind("", "||FOCUS IN") for j in range(8)] - [self[f"INSERT CHECKBOX||IN{i + 1} {j}"].bind("", "||KEY ENTER") for j in range(8)] + [self[f'INSERT CHECKBOX||IN{i + 1} {j}'].bind('', '||FOCUS IN') for j in range(8)] + [self[f'INSERT CHECKBOX||IN{i + 1} {j}'].bind('', '||KEY ENTER') for j in range(8)] # Advanced Settings - self["ADVANCED SETTINGS"].bind("", "||FOCUS IN") - self["ADVANCED SETTINGS"].bind("", "||KEY ENTER") + self['ADVANCED SETTINGS'].bind('', '||FOCUS IN') + self['ADVANCED SETTINGS'].bind('', '||KEY ENTER') # Strip Params for i in range(self.kind.num_strip): for j in range(self.kind.phys_out): - self[f"STRIP {i}||A{j + 1}"].bind("", "||FOCUS IN") - self[f"STRIP {i}||A{j + 1}"].bind("", "||KEY ENTER") + self[f'STRIP {i}||A{j + 1}'].bind('', '||FOCUS IN') + self[f'STRIP {i}||A{j + 1}'].bind('', '||KEY ENTER') for j in range(self.kind.virt_out): - self[f"STRIP {i}||B{j + 1}"].bind("", "||FOCUS IN") - self[f"STRIP {i}||B{j + 1}"].bind("", "||KEY ENTER") + self[f'STRIP {i}||B{j + 1}'].bind('', '||FOCUS IN') + self[f'STRIP {i}||B{j + 1}'].bind('', '||KEY ENTER') if i < self.kind.phys_in: - for param in ("MONO", "SOLO", "MUTE"): - self[f"STRIP {i}||{param}"].bind("", "||FOCUS IN") - self[f"STRIP {i}||{param}"].bind("", "||KEY ENTER") + for param in ('MONO', 'SOLO', 'MUTE'): + self[f'STRIP {i}||{param}'].bind('', '||FOCUS IN') + self[f'STRIP {i}||{param}'].bind('', '||KEY ENTER') else: if i == self.kind.phys_in + 1: - for param in ("KARAOKE", "SOLO", "MUTE"): - self[f"STRIP {i}||{param}"].bind("", "||FOCUS IN") - self[f"STRIP {i}||{param}"].bind("", "||KEY ENTER") + for param in ('KARAOKE', 'SOLO', 'MUTE'): + self[f'STRIP {i}||{param}'].bind('', '||FOCUS IN') + self[f'STRIP {i}||{param}'].bind('', '||KEY ENTER') else: - for param in ("MC", "SOLO", "MUTE"): - self[f"STRIP {i}||{param}"].bind("", "||FOCUS IN") - self[f"STRIP {i}||{param}"].bind("", "||KEY ENTER") + for param in ('MC', 'SOLO', 'MUTE'): + self[f'STRIP {i}||{param}'].bind('', '||FOCUS IN') + self[f'STRIP {i}||{param}'].bind('', '||KEY ENTER') # Strip Sliders for i in range(self.kind.num_strip): for param in util.get_full_slider_params(i, self.kind): - self[f"STRIP {i}||SLIDER {param}"].bind("", "||FOCUS IN") - self[f"STRIP {i}||SLIDER {param}"].bind("", "||FOCUS OUT") - for event in ("KeyPress", "KeyRelease"): - event_id = event.removeprefix("Key").upper() - for direction in ("Left", "Right", "Up", "Down"): - self[f"STRIP {i}||SLIDER {param}"].bind( - f"<{event}-{direction}>", f"||KEY {direction.upper()} {event_id}" + self[f'STRIP {i}||SLIDER {param}'].bind('', '||FOCUS IN') + self[f'STRIP {i}||SLIDER {param}'].bind('', '||FOCUS OUT') + for event in ('KeyPress', 'KeyRelease'): + event_id = event.removeprefix('Key').upper() + for direction in ('Left', 'Right', 'Up', 'Down'): + self[f'STRIP {i}||SLIDER {param}'].bind( + f'<{event}-{direction}>', f'||KEY {direction.upper()} {event_id}' ) - self[f"STRIP {i}||SLIDER {param}"].bind( - f"", f"||KEY SHIFT {direction.upper()} {event_id}" + self[f'STRIP {i}||SLIDER {param}'].bind( + f'', f'||KEY SHIFT {direction.upper()} {event_id}' ) - self[f"STRIP {i}||SLIDER {param}"].bind( - f"", f"||KEY CTRL {direction.upper()} {event_id}" + self[f'STRIP {i}||SLIDER {param}'].bind( + f'', f'||KEY CTRL {direction.upper()} {event_id}' ) - self[f"STRIP {i}||SLIDER {param}"].bind("", "||KEY CTRL SHIFT R") + self[f'STRIP {i}||SLIDER {param}'].bind('', '||KEY CTRL SHIFT R') # Bus Params - params = ["MONO", "EQ", "MUTE"] - if self.kind.name == "basic": - params.remove("EQ") + params = ['MONO', 'EQ', 'MUTE'] + if self.kind.name == 'basic': + params.remove('EQ') for i in range(self.kind.num_bus): for param in params: - self[f"BUS {i}||{param}"].bind("", "||FOCUS IN") - self[f"BUS {i}||{param}"].bind("", "||KEY ENTER") - self[f"BUS {i}||MODE"].bind("", "||FOCUS IN") - self[f"BUS {i}||MODE"].bind("", "||KEY SPACE", propagate=False) - self[f"BUS {i}||MODE"].bind("", "||KEY ENTER", propagate=False) + self[f'BUS {i}||{param}'].bind('', '||FOCUS IN') + self[f'BUS {i}||{param}'].bind('', '||KEY ENTER') + self[f'BUS {i}||MODE'].bind('', '||FOCUS IN') + self[f'BUS {i}||MODE'].bind('', '||KEY SPACE', propagate=False) + self[f'BUS {i}||MODE'].bind('', '||KEY ENTER', propagate=False) # Bus Sliders for i in range(self.kind.num_bus): - self[f"BUS {i}||SLIDER GAIN"].bind("", "||FOCUS IN") - self[f"BUS {i}||SLIDER GAIN"].bind("", "||FOCUS OUT") - for event in ("KeyPress", "KeyRelease"): - event_id = event.removeprefix("Key").upper() - for direction in ("Left", "Right", "Up", "Down"): - self[f"BUS {i}||SLIDER GAIN"].bind( - f"<{event}-{direction}>", f"||KEY {direction.upper()} {event_id}" + self[f'BUS {i}||SLIDER GAIN'].bind('', '||FOCUS IN') + self[f'BUS {i}||SLIDER GAIN'].bind('', '||FOCUS OUT') + for event in ('KeyPress', 'KeyRelease'): + event_id = event.removeprefix('Key').upper() + for direction in ('Left', 'Right', 'Up', 'Down'): + self[f'BUS {i}||SLIDER GAIN'].bind( + f'<{event}-{direction}>', f'||KEY {direction.upper()} {event_id}' ) - self[f"BUS {i}||SLIDER GAIN"].bind( - f"", f"||KEY SHIFT {direction.upper()} {event_id}" + self[f'BUS {i}||SLIDER GAIN'].bind( + f'', f'||KEY SHIFT {direction.upper()} {event_id}' ) - self[f"BUS {i}||SLIDER GAIN"].bind( - f"", f"||KEY CTRL {direction.upper()} {event_id}" + self[f'BUS {i}||SLIDER GAIN'].bind( + f'', f'||KEY CTRL {direction.upper()} {event_id}' ) - self[f"BUS {i}||SLIDER GAIN"].bind("", "||KEY CTRL SHIFT R") + self[f'BUS {i}||SLIDER GAIN'].bind('', '||KEY CTRL SHIFT R') def run(self): """ @@ -290,312 +290,312 @@ class NVDAVMWindow(psg.Window): while True: event, values = self.read() - self.logger.debug(f"event::{event}") - self.logger.debug(f"values::{values}") - if event in (psg.WIN_CLOSED, "Exit"): + self.logger.debug(f'event::{event}') + self.logger.debug(f'values::{values}') + if event in (psg.WIN_CLOSED, 'Exit'): break elif event in util.get_slider_modes(): mode = event - self.nvda.speak(f"{mode} enabled") - self.logger.debug(f"entered slider mode {mode}") + self.nvda.speak(f'{mode} enabled') + self.logger.debug(f'entered slider mode {mode}') continue - elif event == "ESCAPE": + elif event == 'ESCAPE': if mode: - self.nvda.speak(f"{mode} disabled") - self.logger.debug(f"exited from slider mode {mode}") + self.nvda.speak(f'{mode} disabled') + self.logger.debug(f'exited from slider mode {mode}') mode = None continue match parsed_cmd := self.parser.match.parseString(event): # Slider mode - case [["ALT", "LEFT" | "RIGHT" | "UP" | "DOWN" as direction], ["PRESS" | "RELEASE" as e]]: + case [['ALT', 'LEFT' | 'RIGHT' | 'UP' | 'DOWN' as direction], ['PRESS' | 'RELEASE' as e]]: if mode: - self.write_event_value(f"SLIDER MODE {direction}||{e}", mode.split()[0]) + self.write_event_value(f'SLIDER MODE {direction}||{e}', mode.split()[0]) case [ - ["ALT", "SHIFT" | "CTRL" as modifier, "LEFT" | "RIGHT" | "UP" | "DOWN" as direction], - ["PRESS" | "RELEASE" as e], + ['ALT', 'SHIFT' | 'CTRL' as modifier, 'LEFT' | 'RIGHT' | 'UP' | 'DOWN' as direction], + ['PRESS' | 'RELEASE' as e], ]: if mode: - self.write_event_value(f"SLIDER MODE {modifier} {direction}||{e}", mode.split()[0]) + self.write_event_value(f'SLIDER MODE {modifier} {direction}||{e}', mode.split()[0]) # Focus tabgroup - case ["CTRL-TAB"] | ["CTRL-SHIFT-TAB"]: - self["tabgroup"].set_focus() - self.nvda.speak(f"{values['tabgroup']}") + case ['CTRL-TAB'] | ['CTRL-SHIFT-TAB']: + self['tabgroup'].set_focus() + self.nvda.speak(f'{values["tabgroup"]}') # Quick Navigation - case ["CTRL-1" | "CTRL-2" | "CTRL-3" | "CTRL-4" | "CTRL-5" | "CTRL-6" | "CTRL-7" | "CTRL-8" as bind]: - key, index = bind.split("-") - match values["tabgroup"]: - case "tab||Physical Strip": + case ['CTRL-1' | 'CTRL-2' | 'CTRL-3' | 'CTRL-4' | 'CTRL-5' | 'CTRL-6' | 'CTRL-7' | 'CTRL-8' as bind]: + key, index = bind.split('-') + match values['tabgroup']: + case 'tab||Physical Strip': if int(index) > self.kind.phys_in: continue - self[f"STRIP {int(index) - 1}||A1"].set_focus() + self[f'STRIP {int(index) - 1}||A1'].set_focus() if ( self.find_element_with_focus() is None - or self.find_element_with_focus().Key != f"STRIP {int(index) - 1}||A1" + or self.find_element_with_focus().Key != f'STRIP {int(index) - 1}||A1' ): - self[f"STRIP {int(index) - 1}||SLIDER GAIN"].set_focus() - case "tab||Virtual Strip": + self[f'STRIP {int(index) - 1}||SLIDER GAIN'].set_focus() + case 'tab||Virtual Strip': index = int(index) + self.kind.phys_in if index > self.kind.num_strip: continue - self[f"STRIP {index - 1}||A1"].set_focus() + self[f'STRIP {index - 1}||A1'].set_focus() if ( self.find_element_with_focus() is None - or self.find_element_with_focus().Key != f"STRIP {int(index) - 1}||A1" + or self.find_element_with_focus().Key != f'STRIP {int(index) - 1}||A1' ): - self[f"STRIP {int(index) - 1}||SLIDER GAIN"].set_focus() - case "tab||Buses": + self[f'STRIP {int(index) - 1}||SLIDER GAIN'].set_focus() + case 'tab||Buses': if int(index) > self.kind.num_bus: continue - self[f"BUS {int(index) - 1}||MONO"].set_focus() + self[f'BUS {int(index) - 1}||MONO'].set_focus() if ( self.find_element_with_focus() is None - or self.find_element_with_focus().Key != f"BUS {int(index) - 1}||MONO" + or self.find_element_with_focus().Key != f'BUS {int(index) - 1}||MONO' ): - self[f"BUS {int(index) - 1}||SLIDER GAIN"].set_focus() - case ["ALT-1" | "ALT-2" | "ALT-3" | "ALT-4" | "ALT-5" | "ALT-6" | "ALT-7" | "ALT-8" as bind]: - if values["tabgroup"] not in ("tab||Physical Strip", "tab||Virtual Strip", "tab||Buses"): + self[f'BUS {int(index) - 1}||SLIDER GAIN'].set_focus() + case ['ALT-1' | 'ALT-2' | 'ALT-3' | 'ALT-4' | 'ALT-5' | 'ALT-6' | 'ALT-7' | 'ALT-8' as bind]: + if values['tabgroup'] not in ('tab||Physical Strip', 'tab||Virtual Strip', 'tab||Buses'): continue - key, index = bind.split("-") + key, index = bind.split('-') if int(index) > self.kind.phys_out + self.kind.virt_out: continue if focus := self.find_element_with_focus(): - identifier, param = focus.Key.split("||") + identifier, param = focus.Key.split('||') if int(index) <= self.kind.phys_out: - self.write_event_value(f"{identifier}||A{int(index)}", None) + self.write_event_value(f'{identifier}||A{int(index)}', None) else: - self.write_event_value(f"{identifier}||B{int(index) - self.kind.phys_out}", None) - case ["CTRL-O"]: - if values["tabgroup"] not in ("tab||Physical Strip", "tab||Virtual Strip", "tab||Buses"): + self.write_event_value(f'{identifier}||B{int(index) - self.kind.phys_out}', None) + case ['CTRL-O']: + if values['tabgroup'] not in ('tab||Physical Strip', 'tab||Virtual Strip', 'tab||Buses'): continue if focus := self.find_element_with_focus(): - identifier, param = focus.Key.split("||") - self.write_event_value(f"{identifier}||MONO", None) - case ["CTRL-S"]: - if values["tabgroup"] not in ("tab||Physical Strip", "tab||Virtual Strip"): + identifier, param = focus.Key.split('||') + self.write_event_value(f'{identifier}||MONO', None) + case ['CTRL-S']: + if values['tabgroup'] not in ('tab||Physical Strip', 'tab||Virtual Strip'): continue if focus := self.find_element_with_focus(): - identifier, param = focus.Key.split("||") - self.write_event_value(f"{identifier}||SOLO", None) - case ["CTRL-M"]: - if values["tabgroup"] not in ("tab||Physical Strip", "tab||Virtual Strip", "tab||Buses"): + identifier, param = focus.Key.split('||') + self.write_event_value(f'{identifier}||SOLO', None) + case ['CTRL-M']: + if values['tabgroup'] not in ('tab||Physical Strip', 'tab||Virtual Strip', 'tab||Buses'): continue if focus := self.find_element_with_focus(): - identifier, param = focus.Key.split("||") - self.write_event_value(f"{identifier}||MUTE", None) - case [["SLIDER", "MODE", direction], ["PRESS" | "RELEASE" as e]]: - if values["tabgroup"] not in ("tab||Physical Strip", "tab||Virtual Strip", "tab||Buses"): + identifier, param = focus.Key.split('||') + self.write_event_value(f'{identifier}||MUTE', None) + case [['SLIDER', 'MODE', direction], ['PRESS' | 'RELEASE' as e]]: + if values['tabgroup'] not in ('tab||Physical Strip', 'tab||Virtual Strip', 'tab||Buses'): continue param = values[event] if focus := self.find_element_with_focus(): - identifier, partial = focus.Key.split("||") + identifier, partial = focus.Key.split('||') _, index = identifier.split() if param in util.get_full_slider_params(int(index), self.kind): - if "SLIDER" not in partial: - self.write_event_value(f"{identifier}||SLIDER {param}||KEY {direction} {e}", None) + if 'SLIDER' not in partial: + self.write_event_value(f'{identifier}||SLIDER {param}||KEY {direction} {e}', None) case [ - ["SLIDER", "MODE", "SHIFT" | "CTRL" as modifier, direction], - ["PRESS" | "RELEASE" as e], + ['SLIDER', 'MODE', 'SHIFT' | 'CTRL' as modifier, direction], + ['PRESS' | 'RELEASE' as e], ]: - if values["tabgroup"] not in ("tab||Physical Strip", "tab||Virtual Strip", "tab||Buses"): + if values['tabgroup'] not in ('tab||Physical Strip', 'tab||Virtual Strip', 'tab||Buses'): continue param = values[event] if focus := self.find_element_with_focus(): - identifier, partial = focus.Key.split("||") + identifier, partial = focus.Key.split('||') _, index = identifier.split() if param in util.get_full_slider_params(int(index), self.kind): - if "SLIDER" not in partial: + if 'SLIDER' not in partial: self.write_event_value( - f"{identifier}||SLIDER {param}||KEY {modifier} {direction} {e}", None + f'{identifier}||SLIDER {param}||KEY {modifier} {direction} {e}', None ) # Rename popups - case ["F2"]: - tab = values["tabgroup"].split("||")[1] - if tab in ("Physical Strip", "Virtual Strip", "Buses"): + case ['F2']: + tab = values['tabgroup'].split('||')[1] + if tab in ('Physical Strip', 'Virtual Strip', 'Buses'): if focus := self.find_element_with_focus(): - identifier, partial = focus.Key.split("||") + identifier, partial = focus.Key.split('||') _, index = identifier.split() index = int(index) - data = self.popup.rename("Label", index, title="Rename", tab=tab) + data = self.popup.rename('Label', index, title='Rename', tab=tab) if not data: # cancel was pressed continue match tab: - case "Physical Strip": - label = data.get("Edit", f"Hardware Input {int(index) + 1}") + case 'Physical Strip': + label = data.get('Edit', f'Hardware Input {int(index) + 1}') self.vm.strip[int(index)].label = label - self[f"STRIP {index}||LABEL"].update(value=label) - self.cache["labels"][f"STRIP {index}||LABEL"] = label - case "Virtual Strip": - label = data.get("Edit", f"Virtual Input {int(index) + 1}") + self[f'STRIP {index}||LABEL'].update(value=label) + self.cache['labels'][f'STRIP {index}||LABEL'] = label + case 'Virtual Strip': + label = data.get('Edit', f'Virtual Input {int(index) + 1}') self.vm.strip[int(index)].label = label - self[f"STRIP {index}||LABEL"].update(value=label) - self.cache["labels"][f"STRIP {index}||LABEL"] = label - case "Buses": + self[f'STRIP {index}||LABEL'].update(value=label) + self.cache['labels'][f'STRIP {index}||LABEL'] = label + case 'Buses': if index < self.kind.phys_out: - label = data.get("Edit", f"Physical Bus {int(index) + 1}") + label = data.get('Edit', f'Physical Bus {int(index) + 1}') else: - label = data.get("Edit", f"Virtual Bus {int(index) - self.kind.phys_out + 1}") + label = data.get('Edit', f'Virtual Bus {int(index) - self.kind.phys_out + 1}') self.vm.bus[int(index)].label = label - self[f"BUS {index}||LABEL"].update(value=label) - self.cache["labels"][f"BUS {index}||LABEL"] = label + self[f'BUS {index}||LABEL'].update(value=label) + self.cache['labels'][f'BUS {index}||LABEL'] = label # Advanced popups (settings, comp, gate) - case ["CTRL-A"]: - match values["tabgroup"]: - case "tab||Settings": - self.write_event_value("ADVANCED SETTINGS", None) - case "tab||Physical Strip": - if values["tabgroup||Physical Strip"] == "tab||Physical Strip||sliders": + case ['CTRL-A']: + match values['tabgroup']: + case 'tab||Settings': + self.write_event_value('ADVANCED SETTINGS', None) + case 'tab||Physical Strip': + if values['tabgroup||Physical Strip'] == 'tab||Physical Strip||sliders': if focus := self.find_element_with_focus(): - identifier, partial = focus.key.split("||") + identifier, partial = focus.key.split('||') _, index = identifier.split() match self.kind.name: - case "potato": - if "SLIDER COMP" in partial: - self.popup.compressor(int(index), title="Advanced Compressor") - elif "SLIDER GATE" in partial: - self.popup.gate(int(index), title="Advanced Gate") + case 'potato': + if 'SLIDER COMP' in partial: + self.popup.compressor(int(index), title='Advanced Compressor') + elif 'SLIDER GATE' in partial: + self.popup.gate(int(index), title='Advanced Gate') # Menus - case [["Restart", "Audio", "Engine"], ["MENU"]]: - self.perform_long_operation(self.vm.command.restart, "ENGINE RESTART||END") - case [["ENGINE", "RESTART"], ["END"]]: + case [['Restart', 'Audio', 'Engine'], ['MENU']]: + self.perform_long_operation(self.vm.command.restart, 'ENGINE RESTART||END') + case [['ENGINE', 'RESTART'], ['END']]: self.TKroot.after( 200, self.nvda.speak, - "Audio Engine restarted", + 'Audio Engine restarted', ) - case [["Save", "Settings"], ["MENU"]]: - initial_folder = Path.home() / "Documents" / "Voicemeeter" + case [['Save', 'Settings'], ['MENU']]: + initial_folder = Path.home() / 'Documents' / 'Voicemeeter' if filepath := self.popup.save_as( - "Open the file browser", title="Save As", initial_folder=initial_folder + 'Open the file browser', title='Save As', initial_folder=initial_folder ): - self.vm.set("command.save", str(filepath)) - self.logger.debug(f"saving config file to {filepath}") + self.vm.set('command.save', str(filepath)) + self.logger.debug(f'saving config file to {filepath}') self.TKroot.after( 200, self.nvda.speak, - f"config file {filepath.stem} has been saved", + f'config file {filepath.stem} has been saved', ) - case [["Load", "Settings"], ["MENU"]]: - initial_folder = Path.home() / "Documents" / "Voicemeeter" + case [['Load', 'Settings'], ['MENU']]: + initial_folder = Path.home() / 'Documents' / 'Voicemeeter' if filepath := psg.popup_get_file( - "Filename", - title="Load Settings", + 'Filename', + title='Load Settings', initial_folder=initial_folder, no_window=True, - file_types=(("XML", ".xml"),), + file_types=(('XML', '.xml'),), ): filepath = Path(filepath) - self.vm.set("command.load", str(filepath)) - self.logger.debug(f"loading config file from {filepath}") + self.vm.set('command.load', str(filepath)) + self.logger.debug(f'loading config file from {filepath}') for i in (25, 50): # for the benefit of the sliders self.TKroot.after(i, self.on_pdirty) self.TKroot.after( 200, self.nvda.speak, - f"config file {filepath.stem} has been loaded", + f'config file {filepath.stem} has been loaded', ) - case [["Load", "Settings", "on", "Startup"], ["MENU"]]: - initial_folder = Path.home() / "Documents" / "Voicemeeter" + case [['Load', 'Settings', 'on', 'Startup'], ['MENU']]: + initial_folder = Path.home() / 'Documents' / 'Voicemeeter' if filepath := psg.popup_get_file( - "Filename", - title="Load Settings", + 'Filename', + title='Load Settings', initial_folder=initial_folder, no_window=True, - file_types=(("XML", ".xml"),), + file_types=(('XML', '.xml'),), ): filepath = Path(filepath) - configuration.set("default_config", str(filepath)) + configuration.set('default_config', str(filepath)) self.TKroot.after( 200, self.nvda.speak, - f"config {filepath.stem} set as default on startup", + f'config {filepath.stem} set as default on startup', ) else: - configuration.delete("default_config") - self.logger.debug("default_config removed from settings.json") + configuration.delete('default_config') + self.logger.debug('default_config removed from settings.json') - case [theme, ["MENU", "THEME"]]: - chosen = " ".join(theme) - if chosen == "Default": - chosen = "Dark Blue 3" - configuration.set("default_theme", chosen) + case [theme, ['MENU', 'THEME']]: + chosen = ' '.join(theme) + if chosen == 'Default': + chosen = 'Dark Blue 3' + configuration.set('default_theme', chosen) self.TKroot.after( 200, self.nvda.speak, - f"theme {chosen} selected.", + f'theme {chosen} selected.', ) - self.logger.debug(f"theme {chosen} selected") + self.logger.debug(f'theme {chosen} selected') # Tabs - case ["tabgroup"] | [["tabgroup"], ["FOCUS", "IN"]]: + case ['tabgroup'] | [['tabgroup'], ['FOCUS', 'IN']]: if self.find_element_with_focus() is None: - self.nvda.speak(f"{values['tabgroup']}") - case [["tabgroup"], tabname] | [["tabgroup"], tabname, ["FOCUS", "IN"]]: + self.nvda.speak(f'{values["tabgroup"]}') + case [['tabgroup'], tabname] | [['tabgroup'], tabname, ['FOCUS', 'IN']]: if self.find_element_with_focus() is None: - name = " ".join(tabname) - self.nvda.speak(f"{values[f'tabgroup||{name}']}") - case [["tabgroup"], _, ["KEY", "SHIFT", "TAB"]]: - self.nvda.speak(values["tabgroup"]) + name = ' '.join(tabname) + self.nvda.speak(f'{values[f"tabgroup||{name}"]}') + case [['tabgroup'], _, ['KEY', 'SHIFT', 'TAB']]: + self.nvda.speak(values['tabgroup']) # Hardware In - case [["HARDWARE", "IN"], [key]]: - selection = values[f"HARDWARE IN||{key}"] + case [['HARDWARE', 'IN'], [key]]: + selection = values[f'HARDWARE IN||{key}'] index = int(key) - 1 - match selection.split(":"): + match selection.split(':'): case [device_name]: - setattr(self.vm.strip[index].device, "wdm", "") - self.TKroot.after(200, self.nvda.speak, f"HARDWARE IN {key} device selection removed") + setattr(self.vm.strip[index].device, 'wdm', '') + self.TKroot.after(200, self.nvda.speak, f'HARDWARE IN {key} device selection removed') case [driver, device_name]: setattr(self.vm.strip[index].device, driver, device_name.lstrip()) - phonetic = {"mme": "em em e"} + phonetic = {'mme': 'em em e'} self.TKroot.after( 200, self.nvda.speak, - f"HARDWARE IN {key} set {phonetic.get(driver, driver)} {device_name}", + f'HARDWARE IN {key} set {phonetic.get(driver, driver)} {device_name}', ) - case [["HARDWARE", "IN"], [key], ["FOCUS", "IN"]]: + case [['HARDWARE', 'IN'], [key], ['FOCUS', 'IN']]: if self.find_element_with_focus() is not None: - self.nvda.speak(f"HARDWARE INPUT {key} {self.cache['hw_ins'][f'HARDWARE IN||{key}']}") - case [["HARDWARE", "IN"], [key], ["KEY", "SPACE" | "ENTER"]]: - util.open_context_menu_for_buttonmenu(self, f"HARDWARE IN||{key}") + self.nvda.speak(f'HARDWARE INPUT {key} {self.cache["hw_ins"][f"HARDWARE IN||{key}"]}') + case [['HARDWARE', 'IN'], [key], ['KEY', 'SPACE' | 'ENTER']]: + util.open_context_menu_for_buttonmenu(self, f'HARDWARE IN||{key}') # Hardware out - case [["HARDWARE", "OUT"], [key]]: - selection = values[f"HARDWARE OUT||{key}"] + case [['HARDWARE', 'OUT'], [key]]: + selection = values[f'HARDWARE OUT||{key}'] index = int(key[1]) - 1 - match selection.split(":"): + match selection.split(':'): case [device_name]: - setattr(self.vm.bus[index].device, "wdm", "") - self.TKroot.after(200, self.nvda.speak, f"HARDWARE OUT {key} device selection removed") + setattr(self.vm.bus[index].device, 'wdm', '') + self.TKroot.after(200, self.nvda.speak, f'HARDWARE OUT {key} device selection removed') case [driver, device_name]: setattr(self.vm.bus[index].device, driver, device_name.lstrip()) - phonetic = {"mme": "em em e"} + phonetic = {'mme': 'em em e'} self.TKroot.after( 200, self.nvda.speak, - f"HARDWARE OUT {key} set {phonetic.get(driver, driver)} {device_name}", + f'HARDWARE OUT {key} set {phonetic.get(driver, driver)} {device_name}', ) - case [["HARDWARE", "OUT"], [key], ["FOCUS", "IN"]]: + case [['HARDWARE', 'OUT'], [key], ['FOCUS', 'IN']]: if self.find_element_with_focus() is not None: - self.nvda.speak(f"HARDWARE OUT {key} {self.cache['hw_outs'][f'HARDWARE OUT||{key}']}") - case [["HARDWARE", "OUT"], [key], ["KEY", "SPACE" | "ENTER"]]: - util.open_context_menu_for_buttonmenu(self, f"HARDWARE OUT||{key}") + self.nvda.speak(f'HARDWARE OUT {key} {self.cache["hw_outs"][f"HARDWARE OUT||{key}"]}') + case [['HARDWARE', 'OUT'], [key], ['KEY', 'SPACE' | 'ENTER']]: + util.open_context_menu_for_buttonmenu(self, f'HARDWARE OUT||{key}') # Patch COMPOSITE - case [["PATCH", "COMPOSITE"], [key]]: - val = values[f"PATCH COMPOSITE||{key}"] + case [['PATCH', 'COMPOSITE'], [key]]: + val = values[f'PATCH COMPOSITE||{key}'] index = int(key[-1]) - 1 self.vm.patch.composite[index].set(util.get_patch_composite_list(self.kind).index(val) + 1) self.TKroot.after(200, self.nvda.speak, val) - case [["PATCH", "COMPOSITE"], [key], ["FOCUS", "IN"]]: + case [['PATCH', 'COMPOSITE'], [key], ['FOCUS', 'IN']]: if self.find_element_with_focus() is not None: - if values[f"PATCH COMPOSITE||{key}"]: - val = values[f"PATCH COMPOSITE||{key}"] + if values[f'PATCH COMPOSITE||{key}']: + val = values[f'PATCH COMPOSITE||{key}'] else: index = int(key[-1]) - 1 comp_index = self.vm.patch.composite[index].get() @@ -604,486 +604,486 @@ class NVDAVMWindow(psg.Window): val = comp_list[comp_index - 1] except IndexError as e: val = comp_list[-1] - self.logger.error(f"{type(e).__name__}: {e}") - self.nvda.speak(f"Patch COMPOSITE {key[-1]} {val}") - case [["PATCH", "COMPOSITE"], [key], ["KEY", "SPACE" | "ENTER"]]: - util.open_context_menu_for_buttonmenu(self, f"PATCH COMPOSITE||{key}") + self.logger.error(f'{type(e).__name__}: {e}') + self.nvda.speak(f'Patch COMPOSITE {key[-1]} {val}') + case [['PATCH', 'COMPOSITE'], [key], ['KEY', 'SPACE' | 'ENTER']]: + util.open_context_menu_for_buttonmenu(self, f'PATCH COMPOSITE||{key}') # Patch INSERT - case [["INSERT", "CHECKBOX"], [in_num, channel]]: + case [['INSERT', 'CHECKBOX'], [in_num, channel]]: index = util.get_insert_checkbox_index( self.kind, int(channel), int(in_num[-1]), ) - val = values[f"INSERT CHECKBOX||{in_num} {channel}"] + val = values[f'INSERT CHECKBOX||{in_num} {channel}'] self.vm.patch.insert[index].on = val - self.nvda.speak("on" if val else "off") - case [["INSERT", "CHECKBOX"], [in_num, channel], ["FOCUS", "IN"]]: + self.nvda.speak('on' if val else 'off') + case [['INSERT', 'CHECKBOX'], [in_num, channel], ['FOCUS', 'IN']]: if self.find_element_with_focus() is not None: index = util.get_insert_checkbox_index( self.kind, int(channel), int(in_num[-1]), ) - val = values[f"INSERT CHECKBOX||{in_num} {channel}"] + val = values[f'INSERT CHECKBOX||{in_num} {channel}'] channel = util._patch_insert_channels[int(channel)] num = int(in_num[-1]) - self.nvda.speak(f"Patch INSERT IN#{num} {channel} {'on' if val else 'off'}") - case [["INSERT", "CHECKBOX"], [in_num, channel], ["KEY", "ENTER"]]: - val = not values[f"INSERT CHECKBOX||{in_num} {channel}"] - self.write_event_value(f"INSERT CHECKBOX||{in_num} {channel}", val) + self.nvda.speak(f'Patch INSERT IN#{num} {channel} {"on" if val else "off"}') + case [['INSERT', 'CHECKBOX'], [in_num, channel], ['KEY', 'ENTER']]: + val = not values[f'INSERT CHECKBOX||{in_num} {channel}'] + self.write_event_value(f'INSERT CHECKBOX||{in_num} {channel}', val) # Advanced Settings - case ["ADVANCED SETTINGS"]: - if values["tabgroup"] == "tab||Settings": - self.popup.advanced_settings(title="Advanced Settings") - case [["ADVANCED", "SETTINGS"], ["FOCUS", "IN"]]: - self.nvda.speak("ADVANCED SETTINGS") - case [["ADVANCED", "SETTINGS"], ["KEY", "ENTER"]]: + case ['ADVANCED SETTINGS']: + if values['tabgroup'] == 'tab||Settings': + self.popup.advanced_settings(title='Advanced Settings') + case [['ADVANCED', 'SETTINGS'], ['FOCUS', 'IN']]: + self.nvda.speak('ADVANCED SETTINGS') + case [['ADVANCED', 'SETTINGS'], ['KEY', 'ENTER']]: self.find_element_with_focus().click() # Strip Params - case [["STRIP", index], [param]]: + case [['STRIP', index], [param]]: match param: - case "KARAOKE": - opts = ["off", "k m", "k 1", "k 2", "k v"] + case 'KARAOKE': + opts = ['off', 'k m', 'k 1', 'k 2', 'k v'] next_val = self.vm.strip[int(index)].k + 1 if next_val == len(opts): next_val = 0 self.vm.strip[int(index)].k = next_val - self.cache["strip"][f"STRIP {index}||{param}"] = next_val + self.cache['strip'][f'STRIP {index}||{param}'] = next_val self.nvda.speak(opts[next_val]) case output if param in util._get_bus_assignments(self.kind): - val = not self.cache["strip"][f"STRIP {index}||{output}"] + val = not self.cache['strip'][f'STRIP {index}||{output}'] setattr(self.vm.strip[int(index)], output, val) - self.cache["strip"][f"STRIP {index}||{output}"] = val - self.nvda.speak("on" if val else "off") + self.cache['strip'][f'STRIP {index}||{output}'] = val + self.nvda.speak('on' if val else 'off') case _: - val = not self.cache["strip"][f"STRIP {index}||{param}"] + val = not self.cache['strip'][f'STRIP {index}||{param}'] setattr(self.vm.strip[int(index)], param.lower(), val) - self.cache["strip"][f"STRIP {index}||{param}"] = val - self.nvda.speak("on" if val else "off") - case [["STRIP", index], [param], ["FOCUS", "IN"]]: + self.cache['strip'][f'STRIP {index}||{param}'] = val + self.nvda.speak('on' if val else 'off') + case [['STRIP', index], [param], ['FOCUS', 'IN']]: if self.find_element_with_focus() is not None: - val = self.cache["strip"][f"STRIP {index}||{param}"] - phonetic = {"KARAOKE": "karaoke"} - label = self.cache["labels"][f"STRIP {index}||LABEL"] - if param == "KARAOKE": + val = self.cache['strip'][f'STRIP {index}||{param}'] + phonetic = {'KARAOKE': 'karaoke'} + label = self.cache['labels'][f'STRIP {index}||LABEL'] + if param == 'KARAOKE': self.nvda.speak( - f"{label} {phonetic.get(param, param)} {['off', 'k m', 'k 1', 'k 2', 'k v'][self.cache['strip'][f'STRIP {int(index)}||{param}']]}" + f'{label} {phonetic.get(param, param)} {["off", "k m", "k 1", "k 2", "k v"][self.cache["strip"][f"STRIP {int(index)}||{param}"]]}' ) else: - self.nvda.speak(f"{label} {phonetic.get(param, param)} {'on' if val else 'off'}") - case [["STRIP", index], [param], ["KEY", "ENTER"]]: + self.nvda.speak(f'{label} {phonetic.get(param, param)} {"on" if val else "off"}') + case [['STRIP', index], [param], ['KEY', 'ENTER']]: self.find_element_with_focus().click() # Strip Sliders case [ - ["STRIP", index], + ['STRIP', index], [ - "SLIDER", - "GAIN" - | "COMP" - | "GATE" - | "DENOISER" - | "AUDIBILITY" - | "LIMIT" - | "BASS" - | "MID" - | "TREBLE" as param, + 'SLIDER', + 'GAIN' + | 'COMP' + | 'GATE' + | 'DENOISER' + | 'AUDIBILITY' + | 'LIMIT' + | 'BASS' + | 'MID' + | 'TREBLE' as param, ], ]: val = values[event] match param: - case "GAIN": + case 'GAIN': self.vm.strip[int(index)].gain = val - case "COMP" | "GATE" | "DENOISER": + case 'COMP' | 'GATE' | 'DENOISER': target = getattr(self.vm.strip[int(index)], param.lower()) target.knob = val - case "AUDIBILITY": + case 'AUDIBILITY': self.vm.strip[int(index)].audibility = val - case "LIMIT": + case 'LIMIT': val = int(val) self.vm.strip[int(index)].limit = val - case "BASS" | "MID" | "TREBLE": + case 'BASS' | 'MID' | 'TREBLE': setattr(self.vm.strip[int(index)], param.lower(), val) case [ - ["STRIP", index], + ['STRIP', index], [ - "SLIDER", - "GAIN" - | "COMP" - | "GATE" - | "DENOISER" - | "AUDIBILITY" - | "LIMIT" - | "BASS" - | "MID" - | "TREBLE" as param, + 'SLIDER', + 'GAIN' + | 'COMP' + | 'GATE' + | 'DENOISER' + | 'AUDIBILITY' + | 'LIMIT' + | 'BASS' + | 'MID' + | 'TREBLE' as param, ], - ["FOCUS", "IN"], + ['FOCUS', 'IN'], ]: if self.find_element_with_focus() is not None: - val = values[f"STRIP {index}||SLIDER {param}"] - label = self.cache["labels"][f"STRIP {index}||LABEL"] - self.nvda.speak(f"{label} {param} {int(val) if param == 'LIMIT' else val}") + val = values[f'STRIP {index}||SLIDER {param}'] + label = self.cache['labels'][f'STRIP {index}||LABEL'] + self.nvda.speak(f'{label} {param} {int(val) if param == "LIMIT" else val}') case [ - ["STRIP", index], + ['STRIP', index], [ - "SLIDER", - "GAIN" | "COMP" | "GATE" | "DENOISER" | "AUDIBILITY" | "LIMIT" | "BASS" | "MID" | "TREBLE", + 'SLIDER', + 'GAIN' | 'COMP' | 'GATE' | 'DENOISER' | 'AUDIBILITY' | 'LIMIT' | 'BASS' | 'MID' | 'TREBLE', ], - ["FOCUS", "OUT"], + ['FOCUS', 'OUT'], ]: pass case [ - ["STRIP", index], + ['STRIP', index], [ - "SLIDER", - "GAIN" - | "COMP" - | "GATE" - | "DENOISER" - | "AUDIBILITY" - | "LIMIT" - | "BASS" - | "MID" - | "TREBLE" as param, + 'SLIDER', + 'GAIN' + | 'COMP' + | 'GATE' + | 'DENOISER' + | 'AUDIBILITY' + | 'LIMIT' + | 'BASS' + | 'MID' + | 'TREBLE' as param, ], - ["KEY", "LEFT" | "RIGHT" | "UP" | "DOWN" as direction, "PRESS" | "RELEASE" as e], + ['KEY', 'LEFT' | 'RIGHT' | 'UP' | 'DOWN' as direction, 'PRESS' | 'RELEASE' as e], ]: - if e == "PRESS": + if e == 'PRESS': self.vm.event.pdirty = False match param: - case "GAIN": + case 'GAIN': val = self.vm.strip[int(index)].gain - case "COMP" | "GATE" | "DENOISER": + case 'COMP' | 'GATE' | 'DENOISER': target = getattr(self.vm.strip[int(index)], param.lower()) val = target.knob - case "AUDIBILITY": + case 'AUDIBILITY': val = self.vm.strip[int(index)].audibility - case "BASS" | "MID" | "TREBLE": + case 'BASS' | 'MID' | 'TREBLE': val = getattr(self.vm.strip[int(index)], param.lower()) - case "LIMIT": + case 'LIMIT': val = self.vm.strip[int(index)].limit match direction: - case "RIGHT" | "UP": + case 'RIGHT' | 'UP': val += 1 - case "LEFT" | "DOWN": + case 'LEFT' | 'DOWN': val -= 1 match param: - case "GAIN": + case 'GAIN': val = util.check_bounds(val, (-60, 12)) self.vm.strip[int(index)].gain = val - self[f"STRIP {index}||SLIDER {param}"].update(value=val) - case "COMP" | "GATE" | "DENOISER": + self[f'STRIP {index}||SLIDER {param}'].update(value=val) + case 'COMP' | 'GATE' | 'DENOISER': val = util.check_bounds(val, (0, 10)) - setattr(target, "knob", val) - self[f"STRIP {index}||SLIDER {param}"].update(value=val) - case "AUDIBILITY": + setattr(target, 'knob', val) + self[f'STRIP {index}||SLIDER {param}'].update(value=val) + case 'AUDIBILITY': val = util.check_bounds(val, (0, 10)) self.vm.strip[int(index)].audibility = val - self[f"STRIP {index}||SLIDER {param}"].update(value=val) - case "BASS" | "MID" | "TREBLE": + self[f'STRIP {index}||SLIDER {param}'].update(value=val) + case 'BASS' | 'MID' | 'TREBLE': val = util.check_bounds(val, (-12, 12)) setattr(self.vm.strip[int(index)], param.lower(), val) - self[f"STRIP {index}||SLIDER {param}"].update(value=val) - case "LIMIT": + self[f'STRIP {index}||SLIDER {param}'].update(value=val) + case 'LIMIT': val = util.check_bounds(val, (-40, 12)) self.vm.strip[int(index)].limit = val - self[f"STRIP {index}||SLIDER {param}"].update(value=val) + self[f'STRIP {index}||SLIDER {param}'].update(value=val) self.nvda.speak(str(round(val, 1))) else: self.vm.event.pdirty = True case [ - ["STRIP", index], + ['STRIP', index], [ - "SLIDER", - "GAIN" - | "COMP" - | "GATE" - | "DENOISER" - | "AUDIBILITY" - | "LIMIT" - | "BASS" - | "MID" - | "TREBLE" as param, + 'SLIDER', + 'GAIN' + | 'COMP' + | 'GATE' + | 'DENOISER' + | 'AUDIBILITY' + | 'LIMIT' + | 'BASS' + | 'MID' + | 'TREBLE' as param, ], - ["KEY", "CTRL", "LEFT" | "RIGHT" | "UP" | "DOWN" as direction, "PRESS" | "RELEASE" as e], + ['KEY', 'CTRL', 'LEFT' | 'RIGHT' | 'UP' | 'DOWN' as direction, 'PRESS' | 'RELEASE' as e], ]: - if e == "PRESS": + if e == 'PRESS': self.vm.event.pdirty = False match param: - case "GAIN": + case 'GAIN': val = self.vm.strip[int(index)].gain - case "COMP" | "GATE" | "DENOISER": + case 'COMP' | 'GATE' | 'DENOISER': target = getattr(self.vm.strip[int(index)], param.lower()) val = target.knob - case "AUDIBILITY": + case 'AUDIBILITY': val = self.vm.strip[int(index)].audibility - case "BASS" | "MID" | "TREBLE": + case 'BASS' | 'MID' | 'TREBLE': val = getattr(self.vm.strip[int(index)], param.lower()) - case "LIMIT": + case 'LIMIT': val = self.vm.strip[int(index)].limit match direction: - case "RIGHT" | "UP": - if param in ("COMP", "GATE", "DENOISER", "AUDIBILITY", "BASS", "MID", "TREBLE"): + case 'RIGHT' | 'UP': + if param in ('COMP', 'GATE', 'DENOISER', 'AUDIBILITY', 'BASS', 'MID', 'TREBLE'): val += 1 else: val += 3 - case "LEFT" | "DOWN": - if param in ("COMP", "GATE", "DENOISER", "AUDIBILITY", "BASS", "MID", "TREBLE"): + case 'LEFT' | 'DOWN': + if param in ('COMP', 'GATE', 'DENOISER', 'AUDIBILITY', 'BASS', 'MID', 'TREBLE'): val -= 1 else: val -= 3 match param: - case "GAIN": + case 'GAIN': val = util.check_bounds(val, (-60, 12)) self.vm.strip[int(index)].gain = val - self[f"STRIP {index}||SLIDER {param}"].update(value=val) - case "COMP" | "GATE" | "DENOISER": + self[f'STRIP {index}||SLIDER {param}'].update(value=val) + case 'COMP' | 'GATE' | 'DENOISER': val = util.check_bounds(val, (0, 10)) - setattr(target, "knob", val) - self[f"STRIP {index}||SLIDER {param}"].update(value=val) - case "AUDIBILITY": + setattr(target, 'knob', val) + self[f'STRIP {index}||SLIDER {param}'].update(value=val) + case 'AUDIBILITY': val = util.check_bounds(val, (0, 10)) self.vm.strip[int(index)].audibility = val - self[f"STRIP {index}||SLIDER {param}"].update(value=val) - case "BASS" | "MID" | "TREBLE": + self[f'STRIP {index}||SLIDER {param}'].update(value=val) + case 'BASS' | 'MID' | 'TREBLE': val = util.check_bounds(val, (-12, 12)) setattr(self.vm.strip[int(index)], param.lower(), val) - self[f"STRIP {index}||SLIDER {param}"].update(value=val) - case "LIMIT": + self[f'STRIP {index}||SLIDER {param}'].update(value=val) + case 'LIMIT': val = util.check_bounds(val, (-40, 12)) self.vm.strip[int(index)].limit = val - self[f"STRIP {index}||SLIDER {param}"].update(value=val) - if param == "LIMIT": + self[f'STRIP {index}||SLIDER {param}'].update(value=val) + if param == 'LIMIT': self.nvda.speak(str(int(val))) else: self.nvda.speak(str(round(val, 1))) else: self.vm.event.pdirty = True case [ - ["STRIP", index], + ['STRIP', index], [ - "SLIDER", - "GAIN" - | "COMP" - | "GATE" - | "DENOISER" - | "AUDIBILITY" - | "LIMIT" - | "BASS" - | "MID" - | "TREBLE" as param, + 'SLIDER', + 'GAIN' + | 'COMP' + | 'GATE' + | 'DENOISER' + | 'AUDIBILITY' + | 'LIMIT' + | 'BASS' + | 'MID' + | 'TREBLE' as param, ], - ["KEY", "SHIFT", "LEFT" | "RIGHT" | "UP" | "DOWN" as direction, "PRESS" | "RELEASE" as e], + ['KEY', 'SHIFT', 'LEFT' | 'RIGHT' | 'UP' | 'DOWN' as direction, 'PRESS' | 'RELEASE' as e], ]: - if e == "PRESS": + if e == 'PRESS': self.vm.event.pdirty = False match param: - case "GAIN": + case 'GAIN': val = self.vm.strip[int(index)].gain - case "COMP" | "GATE" | "DENOISER": + case 'COMP' | 'GATE' | 'DENOISER': target = getattr(self.vm.strip[int(index)], param.lower()) val = target.knob - case "AUDIBILITY": + case 'AUDIBILITY': val = self.vm.strip[int(index)].audibility - case "BASS" | "MID" | "TREBLE": + case 'BASS' | 'MID' | 'TREBLE': val = getattr(self.vm.strip[int(index)], param.lower()) - case "LIMIT": + case 'LIMIT': val = self.vm.strip[int(index)].limit match direction: - case "RIGHT" | "UP": - if param == "LIMIT": + case 'RIGHT' | 'UP': + if param == 'LIMIT': val += 1 else: val += 0.1 - case "LEFT" | "DOWN": - if param == "LIMIT": + case 'LEFT' | 'DOWN': + if param == 'LIMIT': val -= 1 else: val -= 0.1 match param: - case "GAIN": + case 'GAIN': val = util.check_bounds(val, (-60, 12)) self.vm.strip[int(index)].gain = val - self[f"STRIP {index}||SLIDER {param}"].update(value=val) - case "COMP" | "GATE" | "DENOISER": + self[f'STRIP {index}||SLIDER {param}'].update(value=val) + case 'COMP' | 'GATE' | 'DENOISER': val = util.check_bounds(val, (0, 10)) - setattr(target, "knob", val) - self[f"STRIP {index}||SLIDER {param}"].update(value=val) - case "AUDIBILITY": + setattr(target, 'knob', val) + self[f'STRIP {index}||SLIDER {param}'].update(value=val) + case 'AUDIBILITY': val = util.check_bounds(val, (0, 10)) self.vm.strip[int(index)].audibility = val - self[f"STRIP {index}||SLIDER {param}"].update(value=val) - case "BASS" | "MID" | "TREBLE": + self[f'STRIP {index}||SLIDER {param}'].update(value=val) + case 'BASS' | 'MID' | 'TREBLE': val = util.check_bounds(val, (-12, 12)) setattr(self.vm.strip[int(index)], param.lower(), val) - self[f"STRIP {index}||SLIDER {param}"].update(value=val) - case "LIMIT": + self[f'STRIP {index}||SLIDER {param}'].update(value=val) + case 'LIMIT': val = util.check_bounds(val, (-40, 12)) self.vm.strip[int(index)].limit = val - self[f"STRIP {index}||SLIDER {param}"].update(value=val) - if param == "LIMIT": + self[f'STRIP {index}||SLIDER {param}'].update(value=val) + if param == 'LIMIT': self.nvda.speak(str(int(val))) else: self.nvda.speak(str(round(val, 1))) else: self.vm.event.pdirty = True - case [["STRIP", index], ["SLIDER", param], ["KEY", "CTRL", "SHIFT", "R"]]: + case [['STRIP', index], ['SLIDER', param], ['KEY', 'CTRL', 'SHIFT', 'R']]: match param: - case "GAIN": + case 'GAIN': self.vm.strip[int(index)].gain = 0 - self[f"STRIP {index}||SLIDER {param}"].update(value=0) - case "COMP" | "GATE" | "DENOISER": + self[f'STRIP {index}||SLIDER {param}'].update(value=0) + case 'COMP' | 'GATE' | 'DENOISER': target = getattr(self.vm.strip[int(index)], param.lower()) - setattr(target, "knob", 0) - self[f"STRIP {index}||SLIDER {param}"].update(value=0) - case "AUDIBILITY": + setattr(target, 'knob', 0) + self[f'STRIP {index}||SLIDER {param}'].update(value=0) + case 'AUDIBILITY': self.vm.strip[int(index)].audibility = 0 - self[f"STRIP {index}||SLIDER {param}"].update(value=0) - case "BASS" | "MID" | "TREBLE": + self[f'STRIP {index}||SLIDER {param}'].update(value=0) + case 'BASS' | 'MID' | 'TREBLE': setattr(self.vm.strip[int(index)], param.lower(), 0) - self[f"STRIP {index}||SLIDER {param}"].update(value=0) - case "LIMIT": + self[f'STRIP {index}||SLIDER {param}'].update(value=0) + case 'LIMIT': self.vm.strip[int(index)].limit = 12 - self[f"STRIP {index}||SLIDER {param}"].update(value=12) - self.nvda.speak(f"{12 if param == 'LIMIT' else 0}") + self[f'STRIP {index}||SLIDER {param}'].update(value=12) + self.nvda.speak(f'{12 if param == "LIMIT" else 0}') # Bus Params - case [["BUS", index], [param]]: - val = self.cache["bus"][event] - label = self.cache["labels"][f"BUS {index}||LABEL"] + case [['BUS', index], [param]]: + val = self.cache['bus'][event] + label = self.cache['labels'][f'BUS {index}||LABEL'] match param: - case "EQ": + case 'EQ': val = not val self.vm.bus[int(index)].eq.on = val - self.cache["bus"][event] = val + self.cache['bus'][event] = val self.TKroot.after( 200, self.nvda.speak, - "on" if val else "off", + 'on' if val else 'off', ) - case "MONO" | "MUTE": + case 'MONO' | 'MUTE': val = not val setattr(self.vm.bus[int(index)], param.lower(), val) - self.cache["bus"][event] = val + self.cache['bus'][event] = val self.TKroot.after( 200, self.nvda.speak, - "on" if val else "off", + 'on' if val else 'off', ) - case "MODE": + case 'MODE': chosen = util._bus_mode_map_reversed[values[event]] setattr(self.vm.bus[int(index)].mode, chosen, True) - self.cache["bus"][event] = chosen + self.cache['bus'][event] = chosen self.TKroot.after( 200, self.nvda.speak, util._bus_mode_map[chosen], ) - case [["BUS", index], [param], ["FOCUS", "IN"]]: + case [['BUS', index], [param], ['FOCUS', 'IN']]: if self.find_element_with_focus() is not None: - label = self.cache["labels"][f"BUS {index}||LABEL"] - val = self.cache["bus"][f"BUS {index}||{param}"] - if param == "MODE": - self.nvda.speak(f"{label} bus {param} {util._bus_mode_map[val]}") + label = self.cache['labels'][f'BUS {index}||LABEL'] + val = self.cache['bus'][f'BUS {index}||{param}'] + if param == 'MODE': + self.nvda.speak(f'{label} bus {param} {util._bus_mode_map[val]}') else: - self.nvda.speak(f"{label} {param} {'on' if val else 'off'}") - case [["BUS", index], [param], ["KEY", "SPACE" | "ENTER"]]: - if param == "MODE": - util.open_context_menu_for_buttonmenu(self, f"BUS {index}||MODE") + self.nvda.speak(f'{label} {param} {"on" if val else "off"}') + case [['BUS', index], [param], ['KEY', 'SPACE' | 'ENTER']]: + if param == 'MODE': + util.open_context_menu_for_buttonmenu(self, f'BUS {index}||MODE') else: self.find_element_with_focus().click() # Bus Sliders - case [["BUS", index], ["SLIDER", "GAIN"]]: - label = self.cache["labels"][f"BUS {index}||LABEL"] + case [['BUS', index], ['SLIDER', 'GAIN']]: + label = self.cache['labels'][f'BUS {index}||LABEL'] val = values[event] self.vm.bus[int(index)].gain = val - case [["BUS", index], ["SLIDER", "GAIN"], ["FOCUS", "IN"]]: + case [['BUS', index], ['SLIDER', 'GAIN'], ['FOCUS', 'IN']]: if self.find_element_with_focus() is not None: - label = self.cache["labels"][f"BUS {index}||LABEL"] - val = values[f"BUS {index}||SLIDER GAIN"] - self.nvda.speak(f"{label} gain {val}") - case [["BUS", index], ["SLIDER", "GAIN"], ["FOCUS", "OUT"]]: + label = self.cache['labels'][f'BUS {index}||LABEL'] + val = values[f'BUS {index}||SLIDER GAIN'] + self.nvda.speak(f'{label} gain {val}') + case [['BUS', index], ['SLIDER', 'GAIN'], ['FOCUS', 'OUT']]: pass case [ - ["BUS", index], - ["SLIDER", "GAIN"], - ["KEY", "LEFT" | "RIGHT" | "UP" | "DOWN" as direction, "PRESS" | "RELEASE" as e], + ['BUS', index], + ['SLIDER', 'GAIN'], + ['KEY', 'LEFT' | 'RIGHT' | 'UP' | 'DOWN' as direction, 'PRESS' | 'RELEASE' as e], ]: - if e == "PRESS": + if e == 'PRESS': self.vm.event.pdirty = False val = self.vm.bus[int(index)].gain match direction: - case "RIGHT" | "UP": + case 'RIGHT' | 'UP': val += 1 - case "LEFT" | "DOWN": + case 'LEFT' | 'DOWN': val -= 1 val = util.check_bounds(val, (-60, 12)) self.vm.bus[int(index)].gain = val - self[f"BUS {index}||SLIDER GAIN"].update(value=val) + self[f'BUS {index}||SLIDER GAIN'].update(value=val) self.nvda.speak(str(round(val, 1))) else: self.vm.event.pdirty = True case [ - ["BUS", index], - ["SLIDER", "GAIN"], - ["KEY", "CTRL", "LEFT" | "RIGHT" | "UP" | "DOWN" as direction, "PRESS" | "RELEASE" as e], + ['BUS', index], + ['SLIDER', 'GAIN'], + ['KEY', 'CTRL', 'LEFT' | 'RIGHT' | 'UP' | 'DOWN' as direction, 'PRESS' | 'RELEASE' as e], ]: - if e == "PRESS": + if e == 'PRESS': self.vm.event.pdirty = False val = self.vm.bus[int(index)].gain match direction: - case "RIGHT" | "UP": + case 'RIGHT' | 'UP': val += 3 - case "LEFT" | "DOWN": + case 'LEFT' | 'DOWN': val -= 3 val = util.check_bounds(val, (-60, 12)) self.vm.bus[int(index)].gain = val - self[f"BUS {index}||SLIDER GAIN"].update(value=val) + self[f'BUS {index}||SLIDER GAIN'].update(value=val) self.nvda.speak(str(round(val, 1))) else: self.vm.event.pdirty = True case [ - ["BUS", index], - ["SLIDER", "GAIN"], - ["KEY", "SHIFT", "LEFT" | "RIGHT" | "UP" | "DOWN" as direction, "PRESS" | "RELEASE" as e], + ['BUS', index], + ['SLIDER', 'GAIN'], + ['KEY', 'SHIFT', 'LEFT' | 'RIGHT' | 'UP' | 'DOWN' as direction, 'PRESS' | 'RELEASE' as e], ]: - if e == "PRESS": + if e == 'PRESS': self.vm.event.pdirty = False val = self.vm.bus[int(index)].gain match direction: - case "RIGHT" | "UP": + case 'RIGHT' | 'UP': val += 0.1 - case "LEFT" | "DOWN": + case 'LEFT' | 'DOWN': val -= 0.1 val = util.check_bounds(val, (-60, 12)) self.vm.bus[int(index)].gain = val - self[f"BUS {index}||SLIDER GAIN"].update(value=val) + self[f'BUS {index}||SLIDER GAIN'].update(value=val) self.nvda.speak(str(round(val, 1))) else: self.vm.event.pdirty = True - case [["BUS", index], ["SLIDER", "GAIN"], ["KEY", "CTRL", "SHIFT", "R"]]: + case [['BUS', index], ['SLIDER', 'GAIN'], ['KEY', 'CTRL', 'SHIFT', 'R']]: self.vm.bus[int(index)].gain = 0 - self[f"BUS {index}||SLIDER GAIN"].update(value=0) + self[f'BUS {index}||SLIDER GAIN'].update(value=0) self.nvda.speak(str(0)) # Unknown case _: - self.logger.debug(f"Unknown event {event}") - self.logger.debug(f"parsed::{parsed_cmd}") + self.logger.debug(f'Unknown event {event}') + self.logger.debug(f'parsed::{parsed_cmd}') def request_window_object(kind_id, vm): NVDAVMWindow_cls = NVDAVMWindow - return NVDAVMWindow_cls(f"Voicemeeter {kind_id.capitalize()} NVDA", vm) + return NVDAVMWindow_cls(f'Voicemeeter {kind_id.capitalize()} NVDA', vm)