every_holiday/VRCT
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

👍️[Update] UI: backendのendpointに合わせて修正

Browse Source
This commit is contained in:
misyaguziya
2024-09-20 05:14:51 +09:00
parent d3b66b7000
commit ca6514b090
24 changed files with 700 additions and 705 deletions
Download Patch File Download Diff File Expand all files Collapse all files

476
src-python/config.py
View File

@@ -39,8 +39,8 @@ class Config:
return self._VERSION return self._VERSION
@property @property
def ENABLE_SPEAKER2CHATBOX_PASS_CONFIRMATION(self): def SPEAKER2CHATBOX_PASS_CONFIRMATION(self):
return self._ENABLE_SPEAKER2CHATBOX_PASS_CONFIRMATION return self._SPEAKER2CHATBOX_PASS_CONFIRMATION
@property @property
def PATH_LOCAL(self): def PATH_LOCAL(self):
@@ -293,47 +293,47 @@ class Config:
# saveJson(self.PATH_CONFIG, inspect.currentframe().f_code.co_name, value) # saveJson(self.PATH_CONFIG, inspect.currentframe().f_code.co_name, value)
@property @property
@json_serializable('ENABLE_MULTI_LANGUAGE_TRANSLATION') @json_serializable('MULTI_LANGUAGE_TRANSLATION')
def ENABLE_MULTI_LANGUAGE_TRANSLATION(self): def MULTI_LANGUAGE_TRANSLATION(self):
return self._ENABLE_MULTI_LANGUAGE_TRANSLATION return self._MULTI_LANGUAGE_TRANSLATION
@ENABLE_MULTI_LANGUAGE_TRANSLATION.setter @MULTI_LANGUAGE_TRANSLATION.setter
def ENABLE_MULTI_LANGUAGE_TRANSLATION(self, value): def MULTI_LANGUAGE_TRANSLATION(self, value):
if isinstance(value, bool): if isinstance(value, bool):
self._ENABLE_MULTI_LANGUAGE_TRANSLATION = value self._MULTI_LANGUAGE_TRANSLATION = value
saveJson(self.PATH_CONFIG, inspect.currentframe().f_code.co_name, value) saveJson(self.PATH_CONFIG, inspect.currentframe().f_code.co_name, value)
@property @property
@json_serializable('ENABLE_CONVERT_MESSAGE_TO_ROMAJI') @json_serializable('CONVERT_MESSAGE_TO_ROMAJI')
def ENABLE_CONVERT_MESSAGE_TO_ROMAJI(self): def CONVERT_MESSAGE_TO_ROMAJI(self):
return self._ENABLE_CONVERT_MESSAGE_TO_ROMAJI return self._CONVERT_MESSAGE_TO_ROMAJI
@ENABLE_CONVERT_MESSAGE_TO_ROMAJI.setter @CONVERT_MESSAGE_TO_ROMAJI.setter
def ENABLE_CONVERT_MESSAGE_TO_ROMAJI(self, value): def CONVERT_MESSAGE_TO_ROMAJI(self, value):
if isinstance(value, bool): if isinstance(value, bool):
self._ENABLE_CONVERT_MESSAGE_TO_ROMAJI = value self._CONVERT_MESSAGE_TO_ROMAJI = value
saveJson(self.PATH_CONFIG, inspect.currentframe().f_code.co_name, value) saveJson(self.PATH_CONFIG, inspect.currentframe().f_code.co_name, value)
@property @property
@json_serializable('ENABLE_CONVERT_MESSAGE_TO_HIRAGANA') @json_serializable('CONVERT_MESSAGE_TO_HIRAGANA')
def ENABLE_CONVERT_MESSAGE_TO_HIRAGANA(self): def CONVERT_MESSAGE_TO_HIRAGANA(self):
return self._ENABLE_CONVERT_MESSAGE_TO_HIRAGANA return self._CONVERT_MESSAGE_TO_HIRAGANA
@ENABLE_CONVERT_MESSAGE_TO_HIRAGANA.setter @CONVERT_MESSAGE_TO_HIRAGANA.setter
def ENABLE_CONVERT_MESSAGE_TO_HIRAGANA(self, value): def CONVERT_MESSAGE_TO_HIRAGANA(self, value):
if isinstance(value, bool): if isinstance(value, bool):
self._ENABLE_CONVERT_MESSAGE_TO_HIRAGANA = value self._CONVERT_MESSAGE_TO_HIRAGANA = value
saveJson(self.PATH_CONFIG, inspect.currentframe().f_code.co_name, value) saveJson(self.PATH_CONFIG, inspect.currentframe().f_code.co_name, value)
@property @property
@json_serializable('ENABLE_MAIN_WINDOW_SIDEBAR_COMPACT_MODE') @json_serializable('MAIN_WINDOW_SIDEBAR_COMPACT_MODE')
def ENABLE_MAIN_WINDOW_SIDEBAR_COMPACT_MODE(self): def MAIN_WINDOW_SIDEBAR_COMPACT_MODE(self):
return self._ENABLE_MAIN_WINDOW_SIDEBAR_COMPACT_MODE return self._MAIN_WINDOW_SIDEBAR_COMPACT_MODE
@ENABLE_MAIN_WINDOW_SIDEBAR_COMPACT_MODE.setter @MAIN_WINDOW_SIDEBAR_COMPACT_MODE.setter
def ENABLE_MAIN_WINDOW_SIDEBAR_COMPACT_MODE(self, value): def MAIN_WINDOW_SIDEBAR_COMPACT_MODE(self, value):
if isinstance(value, bool): if isinstance(value, bool):
self._ENABLE_MAIN_WINDOW_SIDEBAR_COMPACT_MODE = value self._MAIN_WINDOW_SIDEBAR_COMPACT_MODE = value
saveJson(self.PATH_CONFIG, inspect.currentframe().f_code.co_name, value) saveJson(self.PATH_CONFIG, inspect.currentframe().f_code.co_name, value)
## Config Window ## Config Window
@@ -418,14 +418,14 @@ class Config:
saveJson(self.PATH_CONFIG, inspect.currentframe().f_code.co_name, value) saveJson(self.PATH_CONFIG, inspect.currentframe().f_code.co_name, value)
@property @property
@json_serializable('ENABLE_RESTORE_MAIN_WINDOW_GEOMETRY') @json_serializable('RESTORE_MAIN_WINDOW_GEOMETRY')
def ENABLE_RESTORE_MAIN_WINDOW_GEOMETRY(self): def RESTORE_MAIN_WINDOW_GEOMETRY(self):
return self._ENABLE_RESTORE_MAIN_WINDOW_GEOMETRY return self._RESTORE_MAIN_WINDOW_GEOMETRY
@ENABLE_RESTORE_MAIN_WINDOW_GEOMETRY.setter @RESTORE_MAIN_WINDOW_GEOMETRY.setter
def ENABLE_RESTORE_MAIN_WINDOW_GEOMETRY(self, value): def RESTORE_MAIN_WINDOW_GEOMETRY(self, value):
if isinstance(value, bool): if isinstance(value, bool):
self._ENABLE_RESTORE_MAIN_WINDOW_GEOMETRY = value self._RESTORE_MAIN_WINDOW_GEOMETRY = value
saveJson(self.PATH_CONFIG, inspect.currentframe().f_code.co_name, value) saveJson(self.PATH_CONFIG, inspect.currentframe().f_code.co_name, value)
@property @property
@@ -442,223 +442,223 @@ class Config:
saveJson(self.PATH_CONFIG, inspect.currentframe().f_code.co_name, self.MAIN_WINDOW_GEOMETRY) saveJson(self.PATH_CONFIG, inspect.currentframe().f_code.co_name, self.MAIN_WINDOW_GEOMETRY)
@property @property
@json_serializable('ENABLE_MIC_AUTO_SELECTION') @json_serializable('AUTO_MIC_SELECT')
def ENABLE_MIC_AUTO_SELECTION(self): def AUTO_MIC_SELECT(self):
return self._ENABLE_MIC_AUTO_SELECTION return self._AUTO_MIC_SELECT
@ENABLE_MIC_AUTO_SELECTION.setter @AUTO_MIC_SELECT.setter
def ENABLE_MIC_AUTO_SELECTION(self, value): def AUTO_MIC_SELECT(self, value):
if isinstance(value, bool): if isinstance(value, bool):
self._ENABLE_MIC_AUTO_SELECTION = value self._AUTO_MIC_SELECT = value
saveJson(self.PATH_CONFIG, inspect.currentframe().f_code.co_name, value) saveJson(self.PATH_CONFIG, inspect.currentframe().f_code.co_name, value)
@property @property
@json_serializable('CHOICE_MIC_HOST') @json_serializable('SELECTED_MIC_HOST')
def CHOICE_MIC_HOST(self): def SELECTED_MIC_HOST(self):
return self._CHOICE_MIC_HOST return self._SELECTED_MIC_HOST
@CHOICE_MIC_HOST.setter @SELECTED_MIC_HOST.setter
def CHOICE_MIC_HOST(self, value): def SELECTED_MIC_HOST(self, value):
if value in [host for host in device_manager.getInputDevices().keys()]: if value in [host for host in device_manager.getInputDevices().keys()]:
self._CHOICE_MIC_HOST = value self._SELECTED_MIC_HOST = value
saveJson(self.PATH_CONFIG, inspect.currentframe().f_code.co_name, value) saveJson(self.PATH_CONFIG, inspect.currentframe().f_code.co_name, value)
@property @property
@json_serializable('CHOICE_MIC_DEVICE') @json_serializable('SELECTED_MIC_DEVICE')
def CHOICE_MIC_DEVICE(self): def SELECTED_MIC_DEVICE(self):
return self._CHOICE_MIC_DEVICE return self._SELECTED_MIC_DEVICE
@CHOICE_MIC_DEVICE.setter @SELECTED_MIC_DEVICE.setter
def CHOICE_MIC_DEVICE(self, value): def SELECTED_MIC_DEVICE(self, value):
if value in [device["name"] for device in device_manager.getInputDevices()[self.CHOICE_MIC_HOST]]: if value in [device["name"] for device in device_manager.getInputDevices()[self.SELECTED_MIC_HOST]]:
self._CHOICE_MIC_DEVICE = value self._SELECTED_MIC_DEVICE = value
saveJson(self.PATH_CONFIG, inspect.currentframe().f_code.co_name, value) saveJson(self.PATH_CONFIG, inspect.currentframe().f_code.co_name, value)
@property @property
@json_serializable('INPUT_MIC_ENERGY_THRESHOLD') @json_serializable('MIC_ENERGY_THRESHOLD')
def INPUT_MIC_ENERGY_THRESHOLD(self): def MIC_ENERGY_THRESHOLD(self):
return self._INPUT_MIC_ENERGY_THRESHOLD return self._MIC_ENERGY_THRESHOLD
@INPUT_MIC_ENERGY_THRESHOLD.setter @MIC_ENERGY_THRESHOLD.setter
def INPUT_MIC_ENERGY_THRESHOLD(self, value): def MIC_ENERGY_THRESHOLD(self, value):
if isinstance(value, int): if isinstance(value, int):
self._INPUT_MIC_ENERGY_THRESHOLD = value self._MIC_ENERGY_THRESHOLD = value
saveJson(self.PATH_CONFIG, inspect.currentframe().f_code.co_name, value) saveJson(self.PATH_CONFIG, inspect.currentframe().f_code.co_name, value)
@property @property
@json_serializable('INPUT_MIC_DYNAMIC_ENERGY_THRESHOLD') @json_serializable('MIC_DYNAMIC_ENERGY_THRESHOLD')
def INPUT_MIC_DYNAMIC_ENERGY_THRESHOLD(self): def MIC_DYNAMIC_ENERGY_THRESHOLD(self):
return self._INPUT_MIC_DYNAMIC_ENERGY_THRESHOLD return self._MIC_DYNAMIC_ENERGY_THRESHOLD
@INPUT_MIC_DYNAMIC_ENERGY_THRESHOLD.setter @MIC_DYNAMIC_ENERGY_THRESHOLD.setter
def INPUT_MIC_DYNAMIC_ENERGY_THRESHOLD(self, value): def MIC_DYNAMIC_ENERGY_THRESHOLD(self, value):
if isinstance(value, bool): if isinstance(value, bool):
self._INPUT_MIC_DYNAMIC_ENERGY_THRESHOLD = value self._MIC_DYNAMIC_ENERGY_THRESHOLD = value
saveJson(self.PATH_CONFIG, inspect.currentframe().f_code.co_name, value) saveJson(self.PATH_CONFIG, inspect.currentframe().f_code.co_name, value)
@property @property
@json_serializable('INPUT_MIC_RECORD_TIMEOUT') @json_serializable('MIC_RECORD_TIMEOUT')
def INPUT_MIC_RECORD_TIMEOUT(self): def MIC_RECORD_TIMEOUT(self):
return self._INPUT_MIC_RECORD_TIMEOUT return self._MIC_RECORD_TIMEOUT
@INPUT_MIC_RECORD_TIMEOUT.setter @MIC_RECORD_TIMEOUT.setter
def INPUT_MIC_RECORD_TIMEOUT(self, value): def MIC_RECORD_TIMEOUT(self, value):
if isinstance(value, int): if isinstance(value, int):
self._INPUT_MIC_RECORD_TIMEOUT = value self._MIC_RECORD_TIMEOUT = value
saveJson(self.PATH_CONFIG, inspect.currentframe().f_code.co_name, value) saveJson(self.PATH_CONFIG, inspect.currentframe().f_code.co_name, value)
@property @property
@json_serializable('INPUT_MIC_PHRASE_TIMEOUT') @json_serializable('MIC_PHRASE_TIMEOUT')
def INPUT_MIC_PHRASE_TIMEOUT(self): def MIC_PHRASE_TIMEOUT(self):
return self._INPUT_MIC_PHRASE_TIMEOUT return self._MIC_PHRASE_TIMEOUT
@INPUT_MIC_PHRASE_TIMEOUT.setter @MIC_PHRASE_TIMEOUT.setter
def INPUT_MIC_PHRASE_TIMEOUT(self, value): def MIC_PHRASE_TIMEOUT(self, value):
if isinstance(value, int): if isinstance(value, int):
self._INPUT_MIC_PHRASE_TIMEOUT = value self._MIC_PHRASE_TIMEOUT = value
saveJson(self.PATH_CONFIG, inspect.currentframe().f_code.co_name, value) saveJson(self.PATH_CONFIG, inspect.currentframe().f_code.co_name, value)
@property @property
@json_serializable('INPUT_MIC_MAX_PHRASES') @json_serializable('MIC_MAX_PHRASES')
def INPUT_MIC_MAX_PHRASES(self): def MIC_MAX_PHRASES(self):
return self._INPUT_MIC_MAX_PHRASES return self._MIC_MAX_PHRASES
@INPUT_MIC_MAX_PHRASES.setter @MIC_MAX_PHRASES.setter
def INPUT_MIC_MAX_PHRASES(self, value): def MIC_MAX_PHRASES(self, value):
if isinstance(value, int): if isinstance(value, int):
self._INPUT_MIC_MAX_PHRASES = value self._MIC_MAX_PHRASES = value
saveJson(self.PATH_CONFIG, inspect.currentframe().f_code.co_name, value) saveJson(self.PATH_CONFIG, inspect.currentframe().f_code.co_name, value)
@property @property
@json_serializable('INPUT_MIC_WORD_FILTER') @json_serializable('MIC_WORD_FILTER')
def INPUT_MIC_WORD_FILTER(self): def MIC_WORD_FILTER(self):
return self._INPUT_MIC_WORD_FILTER return self._MIC_WORD_FILTER
@INPUT_MIC_WORD_FILTER.setter @MIC_WORD_FILTER.setter
def INPUT_MIC_WORD_FILTER(self, value): def MIC_WORD_FILTER(self, value):
if isinstance(value, list): if isinstance(value, list):
self._INPUT_MIC_WORD_FILTER = sorted(set(value), key=value.index) self._MIC_WORD_FILTER = sorted(set(value), key=value.index)
saveJson(self.PATH_CONFIG, inspect.currentframe().f_code.co_name, value) saveJson(self.PATH_CONFIG, inspect.currentframe().f_code.co_name, value)
@property @property
@json_serializable('INPUT_MIC_AVG_LOGPROB') @json_serializable('MIC_AVG_LOGPROB')
def INPUT_MIC_AVG_LOGPROB(self): def MIC_AVG_LOGPROB(self):
return self._INPUT_MIC_AVG_LOGPROB return self._MIC_AVG_LOGPROB
@INPUT_MIC_AVG_LOGPROB.setter @MIC_AVG_LOGPROB.setter
def INPUT_MIC_AVG_LOGPROB(self, value): def MIC_AVG_LOGPROB(self, value):
if isinstance(value, float) or isinstance(value, int): if isinstance(value, float) or isinstance(value, int):
self._INPUT_MIC_AVG_LOGPROB = value self._MIC_AVG_LOGPROB = value
saveJson(self.PATH_CONFIG, inspect.currentframe().f_code.co_name, value) saveJson(self.PATH_CONFIG, inspect.currentframe().f_code.co_name, value)
@property @property
@json_serializable('INPUT_MIC_NO_SPEECH_PROB') @json_serializable('MIC_NO_SPEECH_PROB')
def INPUT_MIC_NO_SPEECH_PROB(self): def MIC_NO_SPEECH_PROB(self):
return self._INPUT_MIC_NO_SPEECH_PROB return self._MIC_NO_SPEECH_PROB
@INPUT_MIC_NO_SPEECH_PROB.setter @MIC_NO_SPEECH_PROB.setter
def INPUT_MIC_NO_SPEECH_PROB(self, value): def MIC_NO_SPEECH_PROB(self, value):
if isinstance(value, float) or isinstance(value, int): if isinstance(value, float) or isinstance(value, int):
self._INPUT_MIC_NO_SPEECH_PROB = value self._MIC_NO_SPEECH_PROB = value
saveJson(self.PATH_CONFIG, inspect.currentframe().f_code.co_name, value) saveJson(self.PATH_CONFIG, inspect.currentframe().f_code.co_name, value)
@property @property
@json_serializable('ENABLE_SPEAKER_AUTO_SELECTION') @json_serializable('AUTO_SPEAKER_SELECT')
def ENABLE_SPEAKER_AUTO_SELECTION(self): def AUTO_SPEAKER_SELECT(self):
return self._ENABLE_SPEAKER_AUTO_SELECTION return self._AUTO_SPEAKER_SELECT
@ENABLE_SPEAKER_AUTO_SELECTION.setter @AUTO_SPEAKER_SELECT.setter
def ENABLE_SPEAKER_AUTO_SELECTION(self, value): def AUTO_SPEAKER_SELECT(self, value):
if isinstance(value, bool): if isinstance(value, bool):
self._ENABLE_SPEAKER_AUTO_SELECTION = value self._AUTO_SPEAKER_SELECT = value
saveJson(self.PATH_CONFIG, inspect.currentframe().f_code.co_name, value) saveJson(self.PATH_CONFIG, inspect.currentframe().f_code.co_name, value)
@property @property
@json_serializable('CHOICE_SPEAKER_DEVICE') @json_serializable('SELECTED_SPEAKER_DEVICE')
def CHOICE_SPEAKER_DEVICE(self): def SELECTED_SPEAKER_DEVICE(self):
return self._CHOICE_SPEAKER_DEVICE return self._SELECTED_SPEAKER_DEVICE
@CHOICE_SPEAKER_DEVICE.setter @SELECTED_SPEAKER_DEVICE.setter
def CHOICE_SPEAKER_DEVICE(self, value): def SELECTED_SPEAKER_DEVICE(self, value):
if value in [device["name"] for device in device_manager.getOutputDevices()]: if value in [device["name"] for device in device_manager.getOutputDevices()]:
self._CHOICE_SPEAKER_DEVICE = value self._SELECTED_SPEAKER_DEVICE = value
saveJson(self.PATH_CONFIG, inspect.currentframe().f_code.co_name, value) saveJson(self.PATH_CONFIG, inspect.currentframe().f_code.co_name, value)
@property @property
@json_serializable('INPUT_SPEAKER_ENERGY_THRESHOLD') @json_serializable('SPEAKER_ENERGY_THRESHOLD')
def INPUT_SPEAKER_ENERGY_THRESHOLD(self): def SPEAKER_ENERGY_THRESHOLD(self):
return self._INPUT_SPEAKER_ENERGY_THRESHOLD return self._SPEAKER_ENERGY_THRESHOLD
@INPUT_SPEAKER_ENERGY_THRESHOLD.setter @SPEAKER_ENERGY_THRESHOLD.setter
def INPUT_SPEAKER_ENERGY_THRESHOLD(self, value): def SPEAKER_ENERGY_THRESHOLD(self, value):
if isinstance(value, int): if isinstance(value, int):
self._INPUT_SPEAKER_ENERGY_THRESHOLD = value self._SPEAKER_ENERGY_THRESHOLD = value
saveJson(self.PATH_CONFIG, inspect.currentframe().f_code.co_name, value) saveJson(self.PATH_CONFIG, inspect.currentframe().f_code.co_name, value)
@property @property
@json_serializable('INPUT_SPEAKER_DYNAMIC_ENERGY_THRESHOLD') @json_serializable('SPEAKER_DYNAMIC_ENERGY_THRESHOLD')
def INPUT_SPEAKER_DYNAMIC_ENERGY_THRESHOLD(self): def SPEAKER_DYNAMIC_ENERGY_THRESHOLD(self):
return self._INPUT_SPEAKER_DYNAMIC_ENERGY_THRESHOLD return self._SPEAKER_DYNAMIC_ENERGY_THRESHOLD
@INPUT_SPEAKER_DYNAMIC_ENERGY_THRESHOLD.setter @SPEAKER_DYNAMIC_ENERGY_THRESHOLD.setter
def INPUT_SPEAKER_DYNAMIC_ENERGY_THRESHOLD(self, value): def SPEAKER_DYNAMIC_ENERGY_THRESHOLD(self, value):
if isinstance(value, bool): if isinstance(value, bool):
self._INPUT_SPEAKER_DYNAMIC_ENERGY_THRESHOLD = value self._SPEAKER_DYNAMIC_ENERGY_THRESHOLD = value
saveJson(self.PATH_CONFIG, inspect.currentframe().f_code.co_name, value) saveJson(self.PATH_CONFIG, inspect.currentframe().f_code.co_name, value)
@property @property
@json_serializable('INPUT_SPEAKER_RECORD_TIMEOUT') @json_serializable('SPEAKER_RECORD_TIMEOUT')
def INPUT_SPEAKER_RECORD_TIMEOUT(self): def SPEAKER_RECORD_TIMEOUT(self):
return self._INPUT_SPEAKER_RECORD_TIMEOUT return self._SPEAKER_RECORD_TIMEOUT
@INPUT_SPEAKER_RECORD_TIMEOUT.setter @SPEAKER_RECORD_TIMEOUT.setter
def INPUT_SPEAKER_RECORD_TIMEOUT(self, value): def SPEAKER_RECORD_TIMEOUT(self, value):
if isinstance(value, int): if isinstance(value, int):
self._INPUT_SPEAKER_RECORD_TIMEOUT = value self._SPEAKER_RECORD_TIMEOUT = value
saveJson(self.PATH_CONFIG, inspect.currentframe().f_code.co_name, value) saveJson(self.PATH_CONFIG, inspect.currentframe().f_code.co_name, value)
@property @property
@json_serializable('INPUT_SPEAKER_PHRASE_TIMEOUT') @json_serializable('SPEAKER_PHRASE_TIMEOUT')
def INPUT_SPEAKER_PHRASE_TIMEOUT(self): def SPEAKER_PHRASE_TIMEOUT(self):
return self._INPUT_SPEAKER_PHRASE_TIMEOUT return self._SPEAKER_PHRASE_TIMEOUT
@INPUT_SPEAKER_PHRASE_TIMEOUT.setter @SPEAKER_PHRASE_TIMEOUT.setter
def INPUT_SPEAKER_PHRASE_TIMEOUT(self, value): def SPEAKER_PHRASE_TIMEOUT(self, value):
if isinstance(value, int): if isinstance(value, int):
self._INPUT_SPEAKER_PHRASE_TIMEOUT = value self._SPEAKER_PHRASE_TIMEOUT = value
saveJson(self.PATH_CONFIG, inspect.currentframe().f_code.co_name, value) saveJson(self.PATH_CONFIG, inspect.currentframe().f_code.co_name, value)
@property @property
@json_serializable('INPUT_SPEAKER_MAX_PHRASES') @json_serializable('SPEAKER_MAX_PHRASES')
def INPUT_SPEAKER_MAX_PHRASES(self): def SPEAKER_MAX_PHRASES(self):
return self._INPUT_SPEAKER_MAX_PHRASES return self._SPEAKER_MAX_PHRASES
@INPUT_SPEAKER_MAX_PHRASES.setter @SPEAKER_MAX_PHRASES.setter
def INPUT_SPEAKER_MAX_PHRASES(self, value): def SPEAKER_MAX_PHRASES(self, value):
if isinstance(value, int): if isinstance(value, int):
self._INPUT_SPEAKER_MAX_PHRASES = value self._SPEAKER_MAX_PHRASES = value
saveJson(self.PATH_CONFIG, inspect.currentframe().f_code.co_name, value) saveJson(self.PATH_CONFIG, inspect.currentframe().f_code.co_name, value)
@property @property
@json_serializable('INPUT_SPEAKER_AVG_LOGPROB') @json_serializable('SPEAKER_AVG_LOGPROB')
def INPUT_SPEAKER_AVG_LOGPROB(self): def SPEAKER_AVG_LOGPROB(self):
return self._INPUT_SPEAKER_AVG_LOGPROB return self._SPEAKER_AVG_LOGPROB
@INPUT_SPEAKER_AVG_LOGPROB.setter @SPEAKER_AVG_LOGPROB.setter
def INPUT_SPEAKER_AVG_LOGPROB(self, value): def SPEAKER_AVG_LOGPROB(self, value):
if isinstance(value, float) or isinstance(value, int): if isinstance(value, float) or isinstance(value, int):
self._INPUT_SPEAKER_AVG_LOGPROB = value self._SPEAKER_AVG_LOGPROB = value
saveJson(self.PATH_CONFIG, inspect.currentframe().f_code.co_name, value) saveJson(self.PATH_CONFIG, inspect.currentframe().f_code.co_name, value)
@property @property
@json_serializable('INPUT_SPEAKER_NO_SPEECH_PROB') @json_serializable('SPEAKER_NO_SPEECH_PROB')
def INPUT_SPEAKER_NO_SPEECH_PROB(self): def SPEAKER_NO_SPEECH_PROB(self):
return self._INPUT_SPEAKER_NO_SPEECH_PROB return self._SPEAKER_NO_SPEECH_PROB
@INPUT_SPEAKER_NO_SPEECH_PROB.setter @SPEAKER_NO_SPEECH_PROB.setter
def INPUT_SPEAKER_NO_SPEECH_PROB(self, value): def SPEAKER_NO_SPEECH_PROB(self, value):
if isinstance(value, float) or isinstance(value, int): if isinstance(value, float) or isinstance(value, int):
self._INPUT_SPEAKER_NO_SPEECH_PROB = value self._SPEAKER_NO_SPEECH_PROB = value
saveJson(self.PATH_CONFIG, inspect.currentframe().f_code.co_name, value) saveJson(self.PATH_CONFIG, inspect.currentframe().f_code.co_name, value)
@property @property
@@ -753,25 +753,25 @@ class Config:
saveJson(self.PATH_CONFIG, inspect.currentframe().f_code.co_name, value) saveJson(self.PATH_CONFIG, inspect.currentframe().f_code.co_name, value)
@property @property
@json_serializable('ENABLE_AUTO_CLEAR_MESSAGE_BOX') @json_serializable('AUTO_CLEAR_MESSAGE_BOX')
def ENABLE_AUTO_CLEAR_MESSAGE_BOX(self): def AUTO_CLEAR_MESSAGE_BOX(self):
return self._ENABLE_AUTO_CLEAR_MESSAGE_BOX return self._AUTO_CLEAR_MESSAGE_BOX
@ENABLE_AUTO_CLEAR_MESSAGE_BOX.setter @AUTO_CLEAR_MESSAGE_BOX.setter
def ENABLE_AUTO_CLEAR_MESSAGE_BOX(self, value): def AUTO_CLEAR_MESSAGE_BOX(self, value):
if isinstance(value, bool): if isinstance(value, bool):
self._ENABLE_AUTO_CLEAR_MESSAGE_BOX = value self._AUTO_CLEAR_MESSAGE_BOX = value
saveJson(self.PATH_CONFIG, inspect.currentframe().f_code.co_name, value) saveJson(self.PATH_CONFIG, inspect.currentframe().f_code.co_name, value)
@property @property
@json_serializable('ENABLE_SEND_ONLY_TRANSLATED_MESSAGES') @json_serializable('SEND_ONLY_TRANSLATED_MESSAGES')
def ENABLE_SEND_ONLY_TRANSLATED_MESSAGES(self): def SEND_ONLY_TRANSLATED_MESSAGES(self):
return self._ENABLE_SEND_ONLY_TRANSLATED_MESSAGES return self._SEND_ONLY_TRANSLATED_MESSAGES
@ENABLE_SEND_ONLY_TRANSLATED_MESSAGES.setter @SEND_ONLY_TRANSLATED_MESSAGES.setter
def ENABLE_SEND_ONLY_TRANSLATED_MESSAGES(self, value): def SEND_ONLY_TRANSLATED_MESSAGES(self, value):
if isinstance(value, bool): if isinstance(value, bool):
self._ENABLE_SEND_ONLY_TRANSLATED_MESSAGES = value self._SEND_ONLY_TRANSLATED_MESSAGES = value
saveJson(self.PATH_CONFIG, inspect.currentframe().f_code.co_name, value) saveJson(self.PATH_CONFIG, inspect.currentframe().f_code.co_name, value)
@property @property
@@ -799,14 +799,14 @@ class Config:
saveJson(self.PATH_CONFIG, inspect.currentframe().f_code.co_name, self.OVERLAY_SETTINGS) saveJson(self.PATH_CONFIG, inspect.currentframe().f_code.co_name, self.OVERLAY_SETTINGS)
@property @property
@json_serializable('ENABLE_OVERLAY_SMALL_LOG') @json_serializable('OVERLAY_SMALL_LOG')
def ENABLE_OVERLAY_SMALL_LOG(self): def OVERLAY_SMALL_LOG(self):
return self._ENABLE_OVERLAY_SMALL_LOG return self._OVERLAY_SMALL_LOG
@ENABLE_OVERLAY_SMALL_LOG.setter @OVERLAY_SMALL_LOG.setter
def ENABLE_OVERLAY_SMALL_LOG(self, value): def OVERLAY_SMALL_LOG(self, value):
if isinstance(value, bool): if isinstance(value, bool):
self._ENABLE_OVERLAY_SMALL_LOG = value self._OVERLAY_SMALL_LOG = value
saveJson(self.PATH_CONFIG, inspect.currentframe().f_code.co_name, value) saveJson(self.PATH_CONFIG, inspect.currentframe().f_code.co_name, value)
@property @property
@@ -839,14 +839,14 @@ class Config:
# saveJson(self.PATH_CONFIG, inspect.currentframe().f_code.co_name, value) # saveJson(self.PATH_CONFIG, inspect.currentframe().f_code.co_name, value)
@property @property
@json_serializable('ENABLE_SEND_MESSAGE_TO_VRC') @json_serializable('SEND_MESSAGE_TO_VRC')
def ENABLE_SEND_MESSAGE_TO_VRC(self): def SEND_MESSAGE_TO_VRC(self):
return self._ENABLE_SEND_MESSAGE_TO_VRC return self._SEND_MESSAGE_TO_VRC
@ENABLE_SEND_MESSAGE_TO_VRC.setter @SEND_MESSAGE_TO_VRC.setter
def ENABLE_SEND_MESSAGE_TO_VRC(self, value): def SEND_MESSAGE_TO_VRC(self, value):
if isinstance(value, bool): if isinstance(value, bool):
self._ENABLE_SEND_MESSAGE_TO_VRC = value self._SEND_MESSAGE_TO_VRC = value
saveJson(self.PATH_CONFIG, inspect.currentframe().f_code.co_name, value) saveJson(self.PATH_CONFIG, inspect.currentframe().f_code.co_name, value)
@property @property
@@ -903,60 +903,60 @@ class Config:
# Speaker2Chatbox------------------ # Speaker2Chatbox------------------
@property @property
@json_serializable('ENABLE_SPEAKER2CHATBOX_PASS') @json_serializable('SPEAKER2CHATBOX_PASS')
def ENABLE_SPEAKER2CHATBOX_PASS(self): def SPEAKER2CHATBOX_PASS(self):
return self._ENABLE_SPEAKER2CHATBOX_PASS return self._SPEAKER2CHATBOX_PASS
@ENABLE_SPEAKER2CHATBOX_PASS.setter @SPEAKER2CHATBOX_PASS.setter
def ENABLE_SPEAKER2CHATBOX_PASS(self, value): def SPEAKER2CHATBOX_PASS(self, value):
if isinstance(value, str): if isinstance(value, str):
self._ENABLE_SPEAKER2CHATBOX_PASS = value self._SPEAKER2CHATBOX_PASS = value
saveJson(self.PATH_CONFIG, inspect.currentframe().f_code.co_name, value) saveJson(self.PATH_CONFIG, inspect.currentframe().f_code.co_name, value)
@property @property
@json_serializable('ENABLE_SEND_RECEIVED_MESSAGE_TO_VRC') @json_serializable('SEND_RECEIVED_MESSAGE_TO_VRC')
def ENABLE_SEND_RECEIVED_MESSAGE_TO_VRC(self): def SEND_RECEIVED_MESSAGE_TO_VRC(self):
return self._ENABLE_SEND_RECEIVED_MESSAGE_TO_VRC return self._SEND_RECEIVED_MESSAGE_TO_VRC
@ENABLE_SEND_RECEIVED_MESSAGE_TO_VRC.setter @SEND_RECEIVED_MESSAGE_TO_VRC.setter
def ENABLE_SEND_RECEIVED_MESSAGE_TO_VRC(self, value): def SEND_RECEIVED_MESSAGE_TO_VRC(self, value):
if isinstance(value, bool): if isinstance(value, bool):
if self._ENABLE_SPEAKER2CHATBOX is True: if self._ENABLE_SPEAKER2CHATBOX is True:
self._ENABLE_SEND_RECEIVED_MESSAGE_TO_VRC = value self._SEND_RECEIVED_MESSAGE_TO_VRC = value
else: else:
self._ENABLE_SEND_RECEIVED_MESSAGE_TO_VRC = False self._SEND_RECEIVED_MESSAGE_TO_VRC = False
saveJson(self.PATH_CONFIG, inspect.currentframe().f_code.co_name, value) saveJson(self.PATH_CONFIG, inspect.currentframe().f_code.co_name, value)
# Speaker2Chatbox------------------ # Speaker2Chatbox------------------
@property @property
@json_serializable('ENABLE_LOGGER') @json_serializable('LOGGER')
def ENABLE_LOGGER(self): def LOGGER(self):
return self._ENABLE_LOGGER return self._LOGGER
@ENABLE_LOGGER.setter @LOGGER.setter
def ENABLE_LOGGER(self, value): def LOGGER(self, value):
if isinstance(value, bool): if isinstance(value, bool):
self._ENABLE_LOGGER = value self._LOGGER = value
saveJson(self.PATH_CONFIG, inspect.currentframe().f_code.co_name, value) saveJson(self.PATH_CONFIG, inspect.currentframe().f_code.co_name, value)
@property @property
@json_serializable('ENABLE_VRC_MIC_MUTE_SYNC') @json_serializable('VRC_MIC_MUTE_SYNC')
def ENABLE_VRC_MIC_MUTE_SYNC(self): def VRC_MIC_MUTE_SYNC(self):
return self._ENABLE_VRC_MIC_MUTE_SYNC return self._VRC_MIC_MUTE_SYNC
@ENABLE_VRC_MIC_MUTE_SYNC.setter @VRC_MIC_MUTE_SYNC.setter
def ENABLE_VRC_MIC_MUTE_SYNC(self, value): def VRC_MIC_MUTE_SYNC(self, value):
if isinstance(value, bool): if isinstance(value, bool):
self._ENABLE_VRC_MIC_MUTE_SYNC = value self._VRC_MIC_MUTE_SYNC = value
saveJson(self.PATH_CONFIG, inspect.currentframe().f_code.co_name, value) saveJson(self.PATH_CONFIG, inspect.currentframe().f_code.co_name, value)
def init_config(self): def init_config(self):
# Read Only # Read Only
self._VERSION = "2.2.5" self._VERSION = "2.2.5"
self._ENABLE_SPEAKER2CHATBOX = False # Speaker2Chatbox self._ENABLE_SPEAKER2CHATBOX = False # Speaker2Chatbox
self._ENABLE_SPEAKER2CHATBOX_PASS_CONFIRMATION = "VRCT=0YEN" self._SPEAKER2CHATBOX_PASS_CONFIRMATION = "VRCT=0YEN"
if getattr(sys, 'frozen', False): if getattr(sys, 'frozen', False):
self._PATH_LOCAL = os_path.dirname(sys.executable) self._PATH_LOCAL = os_path.dirname(sys.executable)
else: else:
@@ -1080,10 +1080,10 @@ class Config:
}, },
} }
self._SELECTED_TRANSCRIPTION_ENGINE = "Google" self._SELECTED_TRANSCRIPTION_ENGINE = "Google"
self._ENABLE_MULTI_LANGUAGE_TRANSLATION = False self._MULTI_LANGUAGE_TRANSLATION = False
self._ENABLE_CONVERT_MESSAGE_TO_ROMAJI = False self._CONVERT_MESSAGE_TO_ROMAJI = False
self._ENABLE_CONVERT_MESSAGE_TO_HIRAGANA = False self._CONVERT_MESSAGE_TO_HIRAGANA = False
self._ENABLE_MAIN_WINDOW_SIDEBAR_COMPACT_MODE = False self._MAIN_WINDOW_SIDEBAR_COMPACT_MODE = False
## Config Window ## Config Window
self._TRANSPARENCY = 100 self._TRANSPARENCY = 100
@@ -1093,33 +1093,33 @@ class Config:
self._MESSAGE_BOX_RATIO = 10 self._MESSAGE_BOX_RATIO = 10
self._FONT_FAMILY = "Yu Gothic UI" self._FONT_FAMILY = "Yu Gothic UI"
self._UI_LANGUAGE = "en" self._UI_LANGUAGE = "en"
self._ENABLE_RESTORE_MAIN_WINDOW_GEOMETRY = True self._RESTORE_MAIN_WINDOW_GEOMETRY = True
self._MAIN_WINDOW_GEOMETRY = { self._MAIN_WINDOW_GEOMETRY = {
"x_pos": "0", "x_pos": "0",
"y_pos": "0", "y_pos": "0",
"width": "870", "width": "870",
"height": "654", "height": "654",
} }
self._ENABLE_MIC_AUTO_SELECTION = True self._AUTO_MIC_SELECT = True
self._CHOICE_MIC_HOST = device_manager.getDefaultInputDevice()["host"]["name"] self._SELECTED_MIC_HOST = device_manager.getDefaultInputDevice()["host"]["name"]
self._CHOICE_MIC_DEVICE = device_manager.getDefaultInputDevice()["device"]["name"] self._SELECTED_MIC_DEVICE = device_manager.getDefaultInputDevice()["device"]["name"]
self._INPUT_MIC_ENERGY_THRESHOLD = 300 self._MIC_ENERGY_THRESHOLD = 300
self._INPUT_MIC_DYNAMIC_ENERGY_THRESHOLD = False self._MIC_DYNAMIC_ENERGY_THRESHOLD = False
self._INPUT_MIC_RECORD_TIMEOUT = 3 self._MIC_RECORD_TIMEOUT = 3
self._INPUT_MIC_PHRASE_TIMEOUT = 3 self._MIC_PHRASE_TIMEOUT = 3
self._INPUT_MIC_MAX_PHRASES = 10 self._MIC_MAX_PHRASES = 10
self._INPUT_MIC_WORD_FILTER = [] self._MIC_WORD_FILTER = []
self._INPUT_MIC_AVG_LOGPROB=-0.8 self._MIC_AVG_LOGPROB=-0.8
self._INPUT_MIC_NO_SPEECH_PROB=0.6 self._MIC_NO_SPEECH_PROB=0.6
self._ENABLE_SPEAKER_AUTO_SELECTION = True self._AUTO_SPEAKER_SELECT = True
self._CHOICE_SPEAKER_DEVICE = device_manager.getDefaultOutputDevice()["device"]["name"] self._SELECTED_SPEAKER_DEVICE = device_manager.getDefaultOutputDevice()["device"]["name"]
self._INPUT_SPEAKER_ENERGY_THRESHOLD = 300 self._SPEAKER_ENERGY_THRESHOLD = 300
self._INPUT_SPEAKER_DYNAMIC_ENERGY_THRESHOLD = False self._SPEAKER_DYNAMIC_ENERGY_THRESHOLD = False
self._INPUT_SPEAKER_RECORD_TIMEOUT = 3 self._SPEAKER_RECORD_TIMEOUT = 3
self._INPUT_SPEAKER_PHRASE_TIMEOUT = 3 self._SPEAKER_PHRASE_TIMEOUT = 3
self._INPUT_SPEAKER_MAX_PHRASES = 10 self._SPEAKER_MAX_PHRASES = 10
self._INPUT_SPEAKER_AVG_LOGPROB=-0.8 self._SPEAKER_AVG_LOGPROB=-0.8
self._INPUT_SPEAKER_NO_SPEECH_PROB=0.6 self._SPEAKER_NO_SPEECH_PROB=0.6
self._OSC_IP_ADDRESS = "127.0.0.1" self._OSC_IP_ADDRESS = "127.0.0.1"
self._OSC_PORT = 9000 self._OSC_PORT = 9000
self._AUTH_KEYS = { self._AUTH_KEYS = {
@@ -1134,14 +1134,14 @@ class Config:
self._SEND_MESSAGE_FORMAT_WITH_T = "[message]([translation])" self._SEND_MESSAGE_FORMAT_WITH_T = "[message]([translation])"
self._RECEIVED_MESSAGE_FORMAT = "[message]" self._RECEIVED_MESSAGE_FORMAT = "[message]"
self._RECEIVED_MESSAGE_FORMAT_WITH_T = "[message]([translation])" self._RECEIVED_MESSAGE_FORMAT_WITH_T = "[message]([translation])"
self._ENABLE_AUTO_CLEAR_MESSAGE_BOX = True self._AUTO_CLEAR_MESSAGE_BOX = True
self._ENABLE_SEND_ONLY_TRANSLATED_MESSAGES = False self._SEND_ONLY_TRANSLATED_MESSAGES = False
self._SEND_MESSAGE_BUTTON_TYPE = "show" self._SEND_MESSAGE_BUTTON_TYPE = "show"
self._OVERLAY_SETTINGS = { self._OVERLAY_SETTINGS = {
"opacity": 1.0, "opacity": 1.0,
"ui_scaling": 1.0, "ui_scaling": 1.0,
} }
self._ENABLE_OVERLAY_SMALL_LOG = False self._OVERLAY_SMALL_LOG = False
self._OVERLAY_SMALL_LOG_SETTINGS = { self._OVERLAY_SMALL_LOG_SETTINGS = {
"x_pos": 0.0, "x_pos": 0.0,
"y_pos": 0.0, "y_pos": 0.0,
@@ -1153,11 +1153,11 @@ class Config:
"fadeout_duration": 2, "fadeout_duration": 2,
} }
self._OVERLAY_UI_TYPE = "default" self._OVERLAY_UI_TYPE = "default"
self._ENABLE_SEND_MESSAGE_TO_VRC = True self._SEND_MESSAGE_TO_VRC = True
self._ENABLE_SEND_RECEIVED_MESSAGE_TO_VRC = False # Speaker2Chatbox self._SEND_RECEIVED_MESSAGE_TO_VRC = False # Speaker2Chatbox
self._ENABLE_SPEAKER2CHATBOX_PASS = "000000000" self._SPEAKER2CHATBOX_PASS = "000000000"
self._ENABLE_LOGGER = False self._LOGGER = False
self._ENABLE_VRC_MIC_MUTE_SYNC = False self._VRC_MIC_MUTE_SYNC = False
def load_config(self): def load_config(self):
if os_path.isfile(self.PATH_CONFIG) is not False: if os_path.isfile(self.PATH_CONFIG) is not False:
@@ -1170,8 +1170,8 @@ class Config:
old_message_format = config[key] old_message_format = config[key]
setattr(self, key, config[key]) setattr(self, key, config[key])
if key == "ENABLE_SPEAKER2CHATBOX_PASS": if key == "SPEAKER2CHATBOX_PASS":
if self.ENABLE_SPEAKER2CHATBOX_PASS_CONFIRMATION == config[key]: if self.SPEAKER2CHATBOX_PASS_CONFIRMATION == config[key]:
self.ENABLE_SPEAKER2CHATBOX = True self.ENABLE_SPEAKER2CHATBOX = True
if old_message_format is not None: if old_message_format is not None:

82
src-python/model.py
View File

@@ -220,7 +220,7 @@ class Model:
translations = [] translations = []
success_flags = [] success_flags = []
for key in target_languages.keys(): for key in target_languages.keys():
if key == "primary" or config.ENABLE_MULTI_LANGUAGE_TRANSLATION is True: if key == "primary" or config.MULTI_LANGUAGE_TRANSLATION is True:
target_language = target_languages[key]["language"] target_language = target_languages[key]["language"]
target_country = target_languages[key]["country"] target_country = target_languages[key]["country"]
if target_language is not None or target_country is not None: if target_language is not None or target_country is not None:
@@ -252,7 +252,7 @@ class Model:
return [translation], success_flag return [translation], success_flag
def addKeywords(self): def addKeywords(self):
for f in config.INPUT_MIC_WORD_FILTER: for f in config.MIC_WORD_FILTER:
self.keyword_processor.add_keyword(f) self.keyword_processor.add_keyword(f)
def checkKeywords(self, message): def checkKeywords(self, message):
@@ -412,11 +412,11 @@ class Model:
return result return result
def getInputDefaultDevice(self): def getInputDefaultDevice(self):
result = device_manager.getInputDevices().get(config.CHOICE_MIC_HOST, [{"name": "NoDevice"}])[0]["name"] result = device_manager.getInputDevices().get(config.SELECTED_MIC_HOST, [{"name": "NoDevice"}])[0]["name"]
return result return result
def getListInputDevice(self): def getListInputDevice(self):
result = [device["name"] for device in device_manager.getInputDevices().get(config.CHOICE_MIC_HOST, [{"name": "NoDevice"}])] result = [device["name"] for device in device_manager.getInputDevices().get(config.SELECTED_MIC_HOST, [{"name": "NoDevice"}])]
return result return result
def getListOutputDevice(self): def getListOutputDevice(self):
@@ -424,33 +424,33 @@ class Model:
return result return result
def startMicTranscript(self, fnc): def startMicTranscript(self, fnc):
if config.ENABLE_MIC_AUTO_SELECTION is True: if config.AUTO_MIC_SELECT is True:
default_device = device_manager.getDefaultInputDevice() default_device = device_manager.getDefaultInputDevice()
mic_host_name = default_device["host"]["name"] mic_host_name = default_device["host"]["name"]
mic_device_name = default_device["device"]["name"] mic_device_name = default_device["device"]["name"]
else: else:
mic_host_name = config.CHOICE_MIC_HOST mic_host_name = config.SELECTED_MIC_HOST
mic_device_name = config.CHOICE_MIC_DEVICE mic_device_name = config.SELECTED_MIC_DEVICE
mic_device_list = device_manager.getInputDevices().get(mic_host_name, [{"name": "NoDevice"}]) mic_device_list = device_manager.getInputDevices().get(mic_host_name, [{"name": "NoDevice"}])
choice_mic_device = [device for device in mic_device_list if device["name"] == mic_device_name] selected_mic_device = [device for device in mic_device_list if device["name"] == mic_device_name]
if len(choice_mic_device) == 0: if len(selected_mic_device) == 0:
return False return False
self.mic_audio_queue = Queue() self.mic_audio_queue = Queue()
# self.mic_energy_queue = Queue() # self.mic_energy_queue = Queue()
mic_device = choice_mic_device[0] mic_device = selected_mic_device[0]
record_timeout = config.INPUT_MIC_RECORD_TIMEOUT record_timeout = config.MIC_RECORD_TIMEOUT
phrase_timeout = config.INPUT_MIC_PHRASE_TIMEOUT phrase_timeout = config.MIC_PHRASE_TIMEOUT
if record_timeout > phrase_timeout: if record_timeout > phrase_timeout:
record_timeout = phrase_timeout record_timeout = phrase_timeout
self.mic_audio_recorder = SelectedMicEnergyAndAudioRecorder( self.mic_audio_recorder = SelectedMicEnergyAndAudioRecorder(
device=mic_device, device=mic_device,
energy_threshold=config.INPUT_MIC_ENERGY_THRESHOLD, energy_threshold=config.MIC_ENERGY_THRESHOLD,
dynamic_energy_threshold=config.INPUT_MIC_DYNAMIC_ENERGY_THRESHOLD, dynamic_energy_threshold=config.MIC_DYNAMIC_ENERGY_THRESHOLD,
record_timeout=record_timeout, record_timeout=record_timeout,
) )
# self.mic_audio_recorder.recordIntoQueue(self.mic_audio_queue, mic_energy_queue) # self.mic_audio_recorder.recordIntoQueue(self.mic_audio_queue, mic_energy_queue)
@@ -459,7 +459,7 @@ class Model:
speaker=False, speaker=False,
source=self.mic_audio_recorder.source, source=self.mic_audio_recorder.source,
phrase_timeout=phrase_timeout, phrase_timeout=phrase_timeout,
max_phrases=config.INPUT_MIC_MAX_PHRASES, max_phrases=config.MIC_MAX_PHRASES,
transcription_engine=config.SELECTED_TRANSCRIPTION_ENGINE, transcription_engine=config.SELECTED_TRANSCRIPTION_ENGINE,
root=config.PATH_LOCAL, root=config.PATH_LOCAL,
whisper_weight_type=config.WHISPER_WEIGHT_TYPE, whisper_weight_type=config.WHISPER_WEIGHT_TYPE,
@@ -470,8 +470,8 @@ class Model:
self.mic_audio_queue, self.mic_audio_queue,
config.SELECTED_YOUR_LANGUAGES[config.SELECTED_TAB_NO]["primary"]["language"], config.SELECTED_YOUR_LANGUAGES[config.SELECTED_TAB_NO]["primary"]["language"],
config.SELECTED_YOUR_LANGUAGES[config.SELECTED_TAB_NO]["primary"]["country"], config.SELECTED_YOUR_LANGUAGES[config.SELECTED_TAB_NO]["primary"]["country"],
config.INPUT_MIC_AVG_LOGPROB, config.MIC_AVG_LOGPROB,
config.INPUT_MIC_NO_SPEECH_PROB config.MIC_NO_SPEECH_PROB
) )
if res: if res:
message = self.mic_transcriber.getTranscript() message = self.mic_transcriber.getTranscript()
@@ -531,7 +531,7 @@ class Model:
self.mic_audio_recorder.pause() self.mic_audio_recorder.pause()
def changeMicTranscriptStatus(self): def changeMicTranscriptStatus(self):
if config.ENABLE_VRC_MIC_MUTE_SYNC is True: if config.VRC_MIC_MUTE_SYNC is True:
if self.mic_mute_status is True: if self.mic_mute_status is True:
self.pauseMicTranscript() self.pauseMicTranscript()
elif self.mic_mute_status is False: elif self.mic_mute_status is False:
@@ -558,18 +558,18 @@ class Model:
if isinstance(fnc, Callable): if isinstance(fnc, Callable):
self.check_mic_energy_fnc = fnc self.check_mic_energy_fnc = fnc
if config.ENABLE_MIC_AUTO_SELECTION is True: if config.AUTO_MIC_SELECT is True:
default_device = device_manager.getDefaultInputDevice() default_device = device_manager.getDefaultInputDevice()
mic_host_name = default_device["host"]["name"] mic_host_name = default_device["host"]["name"]
mic_device_name = default_device["device"]["name"] mic_device_name = default_device["device"]["name"]
else: else:
mic_host_name = config.CHOICE_MIC_HOST mic_host_name = config.SELECTED_MIC_HOST
mic_device_name = config.CHOICE_MIC_DEVICE mic_device_name = config.SELECTED_MIC_DEVICE
mic_device_list = device_manager.getInputDevices().get(mic_host_name, [{"name": "NoDevice"}]) mic_device_list = device_manager.getInputDevices().get(mic_host_name, [{"name": "NoDevice"}])
choice_mic_device = [device for device in mic_device_list if device["name"] == mic_device_name] selected_mic_device = [device for device in mic_device_list if device["name"] == mic_device_name]
if len(choice_mic_device) == 0: if len(selected_mic_device) == 0:
return False return False
def sendMicEnergy(): def sendMicEnergy():
@@ -582,7 +582,7 @@ class Model:
sleep(0.01) sleep(0.01)
mic_energy_queue = Queue() mic_energy_queue = Queue()
mic_device = choice_mic_device[0] mic_device = selected_mic_device[0]
self.mic_energy_recorder = SelectedMicEnergyRecorder(mic_device) self.mic_energy_recorder = SelectedMicEnergyRecorder(mic_device)
self.mic_energy_recorder.recordIntoQueue(mic_energy_queue) self.mic_energy_recorder.recordIntoQueue(mic_energy_queue)
self.mic_energy_plot_progressbar = threadFnc(sendMicEnergy) self.mic_energy_plot_progressbar = threadFnc(sendMicEnergy)
@@ -600,30 +600,30 @@ class Model:
self.mic_energy_recorder = None self.mic_energy_recorder = None
def startSpeakerTranscript(self, fnc): def startSpeakerTranscript(self, fnc):
if config.ENABLE_SPEAKER_AUTO_SELECTION is True: if config.AUTO_SPEAKER_SELECT is True:
default_device = device_manager.getDefaultOutputDevice() default_device = device_manager.getDefaultOutputDevice()
speaker_device_name = default_device["device"]["name"] speaker_device_name = default_device["device"]["name"]
else: else:
speaker_device_name = config.CHOICE_SPEAKER_DEVICE speaker_device_name = config.SELECTED_SPEAKER_DEVICE
speaker_device_list = device_manager.getOutputDevices() speaker_device_list = device_manager.getOutputDevices()
choice_speaker_device = [device for device in speaker_device_list if device["name"] == speaker_device_name] selected_speaker_device = [device for device in speaker_device_list if device["name"] == speaker_device_name]
if len(choice_speaker_device) == 0: if len(selected_speaker_device) == 0:
return False return False
speaker_audio_queue = Queue() speaker_audio_queue = Queue()
# speaker_energy_queue = Queue() # speaker_energy_queue = Queue()
speaker_device = choice_speaker_device[0] speaker_device = selected_speaker_device[0]
record_timeout = config.INPUT_SPEAKER_RECORD_TIMEOUT record_timeout = config.SPEAKER_RECORD_TIMEOUT
phrase_timeout = config.INPUT_SPEAKER_PHRASE_TIMEOUT phrase_timeout = config.SPEAKER_PHRASE_TIMEOUT
if record_timeout > phrase_timeout: if record_timeout > phrase_timeout:
record_timeout = phrase_timeout record_timeout = phrase_timeout
self.speaker_audio_recorder = SelectedSpeakerEnergyAndAudioRecorder( self.speaker_audio_recorder = SelectedSpeakerEnergyAndAudioRecorder(
device=speaker_device, device=speaker_device,
energy_threshold=config.INPUT_SPEAKER_ENERGY_THRESHOLD, energy_threshold=config.SPEAKER_ENERGY_THRESHOLD,
dynamic_energy_threshold=config.INPUT_SPEAKER_DYNAMIC_ENERGY_THRESHOLD, dynamic_energy_threshold=config.SPEAKER_DYNAMIC_ENERGY_THRESHOLD,
record_timeout=record_timeout, record_timeout=record_timeout,
) )
# self.speaker_audio_recorder.recordIntoQueue(speaker_audio_queue, speaker_energy_queue) # self.speaker_audio_recorder.recordIntoQueue(speaker_audio_queue, speaker_energy_queue)
@@ -632,7 +632,7 @@ class Model:
speaker=True, speaker=True,
source=self.speaker_audio_recorder.source, source=self.speaker_audio_recorder.source,
phrase_timeout=phrase_timeout, phrase_timeout=phrase_timeout,
max_phrases=config.INPUT_SPEAKER_MAX_PHRASES, max_phrases=config.SPEAKER_MAX_PHRASES,
transcription_engine=config.SELECTED_TRANSCRIPTION_ENGINE, transcription_engine=config.SELECTED_TRANSCRIPTION_ENGINE,
root=config.PATH_LOCAL, root=config.PATH_LOCAL,
whisper_weight_type=config.WHISPER_WEIGHT_TYPE, whisper_weight_type=config.WHISPER_WEIGHT_TYPE,
@@ -643,8 +643,8 @@ class Model:
speaker_audio_queue, speaker_audio_queue,
config.SELECTED_TARGET_LANGUAGES[config.SELECTED_TAB_NO]["primary"]["language"], config.SELECTED_TARGET_LANGUAGES[config.SELECTED_TAB_NO]["primary"]["language"],
config.SELECTED_TARGET_LANGUAGES[config.SELECTED_TAB_NO]["primary"]["country"], config.SELECTED_TARGET_LANGUAGES[config.SELECTED_TAB_NO]["primary"]["country"],
config.INPUT_SPEAKER_AVG_LOGPROB, config.SPEAKER_AVG_LOGPROB,
config.INPUT_SPEAKER_NO_SPEECH_PROB config.SPEAKER_NO_SPEECH_PROB
) )
if res: if res:
message = self.speaker_transcriber.getTranscript() message = self.speaker_transcriber.getTranscript()
@@ -692,16 +692,16 @@ class Model:
if isinstance(fnc, Callable): if isinstance(fnc, Callable):
self.check_speaker_energy_fnc = fnc self.check_speaker_energy_fnc = fnc
if config.ENABLE_SPEAKER_AUTO_SELECTION is True: if config.AUTO_SPEAKER_SELECT is True:
default_device = device_manager.getDefaultOutputDevice() default_device = device_manager.getDefaultOutputDevice()
speaker_device_name = default_device["device"]["name"] speaker_device_name = default_device["device"]["name"]
else: else:
speaker_device_name = config.CHOICE_SPEAKER_DEVICE speaker_device_name = config.SELECTED_SPEAKER_DEVICE
speaker_device_list = device_manager.getOutputDevices() speaker_device_list = device_manager.getOutputDevices()
choice_speaker_device = [device for device in speaker_device_list if device["name"] == speaker_device_name] selected_speaker_device = [device for device in speaker_device_list if device["name"] == speaker_device_name]
if len(choice_speaker_device) == 0: if len(selected_speaker_device) == 0:
return False return False
def sendSpeakerEnergy(): def sendSpeakerEnergy():
@@ -714,7 +714,7 @@ class Model:
sleep(0.01) sleep(0.01)
speaker_energy_queue = Queue() speaker_energy_queue = Queue()
speaker_device = choice_speaker_device[0] speaker_device = selected_speaker_device[0]
self.speaker_energy_recorder = SelectedSpeakerEnergyRecorder(speaker_device) self.speaker_energy_recorder = SelectedSpeakerEnergyRecorder(speaker_device)
self.speaker_energy_recorder.recordIntoQueue(speaker_energy_queue) self.speaker_energy_recorder.recordIntoQueue(speaker_energy_queue)
self.speaker_energy_plot_progressbar = threadFnc(sendSpeakerEnergy) self.speaker_energy_plot_progressbar = threadFnc(sendSpeakerEnergy)

467
src-python/webui_controller.py
View File

@@ -40,8 +40,8 @@ class UpdateSelectedMicDevice:
self.action = action self.action = action
def set(self, host, device) -> None: def set(self, host, device) -> None:
config.CHOICE_MIC_HOST = host config.SELECTED_MIC_HOST = host
config.CHOICE_MIC_DEVICE = device config.SELECTED_MIC_DEVICE = device
printLog("Update Host/Mic Device", f"{host}/{device}") printLog("Update Host/Mic Device", f"{host}/{device}")
self.action("mic", { self.action("mic", {
"status":200, "status":200,
@@ -53,7 +53,7 @@ class UpdateSelectedSpeakerDevice:
self.action = action self.action = action
def set(self, device) -> None: def set(self, device) -> None:
config.CHOICE_SPEAKER_DEVICE = device config.SELECTED_SPEAKER_DEVICE = device
printLog("Update Speaker Device", device) printLog("Update Speaker Device", device)
self.action("speaker", { self.action("speaker", {
"status":200, "status":200,
@@ -132,13 +132,13 @@ class MicMessage:
} }
}) })
if config.ENABLE_CONVERT_MESSAGE_TO_ROMAJI is True or config.ENABLE_CONVERT_MESSAGE_TO_HIRAGANA is True: if config.CONVERT_MESSAGE_TO_ROMAJI is True or config.CONVERT_MESSAGE_TO_HIRAGANA is True:
if config.SELECTED_TARGET_LANGUAGES[config.SELECTED_TAB_NO]["primary"]["language"] == "Japanese": if config.SELECTED_TARGET_LANGUAGES[config.SELECTED_TAB_NO]["primary"]["language"] == "Japanese":
transliteration = model.convertMessageToTransliteration(translation[0]) transliteration = model.convertMessageToTransliteration(translation[0])
if config.ENABLE_TRANSCRIPTION_SEND is True: if config.ENABLE_TRANSCRIPTION_SEND is True:
if config.ENABLE_SEND_MESSAGE_TO_VRC is True: if config.SEND_MESSAGE_TO_VRC is True:
if config.ENABLE_SEND_ONLY_TRANSLATED_MESSAGES is True: if config.SEND_ONLY_TRANSLATED_MESSAGES is True:
if config.ENABLE_TRANSLATION is False: if config.ENABLE_TRANSLATION is False:
osc_message = messageFormatter("SEND", "", [message]) osc_message = messageFormatter("SEND", "", [message])
else: else:
@@ -155,12 +155,12 @@ class MicMessage:
"transliteration":transliteration "transliteration":transliteration
} }
}) })
if config.ENABLE_LOGGER is True: if config.LOGGER is True:
if len(translation) > 0: if len(translation) > 0:
translation = " (" + "/".join(translation) + ")" translation = " (" + "/".join(translation) + ")"
model.logger.info(f"[SENT] {message}{translation}") model.logger.info(f"[SENT] {message}{translation}")
# if config.ENABLE_OVERLAY_SMALL_LOG is True: # if config.OVERLAY_SMALL_LOG is True:
# overlay_image = model.createOverlayImageShort(message, translation) # overlay_image = model.createOverlayImageShort(message, translation)
# model.updateOverlay(overlay_image) # model.updateOverlay(overlay_image)
# overlay_image = model.createOverlayImageLong("send", message, translation) # overlay_image = model.createOverlayImageLong("send", message, translation)
@@ -196,12 +196,12 @@ class SpeakerMessage:
} }
}) })
if config.ENABLE_CONVERT_MESSAGE_TO_ROMAJI is True or config.ENABLE_CONVERT_MESSAGE_TO_HIRAGANA is True: if config.CONVERT_MESSAGE_TO_ROMAJI is True or config.CONVERT_MESSAGE_TO_HIRAGANA is True:
if config.SELECTED_TARGET_LANGUAGES[config.SELECTED_TAB_NO]["primary"]["language"] == "Japanese": if config.SELECTED_TARGET_LANGUAGES[config.SELECTED_TAB_NO]["primary"]["language"] == "Japanese":
transliteration = model.convertMessageToTransliteration(message) transliteration = model.convertMessageToTransliteration(message)
if config.ENABLE_TRANSCRIPTION_RECEIVE is True: if config.ENABLE_TRANSCRIPTION_RECEIVE is True:
if config.ENABLE_OVERLAY_SMALL_LOG is True: if config.OVERLAY_SMALL_LOG is True:
if model.overlay.initialized is True: if model.overlay.initialized is True:
overlay_image = model.createOverlayImageShort(message, translation) overlay_image = model.createOverlayImageShort(message, translation)
model.updateOverlay(overlay_image) model.updateOverlay(overlay_image)
@@ -211,7 +211,7 @@ class SpeakerMessage:
# ------------Speaker2Chatbox------------ # ------------Speaker2Chatbox------------
if config.ENABLE_SPEAKER2CHATBOX is True: if config.ENABLE_SPEAKER2CHATBOX is True:
# send OSC message # send OSC message
if config.ENABLE_SEND_RECEIVED_MESSAGE_TO_VRC is True: if config.SEND_RECEIVED_MESSAGE_TO_VRC is True:
osc_message = messageFormatter("RECEIVED", translation, [message]) osc_message = messageFormatter("RECEIVED", translation, [message])
model.oscSendMessage(osc_message) model.oscSendMessage(osc_message)
# ------------Speaker2Chatbox------------ # ------------Speaker2Chatbox------------
@@ -225,7 +225,7 @@ class SpeakerMessage:
"transliteration":transliteration, "transliteration":transliteration,
} }
}) })
if config.ENABLE_LOGGER is True: if config.LOGGER is True:
if len(translation) > 0: if len(translation) > 0:
translation = " (" + "/".join(translation) + ")" translation = " (" + "/".join(translation) + ")"
model.logger.info(f"[RECEIVED] {message}{translation}") model.logger.info(f"[RECEIVED] {message}{translation}")
@@ -263,13 +263,13 @@ class ChatMessage:
} }
}) })
if config.ENABLE_CONVERT_MESSAGE_TO_ROMAJI is True or config.ENABLE_CONVERT_MESSAGE_TO_HIRAGANA is True: if config.CONVERT_MESSAGE_TO_ROMAJI is True or config.CONVERT_MESSAGE_TO_HIRAGANA is True:
if config.SELECTED_TARGET_LANGUAGES[config.SELECTED_TAB_NO]["primary"]["language"] == "Japanese": if config.SELECTED_TARGET_LANGUAGES[config.SELECTED_TAB_NO]["primary"]["language"] == "Japanese":
transliteration = model.convertMessageToTransliteration(translation[0]) transliteration = model.convertMessageToTransliteration(translation[0])
# send OSC message # send OSC message
if config.ENABLE_SEND_MESSAGE_TO_VRC is True: if config.SEND_MESSAGE_TO_VRC is True:
if config.ENABLE_SEND_ONLY_TRANSLATED_MESSAGES is True: if config.SEND_ONLY_TRANSLATED_MESSAGES is True:
if config.ENABLE_TRANSLATION is False: if config.ENABLE_TRANSLATION is False:
osc_message = messageFormatter("SEND", "", [message]) osc_message = messageFormatter("SEND", "", [message])
else: else:
@@ -278,14 +278,14 @@ class ChatMessage:
osc_message = messageFormatter("SEND", translation, [message]) osc_message = messageFormatter("SEND", translation, [message])
model.oscSendMessage(osc_message) model.oscSendMessage(osc_message)
# if config.ENABLE_OVERLAY_SMALL_LOG is True: # if config.OVERLAY_SMALL_LOG is True:
# overlay_image = model.createOverlayImageShort(message, translation) # overlay_image = model.createOverlayImageShort(message, translation)
# model.updateOverlay(overlay_image) # model.updateOverlay(overlay_image)
# overlay_image = model.createOverlayImageLong("send", message, translation) # overlay_image = model.createOverlayImageLong("send", message, translation)
# model.updateOverlay(overlay_image) # model.updateOverlay(overlay_image)
# update textbox message log (Sent) # update textbox message log (Sent)
if config.ENABLE_LOGGER is True: if config.LOGGER is True:
if len(translation) > 0: if len(translation) > 0:
translation_text = " (" + "/".join(translation) + ")" translation_text = " (" + "/".join(translation) + ")"
model.logger.info(f"[SENT] {message}{translation_text}") model.logger.info(f"[SENT] {message}{translation_text}")
@@ -394,7 +394,7 @@ def getTranslationEngines(*args, **kwargs) -> dict:
engines = model.findTranslationEngines( engines = model.findTranslationEngines(
config.SELECTED_YOUR_LANGUAGES[config.SELECTED_TAB_NO], config.SELECTED_YOUR_LANGUAGES[config.SELECTED_TAB_NO],
config.SELECTED_TARGET_LANGUAGES[config.SELECTED_TAB_NO], config.SELECTED_TARGET_LANGUAGES[config.SELECTED_TAB_NO],
config.ENABLE_MULTI_LANGUAGE_TRANSLATION, config.MULTI_LANGUAGE_TRANSLATION,
) )
return {"status":200, "result":engines} return {"status":200, "result":engines}
@@ -437,49 +437,49 @@ def setSelectedTargetLanguages(select:dict, *args, **kwargs) -> dict:
def getSelectedTranscriptionEngine(*args, **kwargs) -> dict: def getSelectedTranscriptionEngine(*args, **kwargs) -> dict:
return {"status":200, "result":config.SELECTED_TRANSCRIPTION_ENGINE} return {"status":200, "result":config.SELECTED_TRANSCRIPTION_ENGINE}
def getEnableMultiLanguageTranslation(*args, **kwargs) -> dict: def getMultiLanguageTranslation(*args, **kwargs) -> dict:
return {"status":200, "result":config.ENABLE_MULTI_LANGUAGE_TRANSLATION} return {"status":200, "result":config.MULTI_LANGUAGE_TRANSLATION}
def setEnableMultiLanguageTranslation(*args, **kwargs) -> dict: def setEnableMultiLanguageTranslation(*args, **kwargs) -> dict:
config.ENABLE_MULTI_LANGUAGE_TRANSLATION = True config.MULTI_LANGUAGE_TRANSLATION = True
return {"status":200, "result":config.ENABLE_MULTI_LANGUAGE_TRANSLATION} return {"status":200, "result":config.MULTI_LANGUAGE_TRANSLATION}
def setDisableMultiLanguageTranslation(*args, **kwargs) -> dict: def setDisableMultiLanguageTranslation(*args, **kwargs) -> dict:
config.ENABLE_MULTI_LANGUAGE_TRANSLATION = False config.MULTI_LANGUAGE_TRANSLATION = False
return {"status":200, "result":config.ENABLE_MULTI_LANGUAGE_TRANSLATION} return {"status":200, "result":config.MULTI_LANGUAGE_TRANSLATION}
def getEnableConvertMessageToRomaji(*args, **kwargs) -> dict: def getConvertMessageToRomaji(*args, **kwargs) -> dict:
return {"status":200, "result":config.ENABLE_CONVERT_MESSAGE_TO_ROMAJI} return {"status":200, "result":config.CONVERT_MESSAGE_TO_ROMAJI}
def setEnableConvertMessageToRomaji(*args, **kwargs) -> dict: def setEnableConvertMessageToRomaji(*args, **kwargs) -> dict:
config.ENABLE_CONVERT_MESSAGE_TO_ROMAJI = True config.CONVERT_MESSAGE_TO_ROMAJI = True
return {"status":200, "result":config.ENABLE_CONVERT_MESSAGE_TO_ROMAJI} return {"status":200, "result":config.CONVERT_MESSAGE_TO_ROMAJI}
def setDisableConvertMessageToRomaji(*args, **kwargs) -> dict: def setDisableConvertMessageToRomaji(*args, **kwargs) -> dict:
config.ENABLE_CONVERT_MESSAGE_TO_ROMAJI = False config.CONVERT_MESSAGE_TO_ROMAJI = False
return {"status":200, "result":config.ENABLE_CONVERT_MESSAGE_TO_ROMAJI} return {"status":200, "result":config.CONVERT_MESSAGE_TO_ROMAJI}
def getEnableConvertMessageToHiragana(*args, **kwargs) -> dict: def getConvertMessageToHiragana(*args, **kwargs) -> dict:
return {"status":200, "result":config.ENABLE_CONVERT_MESSAGE_TO_HIRAGANA} return {"status":200, "result":config.CONVERT_MESSAGE_TO_HIRAGANA}
def setEnableConvertMessageToHiragana(*args, **kwargs) -> dict: def setEnableConvertMessageToHiragana(*args, **kwargs) -> dict:
config.ENABLE_CONVERT_MESSAGE_TO_HIRAGANA = True config.CONVERT_MESSAGE_TO_HIRAGANA = True
return {"status":200, "result":config.ENABLE_CONVERT_MESSAGE_TO_HIRAGANA} return {"status":200, "result":config.CONVERT_MESSAGE_TO_HIRAGANA}
def setDisableConvertMessageToHiragana(*args, **kwargs) -> dict: def setDisableConvertMessageToHiragana(*args, **kwargs) -> dict:
config.ENABLE_CONVERT_MESSAGE_TO_HIRAGANA = False config.CONVERT_MESSAGE_TO_HIRAGANA = False
return {"status":200, "result":config.ENABLE_CONVERT_MESSAGE_TO_HIRAGANA} return {"status":200, "result":config.CONVERT_MESSAGE_TO_HIRAGANA}
def getEnableMainWindowSidebarCompactMode(*args, **kwargs) -> dict: def getMainWindowSidebarCompactMode(*args, **kwargs) -> dict:
return {"status":200, "result":config.ENABLE_MAIN_WINDOW_SIDEBAR_COMPACT_MODE} return {"status":200, "result":config.MAIN_WINDOW_SIDEBAR_COMPACT_MODE}
def setEnableMainWindowSidebarCompactMode(*args, **kwargs) -> dict: def setEnableMainWindowSidebarCompactMode(*args, **kwargs) -> dict:
config.ENABLE_MAIN_WINDOW_SIDEBAR_COMPACT_MODE = True config.MAIN_WINDOW_SIDEBAR_COMPACT_MODE = True
return {"status":200, "result":config.ENABLE_MAIN_WINDOW_SIDEBAR_COMPACT_MODE} return {"status":200, "result":config.MAIN_WINDOW_SIDEBAR_COMPACT_MODE}
def setDisableMainWindowSidebarCompactMode(*args, **kwargs) -> dict: def setDisableMainWindowSidebarCompactMode(*args, **kwargs) -> dict:
config.ENABLE_MAIN_WINDOW_SIDEBAR_COMPACT_MODE = False config.MAIN_WINDOW_SIDEBAR_COMPACT_MODE = False
return {"status":200, "result":config.ENABLE_MAIN_WINDOW_SIDEBAR_COMPACT_MODE} return {"status":200, "result":config.MAIN_WINDOW_SIDEBAR_COMPACT_MODE}
def getTransparency(*args, **kwargs) -> dict: def getTransparency(*args, **kwargs) -> dict:
return {"status":200, "result":config.TRANSPARENCY} return {"status":200, "result":config.TRANSPARENCY}
@@ -530,16 +530,16 @@ def setUiLanguage(data, *args, **kwargs) -> dict:
config.UI_LANGUAGE = data config.UI_LANGUAGE = data
return {"status":200, "result":config.UI_LANGUAGE} return {"status":200, "result":config.UI_LANGUAGE}
def getEnableRestoreMainWindowGeometry(*args, **kwargs) -> dict: def getRestoreMainWindowGeometry(*args, **kwargs) -> dict:
return {"status":200, "result":config.ENABLE_RESTORE_MAIN_WINDOW_GEOMETRY} return {"status":200, "result":config.RESTORE_MAIN_WINDOW_GEOMETRY}
def setEnableRestoreMainWindowGeometry(*args, **kwargs) -> dict: def setEnableRestoreMainWindowGeometry(*args, **kwargs) -> dict:
config.ENABLE_RESTORE_MAIN_WINDOW_GEOMETRY = True config.RESTORE_MAIN_WINDOW_GEOMETRY = True
return {"status":200, "result":config.ENABLE_RESTORE_MAIN_WINDOW_GEOMETRY} return {"status":200, "result":config.RESTORE_MAIN_WINDOW_GEOMETRY}
def setDisableRestoreMainWindowGeometry(*args, **kwargs) -> dict: def setDisableRestoreMainWindowGeometry(*args, **kwargs) -> dict:
config.ENABLE_RESTORE_MAIN_WINDOW_GEOMETRY = False config.RESTORE_MAIN_WINDOW_GEOMETRY = False
return {"status":200, "result":config.ENABLE_RESTORE_MAIN_WINDOW_GEOMETRY} return {"status":200, "result":config.RESTORE_MAIN_WINDOW_GEOMETRY}
def getMainWindowGeometry(*args, **kwargs) -> dict: def getMainWindowGeometry(*args, **kwargs) -> dict:
return {"status":200, "result":config.MAIN_WINDOW_GEOMETRY} return {"status":200, "result":config.MAIN_WINDOW_GEOMETRY}
@@ -548,279 +548,278 @@ def setMainWindowGeometry(data, *args, **kwargs) -> dict:
config.MAIN_WINDOW_GEOMETRY = data config.MAIN_WINDOW_GEOMETRY = data
return {"status":200, "result":config.MAIN_WINDOW_GEOMETRY} return {"status":200, "result":config.MAIN_WINDOW_GEOMETRY}
def getEnableMicAutoSelection(*args, **kwargs) -> dict: def getAutoMicSelect(*args, **kwargs) -> dict:
return {"status":200, "result":config.ENABLE_MIC_AUTO_SELECTION} return {"status":200, "result":config.AUTO_MIC_SELECT}
def setEnableMicAutoSelection(data, action, *args, **kwargs) -> dict: def setEnableAutoMicSelect(data, action, *args, **kwargs) -> dict:
update_device = UpdateSelectedMicDevice(action) update_device = UpdateSelectedMicDevice(action)
device_manager.setCallbackDefaultInputDevice(update_device.set) device_manager.setCallbackDefaultInputDevice(update_device.set)
config.ENABLE_MIC_AUTO_SELECTION = True config.AUTO_MIC_SELECT = True
return {"status":200, "result":config.ENABLE_MIC_AUTO_SELECTION} return {"status":200, "result":config.AUTO_MIC_SELECT}
def setDisableMicAutoSelection(*args, **kwargs) -> dict: def setDisableAutoMicSelect(*args, **kwargs) -> dict:
device_manager.clearCallbackDefaultInputDevice() device_manager.clearCallbackDefaultInputDevice()
config.ENABLE_MIC_AUTO_SELECTION = False config.AUTO_MIC_SELECT = False
return {"status":200, "result":config.ENABLE_MIC_AUTO_SELECTION} return {"status":200, "result":config.AUTO_MIC_SELECT}
def getChoiceMicHost(*args, **kwargs) -> dict: def getSelectedMicHost(*args, **kwargs) -> dict:
return {"status":200, "result":config.CHOICE_MIC_HOST} return {"status":200, "result":config.SELECTED_MIC_HOST}
def setChoiceMicHost(data, *args, **kwargs) -> dict: def setSelectedMicHost(data, *args, **kwargs) -> dict:
config.CHOICE_MIC_HOST = data config.SELECTED_MIC_HOST = data
config.CHOICE_MIC_DEVICE = model.getInputDefaultDevice() config.SELECTED_MIC_DEVICE = model.getInputDefaultDevice()
if config.ENABLE_CHECK_ENERGY_SEND is True: if config.ENABLE_CHECK_ENERGY_SEND is True:
model.stopCheckMicEnergy() model.stopCheckMicEnergy()
model.startCheckMicEnergy() model.startCheckMicEnergy()
return {"status":200, return {"status":200,
"result":{ "result":{
"host":config.CHOICE_MIC_HOST, "host":config.SELECTED_MIC_HOST,
"device":config.CHOICE_MIC_DEVICE, "device":config.SELECTED_MIC_DEVICE,
}, },
} }
def getChoiceMicDevice(*args, **kwargs) -> dict: def getSelectedMicDevice(*args, **kwargs) -> dict:
return {"status":200, "result":config.CHOICE_MIC_DEVICE} return {"status":200, "result":config.SELECTED_MIC_DEVICE}
def setChoiceMicDevice(data, *args, **kwargs) -> dict: def setSelectedMicDevice(data, *args, **kwargs) -> dict:
config.CHOICE_MIC_DEVICE = data config.SELECTED_MIC_DEVICE = data
if config.ENABLE_CHECK_ENERGY_SEND is True: if config.ENABLE_CHECK_ENERGY_SEND is True:
model.stopCheckMicEnergy() model.stopCheckMicEnergy()
model.startCheckMicEnergy() model.startCheckMicEnergy()
return {"status":200, "result": config.CHOICE_MIC_DEVICE} return {"status":200, "result": config.SELECTED_MIC_DEVICE}
def getInputMicEnergyThreshold(*args, **kwargs) -> dict: def getMicEnergyThreshold(*args, **kwargs) -> dict:
return {"status":200, "result":config.INPUT_MIC_ENERGY_THRESHOLD} return {"status":200, "result":config.MIC_ENERGY_THRESHOLD}
def setInputMicEnergyThreshold(data, *args, **kwargs) -> dict: def setMicEnergyThreshold(data, *args, **kwargs) -> dict:
status = 400 status = 400
data = int(data) data = int(data)
if 0 <= data <= config.MAX_MIC_ENERGY_THRESHOLD: if 0 <= data <= config.MAX_MIC_ENERGY_THRESHOLD:
config.INPUT_MIC_ENERGY_THRESHOLD = data config.MIC_ENERGY_THRESHOLD = data
status = 200 status = 200
return {"status": status, "result": config.INPUT_MIC_ENERGY_THRESHOLD} return {"status": status, "result": config.MIC_ENERGY_THRESHOLD}
def getInputMicDynamicEnergyThreshold(*args, **kwargs) -> dict: def getMicDynamicEnergyThreshold(*args, **kwargs) -> dict:
return {"status":200, "result":config.INPUT_MIC_DYNAMIC_ENERGY_THRESHOLD} return {"status":200, "result":config.MIC_DYNAMIC_ENERGY_THRESHOLD}
def setEnableInputMicDynamicEnergyThreshold(*args, **kwargs) -> dict: def setEnableMicDynamicEnergyThreshold(*args, **kwargs) -> dict:
config.INPUT_MIC_DYNAMIC_ENERGY_THRESHOLD = True config.MIC_DYNAMIC_ENERGY_THRESHOLD = True
return {"status":200, "result":config.INPUT_MIC_DYNAMIC_ENERGY_THRESHOLD} return {"status":200, "result":config.MIC_DYNAMIC_ENERGY_THRESHOLD}
def setDisableInputMicDynamicEnergyThreshold(*args, **kwargs) -> dict: def setDisableMicDynamicEnergyThreshold(*args, **kwargs) -> dict:
config.INPUT_MIC_DYNAMIC_ENERGY_THRESHOLD = False config.MIC_DYNAMIC_ENERGY_THRESHOLD = False
return {"status":200, "result":config.INPUT_MIC_DYNAMIC_ENERGY_THRESHOLD} return {"status":200, "result":config.MIC_DYNAMIC_ENERGY_THRESHOLD}
def getInputMicRecordTimeout(*args, **kwargs) -> dict: def getMicRecordTimeout(*args, **kwargs) -> dict:
return {"status":200, "result":config.INPUT_MIC_RECORD_TIMEOUT} return {"status":200, "result":config.MIC_RECORD_TIMEOUT}
def setInputMicRecordTimeout(data, *args, **kwargs) -> dict: def setMicRecordTimeout(data, *args, **kwargs) -> dict:
printLog("Set Mic Record Timeout", data) printLog("Set Mic Record Timeout", data)
try: try:
data = int(data) data = int(data)
if 0 <= data <= config.INPUT_MIC_PHRASE_TIMEOUT: if 0 <= data <= config.MIC_PHRASE_TIMEOUT:
config.INPUT_MIC_RECORD_TIMEOUT = data config.MIC_RECORD_TIMEOUT = data
else: else:
raise ValueError() raise ValueError()
except Exception: except Exception:
response = {"status":400, "result":{"message":"Error Mic Record Timeout"}} response = {"status":400, "result":{"message":"Error Mic Record Timeout"}}
else: else:
response = {"status":200, "result":config.INPUT_MIC_RECORD_TIMEOUT} response = {"status":200, "result":config.MIC_RECORD_TIMEOUT}
return response return response
def getInputMicPhraseTimeout(*args, **kwargs) -> dict: def getMicPhraseTimeout(*args, **kwargs) -> dict:
return {"status":200, "result":config.INPUT_MIC_PHRASE_TIMEOUT} return {"status":200, "result":config.MIC_PHRASE_TIMEOUT}
def setInputMicPhraseTimeout(data, *args, **kwargs) -> dict: def setMicPhraseTimeout(data, *args, **kwargs) -> dict:
printLog("Set Mic Phrase Timeout", data)
try: try:
data = int(data) data = int(data)
if data >= config.INPUT_MIC_RECORD_TIMEOUT: if data >= config.MIC_RECORD_TIMEOUT:
config.INPUT_MIC_PHRASE_TIMEOUT = data config.MIC_PHRASE_TIMEOUT = data
else: else:
raise ValueError() raise ValueError()
except Exception: except Exception:
response = {"status":400, "result":{"message":"Error Mic Phrase Timeout"}} response = {"status":400, "result":{"message":"Error Mic Phrase Timeout"}}
else: else:
response = {"status":200, "result":config.INPUT_MIC_PHRASE_TIMEOUT} response = {"status":200, "result":config.MIC_PHRASE_TIMEOUT}
return response return response
def getInputMicMaxPhrases(*args, **kwargs) -> dict: def getMicMaxPhrases(*args, **kwargs) -> dict:
return {"status":200, "result":config.INPUT_MIC_MAX_PHRASES} return {"status":200, "result":config.MIC_MAX_PHRASES}
def setInputMicMaxPhrases(data, *args, **kwargs) -> dict: def setMicMaxPhrases(data, *args, **kwargs) -> dict:
try: try:
data = int(data) data = int(data)
if 0 <= data: if 0 <= data:
config.INPUT_MIC_MAX_PHRASES = data config.MIC_MAX_PHRASES = data
else: else:
raise ValueError() raise ValueError()
except Exception: except Exception:
response = {"status":400, "result":{"message":"Error Mic Max Phrases"}} response = {"status":400, "result":{"message":"Error Mic Max Phrases"}}
else: else:
response = {"status":200, "result":config.INPUT_MIC_MAX_PHRASES} response = {"status":200, "result":config.MIC_MAX_PHRASES}
return response return response
def getInputMicWordFilter(*args, **kwargs) -> dict: def getMicWordFilter(*args, **kwargs) -> dict:
return {"status":200, "result":config.INPUT_MIC_WORD_FILTER} return {"status":200, "result":config.MIC_WORD_FILTER}
def setInputMicWordFilter(data, *args, **kwargs) -> dict: def setMicWordFilter(data, *args, **kwargs) -> dict:
data = str(data) data = str(data)
data = [w.strip() for w in data.split(",") if len(w.strip()) > 0] data = [w.strip() for w in data.split(",") if len(w.strip()) > 0]
# Copy the list # Copy the list
new_input_mic_word_filter_list = config.INPUT_MIC_WORD_FILTER new_mic_word_filter_list = config.MIC_WORD_FILTER
new_added_value = [] new_added_value = []
for value in data: for value in data:
if value in new_input_mic_word_filter_list: if value in new_mic_word_filter_list:
# If the value is already in the list, do nothing. # If the value is already in the list, do nothing.
pass pass
else: else:
new_input_mic_word_filter_list.append(value) new_mic_word_filter_list.append(value)
new_added_value.append(value) new_added_value.append(value)
config.INPUT_MIC_WORD_FILTER = new_input_mic_word_filter_list config.MIC_WORD_FILTER = new_mic_word_filter_list
model.resetKeywordProcessor() model.resetKeywordProcessor()
model.addKeywords() model.addKeywords()
return {"status":200, "result":config.INPUT_MIC_WORD_FILTER} return {"status":200, "result":config.MIC_WORD_FILTER}
def delInputMicWordFilter(data, *args, **kwargs) -> dict: def delMicWordFilter(data, *args, **kwargs) -> dict:
try: try:
new_input_mic_word_filter_list = config.INPUT_MIC_WORD_FILTER new_mic_word_filter_list = config.MIC_WORD_FILTER
new_input_mic_word_filter_list.remove(str(data)) new_mic_word_filter_list.remove(str(data))
config.INPUT_MIC_WORD_FILTER = new_input_mic_word_filter_list config.MIC_WORD_FILTER = new_mic_word_filter_list
model.resetKeywordProcessor() model.resetKeywordProcessor()
model.addKeywords() model.addKeywords()
except Exception: except Exception:
printLog("Delete Mic Word Filter", "There was no the target word in config.INPUT_MIC_WORD_FILTER") printLog("Delete Mic Word Filter", "There was no the target word in config.MIC_WORD_FILTER")
return {"status":200, "result":config.INPUT_MIC_WORD_FILTER} return {"status":200, "result":config.MIC_WORD_FILTER}
def getInputMicAvgLogprob(*args, **kwargs) -> dict: def getMicAvgLogprob(*args, **kwargs) -> dict:
return {"status":200, "result":config.INPUT_MIC_AVG_LOGPROB} return {"status":200, "result":config.MIC_AVG_LOGPROB}
def setInputMicAvgLogprob(data, *args, **kwargs) -> dict: def setMicAvgLogprob(data, *args, **kwargs) -> dict:
config.INPUT_MIC_AVG_LOGPROB = float(data) config.MIC_AVG_LOGPROB = float(data)
return {"status":200, "result":config.INPUT_MIC_AVG_LOGPROB} return {"status":200, "result":config.MIC_AVG_LOGPROB}
def getInputMicNoSpeechProb(*args, **kwargs) -> dict: def getMicNoSpeechProb(*args, **kwargs) -> dict:
return {"status":200, "result":config.INPUT_MIC_NO_SPEECH_PROB} return {"status":200, "result":config.MIC_NO_SPEECH_PROB}
def setInputMicNoSpeechProb(data, *args, **kwargs) -> dict: def setMicNoSpeechProb(data, *args, **kwargs) -> dict:
config.INPUT_MIC_NO_SPEECH_PROB = float(data) config.MIC_NO_SPEECH_PROB = float(data)
return {"status":200, "result":config.INPUT_MIC_NO_SPEECH_PROB} return {"status":200, "result":config.MIC_NO_SPEECH_PROB}
def getEnableSpeakerAutoSelection(*args, **kwargs) -> dict: def getAutoSpeakerSelect(*args, **kwargs) -> dict:
return {"status":200, "result":config.ENABLE_SPEAKER_AUTO_SELECTION} return {"status":200, "result":config.AUTO_SPEAKER_SELECT}
def setEnableSpeakerAutoSelection(data, action, *args, **kwargs) -> dict: def setEnableAutoSpeakerSelect(data, action, *args, **kwargs) -> dict:
update_device = UpdateSelectedSpeakerDevice(action) update_device = UpdateSelectedSpeakerDevice(action)
device_manager.setCallbackDefaultOutputDevice(update_device.set) device_manager.setCallbackDefaultOutputDevice(update_device.set)
config.ENABLE_SPEAKER_AUTO_SELECTION = True config.AUTO_SPEAKER_SELECT = True
return {"status":200, "result":config.ENABLE_SPEAKER_AUTO_SELECTION} return {"status":200, "result":config.AUTO_SPEAKER_SELECT}
def setDisableSpeakerAutoSelection(*args, **kwargs) -> dict: def setDisableAutoSpeakerSelect(*args, **kwargs) -> dict:
device_manager.clearCallbackDefaultInputDevice() device_manager.clearCallbackDefaultInputDevice()
config.ENABLE_SPEAKER_AUTO_SELECTION = False config.AUTO_SPEAKER_SELECT = False
return {"status":200, "result":config.ENABLE_SPEAKER_AUTO_SELECTION} return {"status":200, "result":config.AUTO_SPEAKER_SELECT}
def getChoiceSpeakerDevice(*args, **kwargs) -> dict: def getSelectedSpeakerDevice(*args, **kwargs) -> dict:
return {"status":200, "result":config.CHOICE_SPEAKER_DEVICE} return {"status":200, "result":config.SELECTED_SPEAKER_DEVICE}
def setChoiceSpeakerDevice(data, *args, **kwargs) -> dict: def setSelectedSpeakerDevice(data, *args, **kwargs) -> dict:
config.CHOICE_SPEAKER_DEVICE = data config.SELECTED_SPEAKER_DEVICE = data
if config.ENABLE_CHECK_ENERGY_RECEIVE is True: if config.ENABLE_CHECK_ENERGY_RECEIVE is True:
model.stopCheckSpeakerEnergy() model.stopCheckSpeakerEnergy()
model.startCheckSpeakerEnergy() model.startCheckSpeakerEnergy()
return {"status":200, "result":config.CHOICE_SPEAKER_DEVICE} return {"status":200, "result":config.SELECTED_SPEAKER_DEVICE}
def getInputSpeakerEnergyThreshold(*args, **kwargs) -> dict: def getSpeakerEnergyThreshold(*args, **kwargs) -> dict:
return {"status":200, "result":config.INPUT_SPEAKER_ENERGY_THRESHOLD} return {"status":200, "result":config.SPEAKER_ENERGY_THRESHOLD}
def setInputSpeakerEnergyThreshold(data, *args, **kwargs) -> dict: def setSpeakerEnergyThreshold(data, *args, **kwargs) -> dict:
printLog("Set Speaker Energy Threshold", data) printLog("Set Speaker Energy Threshold", data)
try: try:
data = int(data) data = int(data)
if 0 <= data <= config.MAX_SPEAKER_ENERGY_THRESHOLD: if 0 <= data <= config.MAX_SPEAKER_ENERGY_THRESHOLD:
config.INPUT_SPEAKER_ENERGY_THRESHOLD = data config.SPEAKER_ENERGY_THRESHOLD = data
else: else:
raise ValueError() raise ValueError()
except Exception: except Exception:
response = {"status":400, "result":{"message":"Error Set Speaker Energy Threshold"}} response = {"status":400, "result":{"message":"Error Set Speaker Energy Threshold"}}
else: else:
response = {"status":200, "result":config.INPUT_SPEAKER_ENERGY_THRESHOLD} response = {"status":200, "result":config.SPEAKER_ENERGY_THRESHOLD}
return response return response
def getInputSpeakerDynamicEnergyThreshold(*args, **kwargs) -> dict: def getSpeakerDynamicEnergyThreshold(*args, **kwargs) -> dict:
return {"status":200, "result":config.INPUT_SPEAKER_DYNAMIC_ENERGY_THRESHOLD} return {"status":200, "result":config.SPEAKER_DYNAMIC_ENERGY_THRESHOLD}
def setEnableInputSpeakerDynamicEnergyThreshold(*args, **kwargs) -> dict: def setEnableSpeakerDynamicEnergyThreshold(*args, **kwargs) -> dict:
config.INPUT_SPEAKER_DYNAMIC_ENERGY_THRESHOLD = True config.SPEAKER_DYNAMIC_ENERGY_THRESHOLD = True
return {"status":200, "result":config.INPUT_SPEAKER_DYNAMIC_ENERGY_THRESHOLD} return {"status":200, "result":config.SPEAKER_DYNAMIC_ENERGY_THRESHOLD}
def setDisableInputSpeakerDynamicEnergyThreshold(*args, **kwargs) -> dict: def setDisableSpeakerDynamicEnergyThreshold(*args, **kwargs) -> dict:
config.INPUT_SPEAKER_DYNAMIC_ENERGY_THRESHOLD = False config.SPEAKER_DYNAMIC_ENERGY_THRESHOLD = False
return {"status":200, "result":config.INPUT_SPEAKER_DYNAMIC_ENERGY_THRESHOLD} return {"status":200, "result":config.SPEAKER_DYNAMIC_ENERGY_THRESHOLD}
def getInputSpeakerRecordTimeout(*args, **kwargs) -> dict: def getSpeakerRecordTimeout(*args, **kwargs) -> dict:
return {"status":200, "result":config.INPUT_SPEAKER_RECORD_TIMEOUT} return {"status":200, "result":config.SPEAKER_RECORD_TIMEOUT}
def setInputSpeakerRecordTimeout(data, *args, **kwargs) -> dict: def setSpeakerRecordTimeout(data, *args, **kwargs) -> dict:
try: try:
data = int(data) data = int(data)
if 0 <= data <= config.INPUT_SPEAKER_PHRASE_TIMEOUT: if 0 <= data <= config.SPEAKER_PHRASE_TIMEOUT:
config.INPUT_SPEAKER_RECORD_TIMEOUT = data config.SPEAKER_RECORD_TIMEOUT = data
else: else:
raise ValueError() raise ValueError()
except Exception: except Exception:
response = {"status":400, "result":{"message":"Error Speaker Record Timeout"}} response = {"status":400, "result":{"message":"Error Speaker Record Timeout"}}
else: else:
response = {"status":200, "result":config.INPUT_SPEAKER_RECORD_TIMEOUT} response = {"status":200, "result":config.SPEAKER_RECORD_TIMEOUT}
return response return response
def getInputSpeakerPhraseTimeout(*args, **kwargs) -> dict: def getSpeakerPhraseTimeout(*args, **kwargs) -> dict:
return {"status":200, "result":config.INPUT_SPEAKER_PHRASE_TIMEOUT} return {"status":200, "result":config.SPEAKER_PHRASE_TIMEOUT}
def setInputSpeakerPhraseTimeout(data, *args, **kwargs) -> dict: def setSpeakerPhraseTimeout(data, *args, **kwargs) -> dict:
try: try:
data = int(data) data = int(data)
if 0 <= data and data >= config.INPUT_SPEAKER_RECORD_TIMEOUT: if 0 <= data and data >= config.SPEAKER_RECORD_TIMEOUT:
config.INPUT_SPEAKER_PHRASE_TIMEOUT = data config.SPEAKER_PHRASE_TIMEOUT = data
else: else:
raise ValueError() raise ValueError()
except Exception: except Exception:
response = {"status":400, "result":{"message":"Error Speaker Phrase Timeout"}} response = {"status":400, "result":{"message":"Error Speaker Phrase Timeout"}}
else: else:
response = {"status":200, "result":config.INPUT_SPEAKER_PHRASE_TIMEOUT} response = {"status":200, "result":config.SPEAKER_PHRASE_TIMEOUT}
return response return response
def getInputSpeakerMaxPhrases(*args, **kwargs) -> dict: def getSpeakerMaxPhrases(*args, **kwargs) -> dict:
return {"status":200, "result":config.INPUT_SPEAKER_MAX_PHRASES} return {"status":200, "result":config.SPEAKER_MAX_PHRASES}
def setInputSpeakerMaxPhrases(data, *args, **kwargs) -> dict: def setSpeakerMaxPhrases(data, *args, **kwargs) -> dict:
printLog("Set Speaker Max Phrases", data) printLog("Set Speaker Max Phrases", data)
try: try:
data = int(data) data = int(data)
if 0 <= data: if 0 <= data:
config.INPUT_SPEAKER_MAX_PHRASES = data config.SPEAKER_MAX_PHRASES = data
else: else:
raise ValueError() raise ValueError()
except Exception: except Exception:
response = {"status":400, "result":{"message":"Error Speaker Max Phrases"}} response = {"status":400, "result":{"message":"Error Speaker Max Phrases"}}
else: else:
response = {"status":200, "result":config.INPUT_SPEAKER_MAX_PHRASES} response = {"status":200, "result":config.SPEAKER_MAX_PHRASES}
return response return response
def getInputSpeakerAvgLogprob(*args, **kwargs) -> dict: def getSpeakerAvgLogprob(*args, **kwargs) -> dict:
return {"status":200, "result":config.INPUT_SPEAKER_AVG_LOGPROB} return {"status":200, "result":config.SPEAKER_AVG_LOGPROB}
def setInputSpeakerAvgLogprob(data, *args, **kwargs) -> dict: def setSpeakerAvgLogprob(data, *args, **kwargs) -> dict:
config.INPUT_SPEAKER_AVG_LOGPROB = float(data) config.SPEAKER_AVG_LOGPROB = float(data)
return {"status":200, "result":config.INPUT_SPEAKER_AVG_LOGPROB} return {"status":200, "result":config.SPEAKER_AVG_LOGPROB}
def getInputSpeakerNoSpeechProb(*args, **kwargs) -> dict: def getSpeakerNoSpeechProb(*args, **kwargs) -> dict:
return {"status":200, "result":config.INPUT_SPEAKER_NO_SPEECH_PROB} return {"status":200, "result":config.SPEAKER_NO_SPEECH_PROB}
def setInputSpeakerNoSpeechProb(data, *args, **kwargs) -> dict: def setSpeakerNoSpeechProb(data, *args, **kwargs) -> dict:
config.INPUT_SPEAKER_NO_SPEECH_PROB = float(data) config.SPEAKER_NO_SPEECH_PROB = float(data)
return {"status":200, "result":config.INPUT_SPEAKER_NO_SPEECH_PROB} return {"status":200, "result":config.SPEAKER_NO_SPEECH_PROB}
def getOscIpAddress(*args, **kwargs) -> dict: def getOscIpAddress(*args, **kwargs) -> dict:
return {"status":200, "result":config.OSC_IP_ADDRESS} return {"status":200, "result":config.OSC_IP_ADDRESS}
@@ -964,27 +963,27 @@ def setWhisperWeightType(data, *args, **kwargs) -> dict:
} }
} }
def getEnableAutoClearMessageBox(*args, **kwargs) -> dict: def getAutoClearMessageBox(*args, **kwargs) -> dict:
return {"status":200, "result":config.ENABLE_AUTO_CLEAR_MESSAGE_BOX} return {"status":200, "result":config.AUTO_CLEAR_MESSAGE_BOX}
def setEnableAutoClearMessageBox(*args, **kwargs) -> dict: def setEnableAutoClearMessageBox(*args, **kwargs) -> dict:
config.ENABLE_AUTO_CLEAR_MESSAGE_BOX = True config.AUTO_CLEAR_MESSAGE_BOX = True
return {"status":200, "result":config.ENABLE_AUTO_CLEAR_MESSAGE_BOX} return {"status":200, "result":config.AUTO_CLEAR_MESSAGE_BOX}
def setDisableAutoClearMessageBox(*args, **kwargs) -> dict: def setDisableAutoClearMessageBox(*args, **kwargs) -> dict:
config.ENABLE_AUTO_CLEAR_MESSAGE_BOX = False config.AUTO_CLEAR_MESSAGE_BOX = False
return {"status":200, "result":config.ENABLE_AUTO_CLEAR_MESSAGE_BOX} return {"status":200, "result":config.AUTO_CLEAR_MESSAGE_BOX}
def getEnableSendOnlyTranslatedMessages(*args, **kwargs) -> dict: def getSendOnlyTranslatedMessages(*args, **kwargs) -> dict:
return {"status":200, "result":config.ENABLE_SEND_ONLY_TRANSLATED_MESSAGES} return {"status":200, "result":config.SEND_ONLY_TRANSLATED_MESSAGES}
def setEnableSendOnlyTranslatedMessages(*args, **kwargs) -> dict: def setEnableSendOnlyTranslatedMessages(*args, **kwargs) -> dict:
config.ENABLE_SEND_ONLY_TRANSLATED_MESSAGES = True config.SEND_ONLY_TRANSLATED_MESSAGES = True
return {"status":200, "result":config.ENABLE_SEND_ONLY_TRANSLATED_MESSAGES} return {"status":200, "result":config.SEND_ONLY_TRANSLATED_MESSAGES}
def setDisableSendOnlyTranslatedMessages(*args, **kwargs) -> dict: def setDisableSendOnlyTranslatedMessages(*args, **kwargs) -> dict:
config.ENABLE_SEND_ONLY_TRANSLATED_MESSAGES = False config.SEND_ONLY_TRANSLATED_MESSAGES = False
return {"status":200, "result":config.ENABLE_SEND_ONLY_TRANSLATED_MESSAGES} return {"status":200, "result":config.SEND_ONLY_TRANSLATED_MESSAGES}
def getSendMessageButtonType(*args, **kwargs) -> dict: def getSendMessageButtonType(*args, **kwargs) -> dict:
return {"status":200, "result":config.SEND_MESSAGE_BUTTON_TYPE} return {"status":200, "result":config.SEND_MESSAGE_BUTTON_TYPE}
@@ -1010,33 +1009,33 @@ def setOverlaySmallLogSettings(data, *args, **kwargs) -> dict:
model.updateOverlayPosition() model.updateOverlayPosition()
return {"status":200, "result":config.OVERLAY_SMALL_LOG_SETTINGS} return {"status":200, "result":config.OVERLAY_SMALL_LOG_SETTINGS}
def getEnableOverlaySmallLog(*args, **kwargs) -> dict: def getOverlaySmallLog(*args, **kwargs) -> dict:
return {"status":200, "result":config.ENABLE_OVERLAY_SMALL_LOG} return {"status":200, "result":config.OVERLAY_SMALL_LOG}
def setEnableOverlaySmallLog(*args, **kwargs) -> dict: def setEnableOverlaySmallLog(*args, **kwargs) -> dict:
config.ENABLE_OVERLAY_SMALL_LOG = True config.OVERLAY_SMALL_LOG = True
if config.ENABLE_OVERLAY_SMALL_LOG is True and config.ENABLE_TRANSCRIPTION_RECEIVE is True: if config.OVERLAY_SMALL_LOG is True and config.ENABLE_TRANSCRIPTION_RECEIVE is True:
if model.overlay.initialized is False and model.overlay.checkSteamvrRunning() is True: if model.overlay.initialized is False and model.overlay.checkSteamvrRunning() is True:
model.startOverlay() model.startOverlay()
return {"status":200, "result":config.ENABLE_OVERLAY_SMALL_LOG} return {"status":200, "result":config.OVERLAY_SMALL_LOG}
def setDisableOverlaySmallLog(*args, **kwargs) -> dict: def setDisableOverlaySmallLog(*args, **kwargs) -> dict:
config.ENABLE_OVERLAY_SMALL_LOG = False config.OVERLAY_SMALL_LOG = False
if config.ENABLE_OVERLAY_SMALL_LOG is False: if config.OVERLAY_SMALL_LOG is False:
model.clearOverlayImage() model.clearOverlayImage()
model.shutdownOverlay() model.shutdownOverlay()
return {"status":200, "result":config.ENABLE_OVERLAY_SMALL_LOG} return {"status":200, "result":config.OVERLAY_SMALL_LOG}
def getEnableSendMessageToVrc(*args, **kwargs) -> dict: def getSendMessageToVrc(*args, **kwargs) -> dict:
return {"status":200, "result":config.ENABLE_SEND_MESSAGE_TO_VRC} return {"status":200, "result":config.SEND_MESSAGE_TO_VRC}
def setEnableSendMessageToVrc(*args, **kwargs) -> dict: def setEnableSendMessageToVrc(*args, **kwargs) -> dict:
config.ENABLE_SEND_MESSAGE_TO_VRC = True config.SEND_MESSAGE_TO_VRC = True
return {"status":200, "result":config.ENABLE_SEND_MESSAGE_TO_VRC} return {"status":200, "result":config.SEND_MESSAGE_TO_VRC}
def setDisableSendMessageToVrc(*args, **kwargs) -> dict: def setDisableSendMessageToVrc(*args, **kwargs) -> dict:
config.ENABLE_SEND_MESSAGE_TO_VRC = False config.SEND_MESSAGE_TO_VRC = False
return {"status":200, "result":config.ENABLE_SEND_MESSAGE_TO_VRC} return {"status":200, "result":config.SEND_MESSAGE_TO_VRC}
def getSendMessageFormat(*args, **kwargs) -> dict: def getSendMessageFormat(*args, **kwargs) -> dict:
return {"status":200, "result":config.SEND_MESSAGE_FORMAT} return {"status":200, "result":config.SEND_MESSAGE_FORMAT}
@@ -1072,55 +1071,51 @@ def setReceivedMessageFormatWithT(data, *args, **kwargs) -> dict:
config.RECEIVED_MESSAGE_FORMAT_WITH_T = data config.RECEIVED_MESSAGE_FORMAT_WITH_T = data
return {"status":200, "result":config.RECEIVED_MESSAGE_FORMAT_WITH_T} return {"status":200, "result":config.RECEIVED_MESSAGE_FORMAT_WITH_T}
def getEnableSpeaker2ChatboxPass(*args, **kwargs) -> dict: def getSpeaker2ChatboxPass(*args, **kwargs) -> dict:
return {"status":200, "result":config.ENABLE_SPEAKER2CHATBOX_PASS} return {"status":200, "result":config.SPEAKER2CHATBOX_PASS}
def setEnableSpeaker2ChatboxPass(*args, **kwargs) -> dict: def setSpeaker2ChatboxPass(data, *args, **kwargs) -> dict:
config.ENABLE_SPEAKER2CHATBOX_PASS = True config.SPEAKER2CHATBOX_PASS = data
return {"status":200, "result":config.ENABLE_SPEAKER2CHATBOX_PASS} return {"status":200, "result":config.SPEAKER2CHATBOX_PASS}
def setDisableSpeaker2ChatboxPass(*args, **kwargs) -> dict: def getSendReceivedMessageToVrc(*args, **kwargs) -> dict:
config.ENABLE_SPEAKER2CHATBOX_PASS = False return {"status":200, "result":config.SEND_RECEIVED_MESSAGE_TO_VRC}
return {"status":200, "result":config.ENABLE_SPEAKER2CHATBOX_PASS}
def getEnableSendReceivedMessageToVrc(*args, **kwargs) -> dict:
return {"status":200, "result":config.ENABLE_SEND_RECEIVED_MESSAGE_TO_VRC}
def setEnableSendReceivedMessageToVrc(*args, **kwargs) -> dict: def setEnableSendReceivedMessageToVrc(*args, **kwargs) -> dict:
config.ENABLE_SEND_RECEIVED_MESSAGE_TO_VRC = True config.SEND_RECEIVED_MESSAGE_TO_VRC = True
return {"status":200, "result":config.ENABLE_SEND_RECEIVED_MESSAGE_TO_VRC} return {"status":200, "result":config.SEND_RECEIVED_MESSAGE_TO_VRC}
def setDisableSendReceivedMessageToVrc(*args, **kwargs) -> dict: def setDisableSendReceivedMessageToVrc(*args, **kwargs) -> dict:
config.ENABLE_SEND_RECEIVED_MESSAGE_TO_VRC = False config.SEND_RECEIVED_MESSAGE_TO_VRC = False
return {"status":200, "result":config.ENABLE_SEND_RECEIVED_MESSAGE_TO_VRC} return {"status":200, "result":config.SEND_RECEIVED_MESSAGE_TO_VRC}
def getEnableLogger(*args, **kwargs) -> dict: def getLogger(*args, **kwargs) -> dict:
return {"status":200, "result":config.ENABLE_LOGGER} return {"status":200, "result":config.LOGGER}
def setEnableLogger(*args, **kwargs) -> dict: def setEnableLogger(*args, **kwargs) -> dict:
config.ENABLE_LOGGER = True config.LOGGER = True
model.startLogger() model.startLogger()
return {"status":200, "result":config.ENABLE_LOGGER} return {"status":200, "result":config.LOGGER}
def setDisableLogger(*args, **kwargs) -> dict: def setDisableLogger(*args, **kwargs) -> dict:
model.stopLogger() model.stopLogger()
config.ENABLE_LOGGER = False config.LOGGER = False
return {"status":200, "result":config.ENABLE_LOGGER} return {"status":200, "result":config.LOGGER}
def getEnableVrcMicMuteSync(*args, **kwargs) -> dict: def getVrcMicMuteSync(*args, **kwargs) -> dict:
return {"status":200, "result":config.ENABLE_VRC_MIC_MUTE_SYNC} return {"status":200, "result":config.VRC_MIC_MUTE_SYNC}
def setEnableVrcMicMuteSync(*args, **kwargs) -> dict: def setEnableVrcMicMuteSync(*args, **kwargs) -> dict:
config.ENABLE_VRC_MIC_MUTE_SYNC = True config.VRC_MIC_MUTE_SYNC = True
model.startCheckMuteSelfStatus() model.startCheckMuteSelfStatus()
model.changeMicTranscriptStatus() model.changeMicTranscriptStatus()
return {"status":200, "result":config.ENABLE_VRC_MIC_MUTE_SYNC} return {"status":200, "result":config.VRC_MIC_MUTE_SYNC}
def setDisableVrcMicMuteSync(*args, **kwargs) -> dict: def setDisableVrcMicMuteSync(*args, **kwargs) -> dict:
config.ENABLE_VRC_MIC_MUTE_SYNC = False config.VRC_MIC_MUTE_SYNC = False
model.stopCheckMuteSelfStatus() model.stopCheckMuteSelfStatus()
model.changeMicTranscriptStatus() model.changeMicTranscriptStatus()
return {"status":200, "result":config.ENABLE_VRC_MIC_MUTE_SYNC} return {"status":200, "result":config.VRC_MIC_MUTE_SYNC}
def setEnableCheckSpeakerThreshold(data, action, *args, **kwargs) -> dict: def setEnableCheckSpeakerThreshold(data, action, *args, **kwargs) -> dict:
progressbar_speaker_energy = ProgressBarSpeakerEnergy(action) progressbar_speaker_energy = ProgressBarSpeakerEnergy(action)
@@ -1180,7 +1175,7 @@ def setDisableTranscriptionSend(*args, **kwargs) -> dict:
def setEnableTranscriptionReceive(data, action, *args, **kwargs) -> dict: def setEnableTranscriptionReceive(data, action, *args, **kwargs) -> dict:
startThreadingTranscriptionReceiveMessage(action) startThreadingTranscriptionReceiveMessage(action)
if config.ENABLE_OVERLAY_SMALL_LOG is True: if config.OVERLAY_SMALL_LOG is True:
if model.overlay.initialized is False and model.overlay.checkSteamvrRunning() is True: if model.overlay.initialized is False and model.overlay.checkSteamvrRunning() is True:
model.startOverlay() model.startOverlay()
config.ENABLE_TRANSCRIPTION_RECEIVE = True config.ENABLE_TRANSCRIPTION_RECEIVE = True
@@ -1198,12 +1193,12 @@ def sendMessageBox(data, action, *args, **kwargs) -> dict:
return response return response
def typingMessageBox(*args, **kwargs) -> dict: def typingMessageBox(*args, **kwargs) -> dict:
if config.ENABLE_SEND_MESSAGE_TO_VRC is True: if config.SEND_MESSAGE_TO_VRC is True:
model.oscStartSendTyping() model.oscStartSendTyping()
return {"status":200, "result":True} return {"status":200, "result":True}
def stopTypingMessageBox(*args, **kwargs) -> dict: def stopTypingMessageBox(*args, **kwargs) -> dict:
if config.ENABLE_SEND_MESSAGE_TO_VRC is True: if config.SEND_MESSAGE_TO_VRC is True:
model.oscStopSendTyping() model.oscStopSendTyping()
return {"status":200, "result":True} return {"status":200, "result":True}
@@ -1426,22 +1421,22 @@ def init(actions:dict, *args, **kwargs) -> None:
# init logger # init logger
printLog("Init Logger") printLog("Init Logger")
if config.ENABLE_LOGGER is True: if config.LOGGER is True:
model.startLogger() model.startLogger()
# init OSC receive # init OSC receive
printLog("Init OSC Receive") printLog("Init OSC Receive")
model.startReceiveOSC() model.startReceiveOSC()
if config.ENABLE_VRC_MIC_MUTE_SYNC is True: if config.VRC_MIC_MUTE_SYNC is True:
model.startCheckMuteSelfStatus() model.startCheckMuteSelfStatus()
# init Auto device selection # init Auto device selection
printLog("Init Auto Device Selection") printLog("Init Auto Device Selection")
if config.ENABLE_MIC_AUTO_SELECTION is True: if config.AUTO_MIC_SELECT is True:
update_mic_device = UpdateSelectedMicDevice(actions["update_selected_mic_device"]) update_mic_device = UpdateSelectedMicDevice(actions["update_selected_mic_device"])
device_manager.setCallbackDefaultInputDevice(update_mic_device.set) device_manager.setCallbackDefaultInputDevice(update_mic_device.set)
if config.ENABLE_SPEAKER_AUTO_SELECTION is True: if config.AUTO_SPEAKER_SELECT is True:
update_speaker_device = UpdateSelectedSpeakerDevice(actions["update_selected_speaker_device"]) update_speaker_device = UpdateSelectedSpeakerDevice(actions["update_selected_speaker_device"])
device_manager.setCallbackDefaultOutputDevice(update_speaker_device.set) device_manager.setCallbackDefaultOutputDevice(update_speaker_device.set)

174
src-python/webui_mainloop.py
View File

@@ -47,19 +47,19 @@ mapping = {
"/get/selected_transcription_engine": {"status": False, "variable":controller.getSelectedTranscriptionEngine}, "/get/selected_transcription_engine": {"status": False, "variable":controller.getSelectedTranscriptionEngine},
"/get/enable_multi_language_translation": {"status": True, "variable":controller.getEnableMultiLanguageTranslation}, "/get/multi_language_translation": {"status": True, "variable":controller.getMultiLanguageTranslation},
"/set/enable_multi_language_translation": {"status": True, "variable":controller.setEnableMultiLanguageTranslation}, "/set/enable_multi_language_translation": {"status": True, "variable":controller.setEnableMultiLanguageTranslation},
"/set/disable_multi_language_translation": {"status": True, "variable":controller.setDisableMultiLanguageTranslation}, "/set/disable_multi_language_translation": {"status": True, "variable":controller.setDisableMultiLanguageTranslation},
"/get/enable_convert_message_to_romaji": {"status": True, "variable":controller.getEnableConvertMessageToRomaji}, "/get/convert_message_to_romaji": {"status": True, "variable":controller.getConvertMessageToRomaji},
"/set/enable_convert_message_to_romaji": {"status": True, "variable":controller.setEnableConvertMessageToRomaji}, "/set/enable_convert_message_to_romaji": {"status": True, "variable":controller.setEnableConvertMessageToRomaji},
"/set/disable_convert_message_to_romaji": {"status": True, "variable":controller.setDisableConvertMessageToRomaji}, "/set/disable_convert_message_to_romaji": {"status": True, "variable":controller.setDisableConvertMessageToRomaji},
"/get/enable_convert_message_to_hiragana": {"status": True, "variable":controller.getEnableConvertMessageToHiragana}, "/get/convert_message_to_hiragana": {"status": True, "variable":controller.getConvertMessageToHiragana},
"/set/enable_convert_message_to_hiragana": {"status": True, "variable":controller.setEnableConvertMessageToHiragana}, "/set/enable_convert_message_to_hiragana": {"status": True, "variable":controller.setEnableConvertMessageToHiragana},
"/set/disable_convert_message_to_hiragana": {"status": True, "variable":controller.setDisableConvertMessageToHiragana}, "/set/disable_convert_message_to_hiragana": {"status": True, "variable":controller.setDisableConvertMessageToHiragana},
"/get/enable_main_window_sidebar_compact_mode": {"status": True, "variable":controller.getEnableMainWindowSidebarCompactMode}, "/get/main_window_sidebar_compact_mode": {"status": True, "variable":controller.getMainWindowSidebarCompactMode},
"/set/enable_main_window_sidebar_compact_mode": {"status": True, "variable":controller.setEnableMainWindowSidebarCompactMode}, "/set/enable_main_window_sidebar_compact_mode": {"status": True, "variable":controller.setEnableMainWindowSidebarCompactMode},
"/set/disable_main_window_sidebar_compact_mode": {"status": True, "variable":controller.setDisableMainWindowSidebarCompactMode}, "/set/disable_main_window_sidebar_compact_mode": {"status": True, "variable":controller.setDisableMainWindowSidebarCompactMode},
@@ -84,76 +84,77 @@ mapping = {
"/get/ui_language": {"status": True, "variable":controller.getUiLanguage}, "/get/ui_language": {"status": True, "variable":controller.getUiLanguage},
"/set/ui_language": {"status": True, "variable":controller.setUiLanguage}, "/set/ui_language": {"status": True, "variable":controller.setUiLanguage},
"/get/enable_restore_main_window_geometry": {"status": True, "variable":controller.getEnableRestoreMainWindowGeometry}, "/get/restore_main_window_geometry": {"status": True, "variable":controller.getRestoreMainWindowGeometry},
"/set/enable_restore_main_window_geometry": {"status": True, "variable":controller.setEnableRestoreMainWindowGeometry}, "/set/enable_restore_main_window_geometry": {"status": True, "variable":controller.setEnableRestoreMainWindowGeometry},
"/set/disable_restore_main_window_geometry": {"status": True, "variable":controller.setDisableRestoreMainWindowGeometry}, "/set/disable_restore_main_window_geometry": {"status": True, "variable":controller.setDisableRestoreMainWindowGeometry},
"/get/main_window_geometry": {"status": True, "variable":controller.getMainWindowGeometry}, "/get/main_window_geometry": {"status": True, "variable":controller.getMainWindowGeometry},
"/set/main_window_geometry": {"status": True, "variable":controller.setMainWindowGeometry}, "/set/main_window_geometry": {"status": True, "variable":controller.setMainWindowGeometry},
"/get/enable_mic_auto_selection": {"status": True, "variable":controller.getEnableMicAutoSelection}, "/get/auto_mic_select": {"status": True, "variable":controller.getAutoMicSelect},
"/set/enable_mic_auto_selection": {"status": True, "variable":controller.setEnableMicAutoSelection}, "/set/enable_auto_mic_select": {"status": True, "variable":controller.setEnableAutoMicSelect},
"/set/disable_mic_auto_selection": {"status": True, "variable":controller.setDisableMicAutoSelection}, "/set/disable_auto_mic_select": {"status": True, "variable":controller.setDisableAutoMicSelect},
"/get/choice_mic_host": {"status": True, "variable":controller.getChoiceMicHost}, "/get/selected_mic_host": {"status": True, "variable":controller.getSelectedMicHost},
"/set/choice_mic_host": {"status": True, "variable":controller.setChoiceMicHost}, "/set/selected_mic_host": {"status": True, "variable":controller.setSelectedMicHost},
"/get/choice_mic_device": {"status": True, "variable":controller.getChoiceMicDevice}, "/get/selected_mic_device": {"status": True, "variable":controller.getSelectedMicDevice},
"/set/choice_mic_device": {"status": True, "variable":controller.setChoiceMicDevice}, "/set/selected_mic_device": {"status": True, "variable":controller.setSelectedMicDevice},
"/get/input_mic_energy_threshold": {"status": True, "variable":controller.getInputMicEnergyThreshold}, "/get/mic_energy_threshold": {"status": True, "variable":controller.getMicEnergyThreshold},
"/set/input_mic_energy_threshold": {"status": True, "variable":controller.setInputMicEnergyThreshold}, "/set/mic_energy_threshold": {"status": True, "variable":controller.setMicEnergyThreshold},
"/get/input_mic_dynamic_energy_threshold": {"status": True, "variable":controller.getInputMicDynamicEnergyThreshold}, "/get/mic_dynamic_energy_threshold": {"status": True, "variable":controller.getMicDynamicEnergyThreshold},
"/set/enable_input_mic_dynamic_energy_threshold": {"status": True, "variable":controller.setEnableInputMicDynamicEnergyThreshold}, "/set/enable_mic_dynamic_energy_threshold": {"status": True, "variable":controller.setEnableMicDynamicEnergyThreshold},
"/set/disable_input_mic_dynamic_energy_threshold": {"status": True, "variable":controller.setDisableInputMicDynamicEnergyThreshold}, "/set/disable_mic_dynamic_energy_threshold": {"status": True, "variable":controller.setDisableMicDynamicEnergyThreshold},
"/get/input_mic_record_timeout": {"status": True, "variable":controller.getInputMicRecordTimeout}, "/get/mic_record_timeout": {"status": True, "variable":controller.getMicRecordTimeout},
"/set/input_mic_record_timeout": {"status": True, "variable":controller.setInputMicRecordTimeout}, "/set/mic_record_timeout": {"status": True, "variable":controller.setMicRecordTimeout},
"/get/input_mic_phrase_timeout": {"status": True, "variable":controller.getInputMicPhraseTimeout}, "/get/mic_phrase_timeout": {"status": True, "variable":controller.getMicPhraseTimeout},
"/set/input_mic_phrase_timeout": {"status": True, "variable":controller.setInputMicPhraseTimeout}, "/set/mic_phrase_timeout": {"status": True, "variable":controller.setMicPhraseTimeout},
"/get/input_mic_max_phrases": {"status": True, "variable":controller.getInputMicMaxPhrases}, "/get/mic_max_phrases": {"status": True, "variable":controller.getMicMaxPhrases},
"/set/input_mic_max_phrases": {"status": True, "variable":controller.setInputMicMaxPhrases}, "/set/mic_max_phrases": {"status": True, "variable":controller.setMicMaxPhrases},
"/get/input_mic_word_filter": {"status": True, "variable":controller.getInputMicWordFilter}, "/get/mic_word_filter": {"status": True, "variable":controller.getMicWordFilter},
"/set/input_mic_word_filter": {"status": True, "variable":controller.setInputMicWordFilter}, "/set/mic_word_filter": {"status": True, "variable":controller.setMicWordFilter},
"/del/input_mic_word_filter": {"status": True, "variable":controller.delInputMicWordFilter}, "/del/mic_word_filter": {"status": True, "variable":controller.delMicWordFilter},
"/get/input_mic_avg_logprob": {"status": True, "variable":controller.getInputMicAvgLogprob}, "/get/mic_avg_logprob": {"status": True, "variable":controller.getMicAvgLogprob},
"/set/input_mic_avg_logprob": {"status": True, "variable":controller.setInputMicAvgLogprob}, "/set/mic_avg_logprob": {"status": True, "variable":controller.setMicAvgLogprob},
"/get/input_mic_no_speech_prob": {"status": True, "variable":controller.getInputMicNoSpeechProb}, "/get/mic_no_speech_prob": {"status": True, "variable":controller.getMicNoSpeechProb},
"/set/input_mic_no_speech_prob": {"status": True, "variable":controller.setInputMicNoSpeechProb}, "/set/mic_no_speech_prob": {"status": True, "variable":controller.setMicNoSpeechProb},
"/set/enable_speaker_auto_selection": {"status": True, "variable":controller.setEnableSpeakerAutoSelection}, "/get/auto_speaker_select": {"status": True, "variable":controller.getAutoSpeakerSelect},
"/set/disable_speaker_auto_selection": {"status": True, "variable":controller.setDisableSpeakerAutoSelection}, "/set/enable_auto_speaker_select": {"status": True, "variable":controller.setEnableAutoSpeakerSelect},
"/set/disable_auto_speaker_select": {"status": True, "variable":controller.setDisableAutoSpeakerSelect},
"/get/choice_speaker_device": {"status": True, "variable":controller.getChoiceSpeakerDevice}, "/get/selected_speaker_device": {"status": True, "variable":controller.getSelectedSpeakerDevice},
"/set/choice_speaker_device": {"status": True, "variable":controller.setChoiceSpeakerDevice}, "/set/selected_speaker_device": {"status": True, "variable":controller.setSelectedSpeakerDevice},
"/get/input_speaker_energy_threshold": {"status": True, "variable":controller.getInputSpeakerEnergyThreshold}, "/get/speaker_energy_threshold": {"status": True, "variable":controller.getSpeakerEnergyThreshold},
"/set/input_speaker_energy_threshold": {"status": True, "variable":controller.setInputSpeakerEnergyThreshold}, "/set/speaker_energy_threshold": {"status": True, "variable":controller.setSpeakerEnergyThreshold},
"/get/input_speaker_dynamic_energy_threshold": {"status": True, "variable":controller.getInputSpeakerDynamicEnergyThreshold}, "/get/speaker_dynamic_energy_threshold": {"status": True, "variable":controller.getSpeakerDynamicEnergyThreshold},
"/set/enable_input_speaker_dynamic_energy_threshold": {"status": True, "variable":controller.setEnableInputSpeakerDynamicEnergyThreshold}, "/set/enable_speaker_dynamic_energy_threshold": {"status": True, "variable":controller.setEnableSpeakerDynamicEnergyThreshold},
"/set/disable_input_speaker_dynamic_energy_threshold": {"status": True, "variable":controller.setDisableInputSpeakerDynamicEnergyThreshold}, "/set/disable_speaker_dynamic_energy_threshold": {"status": True, "variable":controller.setDisableSpeakerDynamicEnergyThreshold},
"/get/input_speaker_record_timeout": {"status": True, "variable":controller.getInputSpeakerRecordTimeout}, "/get/speaker_record_timeout": {"status": True, "variable":controller.getSpeakerRecordTimeout},
"/set/input_speaker_record_timeout": {"status": True, "variable":controller.setInputSpeakerRecordTimeout}, "/set/speaker_record_timeout": {"status": True, "variable":controller.setSpeakerRecordTimeout},
"/get/input_speaker_phrase_timeout": {"status": True, "variable":controller.getInputSpeakerPhraseTimeout}, "/get/speaker_phrase_timeout": {"status": True, "variable":controller.getSpeakerPhraseTimeout},
"/set/input_speaker_phrase_timeout": {"status": True, "variable":controller.setInputSpeakerPhraseTimeout}, "/set/speaker_phrase_timeout": {"status": True, "variable":controller.setSpeakerPhraseTimeout},
"/get/input_speaker_max_phrases": {"status": True, "variable":controller.getInputSpeakerMaxPhrases}, "/get/speaker_max_phrases": {"status": True, "variable":controller.getSpeakerMaxPhrases},
"/set/input_speaker_max_phrases": {"status": True, "variable":controller.setInputSpeakerMaxPhrases}, "/set/speaker_max_phrases": {"status": True, "variable":controller.setSpeakerMaxPhrases},
"/get/input_speaker_avg_logprob": {"status": True, "variable":controller.getInputSpeakerAvgLogprob}, "/get/speaker_avg_logprob": {"status": True, "variable":controller.getSpeakerAvgLogprob},
"/set/input_speaker_avg_logprob": {"status": True, "variable":controller.setInputSpeakerAvgLogprob}, "/set/speaker_avg_logprob": {"status": True, "variable":controller.setSpeakerAvgLogprob},
"/get/input_speaker_no_speech_prob": {"status": True, "variable":controller.getInputSpeakerNoSpeechProb}, "/get/speaker_no_speech_prob": {"status": True, "variable":controller.getSpeakerNoSpeechProb},
"/set/input_speaker_no_speech_prob": {"status": True, "variable":controller.setInputSpeakerNoSpeechProb}, "/set/speaker_no_speech_prob": {"status": True, "variable":controller.setSpeakerNoSpeechProb},
"/get/osc_ip_address": {"status": True, "variable":controller.getOscIpAddress}, "/get/osc_ip_address": {"status": True, "variable":controller.getOscIpAddress},
"/set/osc_ip_address": {"status": True, "variable":controller.setOscIpAddress}, "/set/osc_ip_address": {"status": True, "variable":controller.setOscIpAddress},
@@ -179,11 +180,11 @@ mapping = {
"/get/whisper_weight_type": {"status": True, "variable":controller.getWhisperWeightType}, "/get/whisper_weight_type": {"status": True, "variable":controller.getWhisperWeightType},
"/set/whisper_weight_type": {"status": True, "variable":controller.setWhisperWeightType}, "/set/whisper_weight_type": {"status": True, "variable":controller.setWhisperWeightType},
"/get/enable_auto_clear_message_box": {"status": True, "variable":controller.getEnableAutoClearMessageBox}, "/get/auto_clear_message_box": {"status": True, "variable":controller.getAutoClearMessageBox},
"/set/enable_auto_clear_message_box": {"status": True, "variable":controller.setEnableAutoClearMessageBox}, "/set/enable_auto_clear_message_box": {"status": True, "variable":controller.setEnableAutoClearMessageBox},
"/set/disable_auto_clear_message_box": {"status": True, "variable":controller.setDisableAutoClearMessageBox}, "/set/disable_auto_clear_message_box": {"status": True, "variable":controller.setDisableAutoClearMessageBox},
"/get/enable_send_only_translated_messages": {"status": True, "variable":controller.getEnableSendOnlyTranslatedMessages}, "/get/send_only_translated_messages": {"status": True, "variable":controller.getSendOnlyTranslatedMessages},
"/set/enable_send_only_translated_messages": {"status": True, "variable":controller.setEnableSendOnlyTranslatedMessages}, "/set/enable_send_only_translated_messages": {"status": True, "variable":controller.setEnableSendOnlyTranslatedMessages},
"/set/disable_send_only_translated_messages": {"status": True, "variable":controller.setDisableSendOnlyTranslatedMessages}, "/set/disable_send_only_translated_messages": {"status": True, "variable":controller.setDisableSendOnlyTranslatedMessages},
@@ -196,11 +197,11 @@ mapping = {
"/get/overlay_small_log_settings": {"status": True, "variable":controller.getOverlaySmallLogSettings}, "/get/overlay_small_log_settings": {"status": True, "variable":controller.getOverlaySmallLogSettings},
"/set/overlay_small_log_settings": {"status": True, "variable":controller.setOverlaySmallLogSettings}, "/set/overlay_small_log_settings": {"status": True, "variable":controller.setOverlaySmallLogSettings},
"/get/enable_overlay_small_log": {"status": True, "variable":controller.getEnableOverlaySmallLog}, "/get/overlay_small_log": {"status": True, "variable":controller.getOverlaySmallLog},
"/set/enable_overlay_small_log": {"status": True, "variable":controller.setEnableOverlaySmallLog}, "/set/enable_overlay_small_log": {"status": True, "variable":controller.setEnableOverlaySmallLog},
"/set/disable_overlay_small_log": {"status": True, "variable":controller.setDisableOverlaySmallLog}, "/set/disable_overlay_small_log": {"status": True, "variable":controller.setDisableOverlaySmallLog},
"/get/enable_send_message_to_vrc": {"status": True, "variable":controller.getEnableSendMessageToVrc}, "/get/send_message_to_vrc": {"status": True, "variable":controller.getSendMessageToVrc},
"/set/enable_send_message_to_vrc": {"status": True, "variable":controller.setEnableSendMessageToVrc}, "/set/enable_send_message_to_vrc": {"status": True, "variable":controller.setEnableSendMessageToVrc},
"/set/disable_send_message_to_vrc": {"status": True, "variable":controller.setDisableSendMessageToVrc}, "/set/disable_send_message_to_vrc": {"status": True, "variable":controller.setDisableSendMessageToVrc},
@@ -216,19 +217,18 @@ mapping = {
"/get/received_message_format_with_t": {"status": True, "variable":controller.getReceivedMessageFormatWithT}, "/get/received_message_format_with_t": {"status": True, "variable":controller.getReceivedMessageFormatWithT},
"/set/received_message_format_with_t": {"status": True, "variable":controller.setReceivedMessageFormatWithT}, "/set/received_message_format_with_t": {"status": True, "variable":controller.setReceivedMessageFormatWithT},
"/get/enable_speaker2chatbox_pass": {"status": True, "variable":controller.getEnableSpeaker2ChatboxPass}, "/get/speaker2chatbox_pass": {"status": True, "variable":controller.getSpeaker2ChatboxPass},
"/set/enable_speaker2chatbox_pass": {"status": True, "variable":controller.setEnableSpeaker2ChatboxPass}, "/set/speaker2chatbox_pass": {"status": True, "variable":controller.setSpeaker2ChatboxPass},
"/set/disable_speaker2chatbox_pass": {"status": True, "variable":controller.setDisableSpeaker2ChatboxPass},
"/get/enable_send_received_message_to_vrc": {"status": True, "variable":controller.getEnableSendReceivedMessageToVrc}, "/get/send_received_message_to_vrc": {"status": True, "variable":controller.getSendReceivedMessageToVrc},
"/set/enable_send_received_message_to_vrc": {"status": True, "variable":controller.setEnableSendReceivedMessageToVrc}, "/set/enable_send_received_message_to_vrc": {"status": True, "variable":controller.setEnableSendReceivedMessageToVrc},
"/set/disable_send_received_message_to_vrc": {"status": True, "variable":controller.setDisableSendReceivedMessageToVrc}, "/set/disable_send_received_message_to_vrc": {"status": True, "variable":controller.setDisableSendReceivedMessageToVrc},
"/get/enable_logger": {"status": True, "variable":controller.getEnableLogger}, "/get/logger": {"status": True, "variable":controller.getLogger},
"/set/enable_logger": {"status": True, "variable":controller.setEnableLogger}, "/set/enable_logger": {"status": True, "variable":controller.setEnableLogger},
"/set/disable_logger": {"status": True, "variable":controller.setDisableLogger}, "/set/disable_logger": {"status": True, "variable":controller.setDisableLogger},
"/get/enable_vrc_mic_mute_sync": {"status": True, "variable":controller.getEnableVrcMicMuteSync}, "/get/vrc_mic_mute_sync": {"status": True, "variable":controller.getVrcMicMuteSync},
"/set/enable_vrc_mic_mute_sync": {"status": True, "variable":controller.setEnableVrcMicMuteSync}, "/set/enable_vrc_mic_mute_sync": {"status": True, "variable":controller.setEnableVrcMicMuteSync},
"/set/disable_vrc_mic_mute_sync": {"status": True, "variable":controller.setDisableVrcMicMuteSync}, "/set/disable_vrc_mic_mute_sync": {"status": True, "variable":controller.setDisableVrcMicMuteSync},
@@ -250,9 +250,9 @@ mapping = {
"/set/enable_transcription_receive": {"status": False, "variable":controller.setEnableTranscriptionReceive}, "/set/enable_transcription_receive": {"status": False, "variable":controller.setEnableTranscriptionReceive},
"/set/disable_transcription_receive": {"status": False, "variable":controller.setDisableTranscriptionReceive}, "/set/disable_transcription_receive": {"status": False, "variable":controller.setDisableTranscriptionReceive},
"/run/send_messagebox": {"status": False, "variable":controller.sendMessageBox}, "/run/send_message_box": {"status": False, "variable":controller.sendMessageBox},
"/run/typing_messagebox": {"status": False, "variable":controller.typingMessageBox}, "/run/typing_message_box": {"status": False, "variable":controller.typingMessageBox},
"/run/stop_typing_messagebox": {"status": False, "variable":controller.stopTypingMessageBox}, "/run/stop_typing_message_box": {"status": False, "variable":controller.stopTypingMessageBox},
"/run/swap_your_language_and_target_language": {"status": True, "variable":controller.swapYourLanguageAndTargetLanguage}, "/run/swap_your_language_and_target_language": {"status": True, "variable":controller.swapYourLanguageAndTargetLanguage},
"/run/download_ctranslate2_weight": {"status": True, "variable":controller.downloadCtranslate2Weight}, "/run/download_ctranslate2_weight": {"status": True, "variable":controller.downloadCtranslate2Weight},
@@ -290,7 +290,7 @@ action_mapping = {
"speaker":"/action/check_speaker_threshold_energy", "speaker":"/action/check_speaker_threshold_energy",
"error_device":"/action/error_device", "error_device":"/action/error_device",
}, },
"/run/send_messagebox": { "/run/send_message_box": {
"error_translation_engine":"/action/error_translation_engine" "error_translation_engine":"/action/error_translation_engine"
}, },
"/run/download_ctranslate2_weight": { "/run/download_ctranslate2_weight": {
@@ -299,11 +299,11 @@ action_mapping = {
"/run/download_whisper_weight": { "/run/download_whisper_weight": {
"download":"/action/download_whisper_weight" "download":"/action/download_whisper_weight"
}, },
"/set/enable_mic_auto_selection": { "/set/enable_auto_mic_select": {
"mic":"/set/choice_mic_host", "mic":"/set/selected_mic_host",
}, },
"/set/enable_speaker_auto_selection": { "/set/enable_auto_speaker_select": {
"speaker":"/set/choice_speaker_device", "speaker":"/set/selected_speaker_device",
} }
} }
@@ -399,8 +399,8 @@ if __name__ == "__main__":
controller.init({ controller.init({
"download_ctranslate2": Action(action_mapping["/run/download_ctranslate2_weight"]).transmit, "download_ctranslate2": Action(action_mapping["/run/download_ctranslate2_weight"]).transmit,
"download_whisper": Action(action_mapping["/run/download_whisper_weight"]).transmit, "download_whisper": Action(action_mapping["/run/download_whisper_weight"]).transmit,
"update_selected_mic_device": Action(action_mapping["/set/enable_mic_auto_selection"]).transmit, "update_selected_mic_device": Action(action_mapping["/set/enable_auto_mic_select"]).transmit,
"update_selected_speaker_device": Action(action_mapping["/set/enable_speaker_auto_selection"]).transmit, "update_selected_speaker_device": Action(action_mapping["/set/enable_auto_speaker_select"]).transmit,
}) })
# mappingのすべてのstatusをTrueにする # mappingのすべてのstatusをTrueにする
@@ -425,7 +425,7 @@ if __name__ == "__main__":
printLog("endpoint", endpoint) printLog("endpoint", endpoint)
match endpoint: match endpoint:
case "/run/send_messagebox": case "/run/send_message_box":
# handleRequest("/set/enable_translation") # handleRequest("/set/enable_translation")
# handleRequest("/set/enable_convert_message_to_romaji") # handleRequest("/set/enable_convert_message_to_romaji")
data = {"id":"123456", "message":"テスト"} data = {"id":"123456", "message":"テスト"}
@@ -519,31 +519,31 @@ if __name__ == "__main__":
data = "Small" data = "Small"
case "/set/deepl_auth_key": case "/set/deepl_auth_key":
data = "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee:fx" data = "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee:fx"
case "/set/choice_mic_host": case "/set/selected_mic_host":
data = "MME" data = "MME"
case "/set/choice_mic_device": case "/set/selected_mic_device":
data = "マイク (Realtek High Definition Audio)" data = "マイク (Realtek High Definition Audio)"
case "/set/input_mic_energy_threshold": case "/set/mic_energy_threshold":
data = 0.5 data = 0.5
case "/set/input_mic_record_timeout": case "/set/mic_record_timeout":
data = 1 data = 1
case "/set/input_mic_phrase_timeout": case "/set/mic_phrase_timeout":
data = 5 data = 5
case "/set/input_set_mic_max_phrases": case "/set/input_set_mic_max_phrases":
data = 5 data = 5
case "/set/input_mic_word_filter": case "/set/mic_word_filter":
data = "test0, test1, test2" data = "test0, test1, test2"
case "/del/input_mic_word_filter": case "/del/mic_word_filter":
data = "test1" data = "test1"
case "/set/choice_speaker_device": case "/set/selected_speaker_device":
data = "スピーカー (Realtek High Definition Audio)" data = "スピーカー (Realtek High Definition Audio)"
case "/set/input_speaker_energy_threshold": case "/set/speaker_energy_threshold":
data = 0.5 data = 0.5
case "/set/input_speaker_record_timeout": case "/set/speaker_record_timeout":
data = 5 data = 5
case "/set/input_speaker_phrase_timeout": case "/set/speaker_phrase_timeout":
data = 5 data = 5
case "/set/input_speaker_max_phrases": case "/set/speaker_max_phrases":
data = 5 data = 5
case "/set/whisper_weight_type": case "/set/whisper_weight_type":
data = "base" data = "base"
@@ -577,15 +577,15 @@ if __name__ == "__main__":
data = "127.0.0.1" data = "127.0.0.1"
case "/set/osc_port": case "/set/osc_port":
data = 8000 data = 8000
case "/set/input_speaker_no_speech_prob": case "/set/speaker_no_speech_prob":
data = 0.5 data = 0.5
case "/set/input_speaker_avg_logprob": case "/set/speaker_avg_logprob":
data = 0.5 data = 0.5
case "/set/input_mic_no_speech_prob": case "/set/mic_no_speech_prob":
data = 0.5 data = 0.5
case "/set/input_mic_avg_logprob": case "/set/mic_avg_logprob":
data = 0.5 data = 0.5
case "/set/input_mic_max_phrases": case "/set/mic_max_phrases":
data = 5 data = 5
case _: case _:
data = None data = None

6
src-ui/logics/configs/useEnableAutoClearMessageBox.js
View File

@@ -7,15 +7,15 @@ export const useEnableAutoClearMessageBox = () => {
const getEnableAutoClearMessageBox = () => { const getEnableAutoClearMessageBox = () => {
updateEnableAutoClearMessageBox(() => new Promise(() => {})); updateEnableAutoClearMessageBox(() => new Promise(() => {}));
asyncStdoutToPython("/config/enable_auto_clear_message_box"); asyncStdoutToPython("/get/auto_clear_message_box");
}; };
const toggleEnableAutoClearMessageBox = () => { const toggleEnableAutoClearMessageBox = () => {
updateEnableAutoClearMessageBox(() => new Promise(() => {})); updateEnableAutoClearMessageBox(() => new Promise(() => {}));
if (currentEnableAutoClearMessageBox.data) { if (currentEnableAutoClearMessageBox.data) {
asyncStdoutToPython("/controller/callback_disable_auto_clear_chatbox"); asyncStdoutToPython("/set/disable_auto_clear_message_box");
} else { } else {
asyncStdoutToPython("/controller/callback_enable_auto_clear_chatbox"); asyncStdoutToPython("/set/enable_auto_clear_message_box");
} }
}; };

6
src-ui/logics/configs/useEnableAutoMicSelect.js
View File

@@ -7,15 +7,15 @@ export const useEnableAutoMicSelect = () => {
const getEnableAutoMicSelect = () => { const getEnableAutoMicSelect = () => {
updateEnableAutoMicSelect(() => new Promise(() => {})); updateEnableAutoMicSelect(() => new Promise(() => {}));
asyncStdoutToPython("/config/enable_mic_automatic_selection"); asyncStdoutToPython("/get/auto_mic_select");
}; };
const toggleEnableAutoMicSelect = () => { const toggleEnableAutoMicSelect = () => {
updateEnableAutoMicSelect(() => new Promise(() => {})); updateEnableAutoMicSelect(() => new Promise(() => {}));
if (currentEnableAutoMicSelect.data) { if (currentEnableAutoMicSelect.data) {
asyncStdoutToPython("/controller/callback_disable_mic_automatic_selection"); asyncStdoutToPython("/set/disable_auto_mic_select");
} else { } else {
asyncStdoutToPython("/controller/callback_enable_mic_automatic_selection"); asyncStdoutToPython("/set/enable_auto_mic_select");
} }
}; };

6
src-ui/logics/configs/useEnableAutoSpeakerSelect.js
View File

@@ -7,15 +7,15 @@ export const useEnableAutoSpeakerSelect = () => {
const getEnableAutoSpeakerSelect = () => { const getEnableAutoSpeakerSelect = () => {
updateEnableAutoSpeakerSelect(() => new Promise(() => {})); updateEnableAutoSpeakerSelect(() => new Promise(() => {}));
asyncStdoutToPython("/config/enable_speaker_automatic_selection"); asyncStdoutToPython("/get/auto_speaker_select");
}; };
const toggleEnableAutoSpeakerSelect = () => { const toggleEnableAutoSpeakerSelect = () => {
updateEnableAutoSpeakerSelect(() => new Promise(() => {})); updateEnableAutoSpeakerSelect(() => new Promise(() => {}));
if (currentEnableAutoSpeakerSelect.data) { if (currentEnableAutoSpeakerSelect.data) {
asyncStdoutToPython("/controller/callback_disable_speaker_automatic_selection"); asyncStdoutToPython("/set/disable_auto_speaker_select");
} else { } else {
asyncStdoutToPython("/controller/callback_enable_speaker_automatic_selection"); asyncStdoutToPython("/set/enable_auto_speaker_select");
} }
}; };

2
src-ui/logics/configs/useMicDeviceList.js
View File

@@ -7,7 +7,7 @@ export const useMicDeviceList = () => {
const getMicDeviceList = () => { const getMicDeviceList = () => {
updateMicDeviceList(() => new Promise(() => {})); updateMicDeviceList(() => new Promise(() => {}));
asyncStdoutToPython("/controller/list_mic_device"); asyncStdoutToPython("/get/list_mic_device");
}; };
return { return {

2
src-ui/logics/configs/useMicHostList.js
View File

@@ -7,7 +7,7 @@ export const useMicHostList = () => {
const getMicHostList = () => { const getMicHostList = () => {
updateMicHostList(() => new Promise(() => {})); updateMicHostList(() => new Promise(() => {}));
asyncStdoutToPython("/controller/list_mic_host"); asyncStdoutToPython("/get/list_mic_host");
}; };
return { return {

10
src-ui/logics/configs/useMicThreshold.js
View File

@@ -7,24 +7,24 @@ export const useMicThreshold = () => {
const { updateEnableAutomaticMicThreshold, currentEnableAutomaticMicThreshold } = useStore_EnableAutomaticMicThreshold(); const { updateEnableAutomaticMicThreshold, currentEnableAutomaticMicThreshold } = useStore_EnableAutomaticMicThreshold();
const getMicThreshold = () => { const getMicThreshold = () => {
asyncStdoutToPython("/config/input_mic_energy_threshold"); asyncStdoutToPython("/get/mic_energy_threshold");
}; };
const setMicThreshold = (mic_threshold) => { const setMicThreshold = (mic_threshold) => {
asyncStdoutToPython("/controller/callback_set_mic_energy_threshold", mic_threshold); asyncStdoutToPython("/set/mic_energy_threshold", mic_threshold);
}; };
const getEnableAutomaticMicThreshold = () => { const getEnableAutomaticMicThreshold = () => {
updateEnableAutomaticMicThreshold(() => new Promise(() => {})); updateEnableAutomaticMicThreshold(() => new Promise(() => {}));
asyncStdoutToPython("/config/input_mic_dynamic_energy_threshold"); asyncStdoutToPython("/get/mic_dynamic_energy_threshold");
}; };
const toggleEnableAutomaticMicThreshold = () => { const toggleEnableAutomaticMicThreshold = () => {
updateEnableAutomaticMicThreshold(() => new Promise(() => {})); updateEnableAutomaticMicThreshold(() => new Promise(() => {}));
if (currentEnableAutomaticMicThreshold.data) { if (currentEnableAutomaticMicThreshold.data) {
asyncStdoutToPython("/controller/callback_disable_mic_dynamic_energy_threshold"); asyncStdoutToPython("/set/disable_mic_dynamic_energy_threshold");
} else { } else {
asyncStdoutToPython("/controller/callback_enable_mic_dynamic_energy_threshold"); asyncStdoutToPython("/set/enable_mic_dynamic_energy_threshold");
} }
}; };

4
src-ui/logics/configs/useSelectedMicDevice.js
View File

@@ -7,12 +7,12 @@ export const useSelectedMicDevice = () => {
const getSelectedMicDevice = () => { const getSelectedMicDevice = () => {
updateSelectedMicDevice(() => new Promise(() => {})); updateSelectedMicDevice(() => new Promise(() => {}));
asyncStdoutToPython("/config/choice_mic_device"); asyncStdoutToPython("/get/selected_mic_device");
}; };
const setSelectedMicDevice = (selected_mic_device) => { const setSelectedMicDevice = (selected_mic_device) => {
updateSelectedMicDevice(() => new Promise(() => {})); updateSelectedMicDevice(() => new Promise(() => {}));
asyncStdoutToPython("/controller/callback_set_mic_device", selected_mic_device); asyncStdoutToPython("/set/selected_mic_device", selected_mic_device);
}; };
return { return {

4
src-ui/logics/configs/useSelectedMicHost.js
View File

@@ -7,12 +7,12 @@ export const useSelectedMicHost = () => {
const getSelectedMicHost = () => { const getSelectedMicHost = () => {
updateSelectedMicHost(() => new Promise(() => {})); updateSelectedMicHost(() => new Promise(() => {}));
asyncStdoutToPython("/config/choice_mic_host"); asyncStdoutToPython("/get/selected_mic_host");
}; };
const setSelectedMicHost = (selected_mic_host) => { const setSelectedMicHost = (selected_mic_host) => {
updateSelectedMicHost(() => new Promise(() => {})); updateSelectedMicHost(() => new Promise(() => {}));
asyncStdoutToPython("/controller/callback_set_mic_host", selected_mic_host); asyncStdoutToPython("/set/selected_mic_host", selected_mic_host);
}; };
return { return {

4
src-ui/logics/configs/useSelectedSpeakerDevice.js
View File

@@ -7,12 +7,12 @@ export const useSelectedSpeakerDevice = () => {
const getSelectedSpeakerDevice = () => { const getSelectedSpeakerDevice = () => {
updateSelectedSpeakerDevice(() => new Promise(() => {})); updateSelectedSpeakerDevice(() => new Promise(() => {}));
asyncStdoutToPython("/config/choice_speaker_device"); asyncStdoutToPython("/get/selected_speaker_device");
}; };
const setSelectedSpeakerDevice = (selected_speaker_device) => { const setSelectedSpeakerDevice = (selected_speaker_device) => {
updateSelectedSpeakerDevice(() => new Promise(() => {})); updateSelectedSpeakerDevice(() => new Promise(() => {}));
asyncStdoutToPython("/controller/callback_set_speaker_device", selected_speaker_device); asyncStdoutToPython("/set/selected_speaker_device", selected_speaker_device);
}; };
return { return {

4
src-ui/logics/configs/useSendMessageButtonType.js
View File

@@ -7,12 +7,12 @@ export const useSendMessageButtonType = () => {
const getSendMessageButtonType = () => { const getSendMessageButtonType = () => {
updateSendMessageButtonType(() => new Promise(() => {})); updateSendMessageButtonType(() => new Promise(() => {}));
asyncStdoutToPython("/config/send_message_button_type"); asyncStdoutToPython("/get/send_message_button_type");
}; };
const setSendMessageButtonType = (selected_type) => { const setSendMessageButtonType = (selected_type) => {
updateSendMessageButtonType(() => new Promise(() => {})); updateSendMessageButtonType(() => new Promise(() => {}));
asyncStdoutToPython("/controller/callback_set_send_message_button_type", selected_type); asyncStdoutToPython("/set/send_message_button_type", selected_type);
}; };
return { return {

2
src-ui/logics/configs/useSoftwareVersion.js
View File

@@ -7,7 +7,7 @@ export const useSoftwareVersion = () => {
const getSoftwareVersion = () => { const getSoftwareVersion = () => {
updateSoftwareVersion(() => new Promise(() => {})); updateSoftwareVersion(() => new Promise(() => {}));
asyncStdoutToPython("/config/version"); asyncStdoutToPython("/get/version");
}; };
return { return {

2
src-ui/logics/configs/useSpeakerDeviceList.js
View File

@@ -7,7 +7,7 @@ export const useSpeakerDeviceList = () => {
const getSpeakerDeviceList = () => { const getSpeakerDeviceList = () => {
updateSpeakerDeviceList(() => new Promise(() => {})); updateSpeakerDeviceList(() => new Promise(() => {}));
asyncStdoutToPython("/controller/list_speaker_device"); asyncStdoutToPython("/get/list_speaker_device");
}; };
return { return {

10
src-ui/logics/configs/useSpeakerThreshold.js
View File

@@ -7,24 +7,24 @@ export const useSpeakerThreshold = () => {
const { updateEnableAutomaticSpeakerThreshold, currentEnableAutomaticSpeakerThreshold } = useStore_EnableAutomaticSpeakerThreshold(); const { updateEnableAutomaticSpeakerThreshold, currentEnableAutomaticSpeakerThreshold } = useStore_EnableAutomaticSpeakerThreshold();
const getSpeakerThreshold = () => { const getSpeakerThreshold = () => {
asyncStdoutToPython("/config/input_speaker_energy_threshold"); asyncStdoutToPython("/get/speaker_energy_threshold");
}; };
const setSpeakerThreshold = (speaker_threshold) => { const setSpeakerThreshold = (speaker_threshold) => {
asyncStdoutToPython("/controller/callback_set_speaker_energy_threshold", speaker_threshold); asyncStdoutToPython("/set/speaker_energy_threshold", speaker_threshold);
}; };
const getEnableAutomaticSpeakerThreshold = () => { const getEnableAutomaticSpeakerThreshold = () => {
updateEnableAutomaticSpeakerThreshold(() => new Promise(() => {})); updateEnableAutomaticSpeakerThreshold(() => new Promise(() => {}));
asyncStdoutToPython("/config/input_speaker_dynamic_energy_threshold"); asyncStdoutToPython("/get/speaker_dynamic_energy_threshold");
}; };
const toggleEnableAutomaticSpeakerThreshold = () => { const toggleEnableAutomaticSpeakerThreshold = () => {
updateEnableAutomaticSpeakerThreshold(() => new Promise(() => {})); updateEnableAutomaticSpeakerThreshold(() => new Promise(() => {}));
if (currentEnableAutomaticSpeakerThreshold.data) { if (currentEnableAutomaticSpeakerThreshold.data) {
asyncStdoutToPython("/controller/callback_disable_speaker_dynamic_energy_threshold"); asyncStdoutToPython("/set/disable_speaker_dynamic_energy_threshold");
} else { } else {
asyncStdoutToPython("/controller/callback_enable_speaker_dynamic_energy_threshold"); asyncStdoutToPython("/set/enable_speaker_dynamic_energy_threshold");
} }
}; };

4
src-ui/logics/configs/useUiLanguage.js
View File

@@ -7,12 +7,12 @@ export const useUiLanguage = () => {
const getUiLanguage = () => { const getUiLanguage = () => {
updateUiLanguage(() => new Promise(() => {})); updateUiLanguage(() => new Promise(() => {}));
asyncStdoutToPython("/config/ui_language"); asyncStdoutToPython("/get/ui_language");
}; };
const setUiLanguage = (selected_ui_language) => { const setUiLanguage = (selected_ui_language) => {
updateUiLanguage(() => new Promise(() => {})); updateUiLanguage(() => new Promise(() => {}));
asyncStdoutToPython("/controller/callback_set_ui_language", selected_ui_language); asyncStdoutToPython("/set/ui_language", selected_ui_language);
}; };
return { return {

14
src-ui/logics/useLanguageSettings.js
View File

@@ -10,24 +10,24 @@ export const useLanguageSettings = () => {
const getEnableMultiTranslation = () => { const getEnableMultiTranslation = () => {
updateEnableMultiTranslation(() => new Promise(() => {})); updateEnableMultiTranslation(() => new Promise(() => {}));
asyncStdoutToPython("/config/enable_multi_translation"); asyncStdoutToPython("/get/multi_language_translation");
}; };
const getSelectedPresetTabNumber = () => { const getSelectedPresetTabNumber = () => {
updateSelectedPresetTabNumber(() => new Promise(() => {})); updateSelectedPresetTabNumber(() => new Promise(() => {}));
asyncStdoutToPython("/config/selected_tab_no"); asyncStdoutToPython("/get/selected_tab_no");
}; };
const setSelectedPresetTabNumber = (preset_number) => { const setSelectedPresetTabNumber = (preset_number) => {
updateSelectedPresetTabNumber(() => new Promise(() => {})); updateSelectedPresetTabNumber(() => new Promise(() => {}));
asyncStdoutToPython("/controller/callback_selected_language_preset_tab", preset_number); asyncStdoutToPython("/set/selected_tab_no", preset_number);
}; };
const getSelectedYourLanguages = () => { const getSelectedYourLanguages = () => {
updateSelectedYourLanguages(() => new Promise(() => {})); updateSelectedYourLanguages(() => new Promise(() => {}));
asyncStdoutToPython("/config/selected_tab_your_languages"); asyncStdoutToPython("/get/selected_your_languages");
}; };
const setSelectedYourLanguages = (selected_language_data) => { const setSelectedYourLanguages = (selected_language_data) => {
@@ -41,13 +41,13 @@ export const useLanguageSettings = () => {
} }
} }
}; };
asyncStdoutToPython("/controller/set_your_language_and_country", send_obj); asyncStdoutToPython("/set/selected_your_languages", send_obj);
}; };
const getSelectedTargetLanguages = () => { const getSelectedTargetLanguages = () => {
updateSelectedTargetLanguages(() => new Promise(() => {})); updateSelectedTargetLanguages(() => new Promise(() => {}));
asyncStdoutToPython("/config/selected_tab_target_languages"); asyncStdoutToPython("/get/selected_target_languages");
}; };
const setSelectedTargetLanguages = (selected_language_data) => { const setSelectedTargetLanguages = (selected_language_data) => {
@@ -57,7 +57,7 @@ export const useLanguageSettings = () => {
send_obj[currentSelectedPresetTabNumber.data].primary.language = selected_language_data.language, send_obj[currentSelectedPresetTabNumber.data].primary.language = selected_language_data.language,
send_obj[currentSelectedPresetTabNumber.data].primary.country = selected_language_data.country, send_obj[currentSelectedPresetTabNumber.data].primary.country = selected_language_data.country,
asyncStdoutToPython("/controller/set_target_language_and_country", send_obj); asyncStdoutToPython("/set/selected_target_languages", send_obj);
}; };
return { return {

12
src-ui/logics/useMainFunction.js
View File

@@ -36,27 +36,27 @@ export const useMainFunction = () => {
const toggleTranslation = () => { const toggleTranslation = () => {
asyncUpdateTranslationStatus(asyncPending); asyncUpdateTranslationStatus(asyncPending);
if (currentTranslationStatus.data) { if (currentTranslationStatus.data) {
asyncStdoutToPython("/controller/callback_disable_translation"); asyncStdoutToPython("/set/disable_translation");
} else { } else {
asyncStdoutToPython("/controller/callback_enable_translation"); asyncStdoutToPython("/set/enable_translation");
} }
}; };
const toggleTranscriptionSend = () => { const toggleTranscriptionSend = () => {
asyncUpdateTranscriptionSendStatus(asyncPending); asyncUpdateTranscriptionSendStatus(asyncPending);
if (currentTranscriptionSendStatus.data) { if (currentTranscriptionSendStatus.data) {
asyncStdoutToPython("/controller/callback_disable_transcription_send"); asyncStdoutToPython("/set/disable_transcription_send");
} else { } else {
asyncStdoutToPython("/controller/callback_enable_transcription_send"); asyncStdoutToPython("/set/enable_transcription_send");
} }
}; };
const toggleTranscriptionReceive = () => { const toggleTranscriptionReceive = () => {
asyncUpdateTranscriptionReceiveStatus(asyncPending); asyncUpdateTranscriptionReceiveStatus(asyncPending);
if (currentTranscriptionReceiveStatus.data) { if (currentTranscriptionReceiveStatus.data) {
asyncStdoutToPython("/controller/callback_disable_transcription_receive"); asyncStdoutToPython("/set/disable_transcription_receive");
} else { } else {
asyncStdoutToPython("/controller/callback_enable_transcription_receive"); asyncStdoutToPython("/set/enable_transcription_receive");
} }
}; };

2
src-ui/logics/useMessage.js
View File

@@ -14,7 +14,7 @@ export const useMessage = () => {
id: uuid, id: uuid,
message: message, message: message,
}; };
asyncStdoutToPython("/controller/callback_messagebox_send", send_message_object); asyncStdoutToPython("/run/send_message_box", send_message_object);
addMessageLogs({ addMessageLogs({
id: uuid, id: uuid,

102
src-ui/logics/useReceiveRoutes.js
View File

@@ -72,77 +72,77 @@ export const useReceiveRoutes = () => {
} = useVolume(); } = useVolume();
const routes = { const routes = {
"/controller/callback_enable_translation": updateTranslationStatus, "/set/enable_translation": updateTranslationStatus,
"/controller/callback_disable_translation": updateTranslationStatus, "/set/disable_translation": updateTranslationStatus,
"/controller/callback_enable_transcription_send": updateTranscriptionSendStatus, "/set/enable_transcription_send": updateTranscriptionSendStatus,
"/controller/callback_disable_transcription_send": updateTranscriptionSendStatus, "/set/disable_transcription_send": updateTranscriptionSendStatus,
"/controller/callback_enable_transcription_receive": updateTranscriptionReceiveStatus, "/set/enable_transcription_receive": updateTranscriptionReceiveStatus,
"/controller/callback_disable_transcription_receive": updateTranscriptionReceiveStatus, "/set/disable_transcription_receive": updateTranscriptionReceiveStatus,
"/config/selected_tab_no": updateSelectedPresetTabNumber, "/get/selected_tab_no": updateSelectedPresetTabNumber,
"/controller/callback_selected_language_preset_tab": updateSelectedPresetTabNumber, "/set/selected_tab_no": updateSelectedPresetTabNumber,
"/config/enable_multi_translation": updateEnableMultiTranslation, "/get/multi_language_translation": updateEnableMultiTranslation,
"/config/selected_tab_your_languages": updateSelectedYourLanguages, "/get/selected_your_languages": updateSelectedYourLanguages,
"/controller/set_your_language_and_country": updateSelectedYourLanguages, "/set/selected_your_languages": updateSelectedYourLanguages,
"/config/selected_tab_target_languages": updateSelectedTargetLanguages, "/get/selected_target_languages": updateSelectedTargetLanguages,
"/controller/set_your_language_and_country": updateSelectedTargetLanguages, "/set/selected_target_languages": updateSelectedTargetLanguages,
"/controller/list_language_and_country": updateSelectableLanguageList, "/get/list_languages": updateSelectableLanguageList,
"/config/version": updateSoftwareVersion, "/get/version": updateSoftwareVersion,
"/config/enable_mic_automatic_selection": updateEnableAutoMicSelect, "/get/auto_mic_select": updateEnableAutoMicSelect,
"/controller/callback_enable_mic_automatic_selection": updateEnableAutoMicSelect, "/set/enable_auto_mic_select": updateEnableAutoMicSelect,
"/controller/callback_disable_mic_automatic_selection": updateEnableAutoMicSelect, "/set/disable_auto_mic_select": updateEnableAutoMicSelect,
"/config/enable_speaker_automatic_selection": updateEnableAutoSpeakerSelect, "/get/auto_speaker_select": updateEnableAutoSpeakerSelect,
"/controller/callback_enable_speaker_automatic_selection": updateEnableAutoSpeakerSelect, "/set/enable_auto_speaker_select": updateEnableAutoSpeakerSelect,
"/controller/callback_disable_speaker_automatic_selection": updateEnableAutoSpeakerSelect, "/set/disable_auto_speaker_select": updateEnableAutoSpeakerSelect,
"/controller/list_mic_host": (payload) => updateMicHostList(arrayToObject(payload)), "/get/list_mic_host": (payload) => updateMicHostList(arrayToObject(payload)),
"/config/choice_mic_host": updateSelectedMicHost, "/get/selected_mic_host": updateSelectedMicHost,
"/controller/callback_set_mic_host": (payload) => { "/set/selected_mic_host": (payload) => {
updateSelectedMicHost(payload.host); updateSelectedMicHost(payload.host);
updateSelectedMicDevice(payload.device); updateSelectedMicDevice(payload.device);
}, },
"/controller/list_mic_device": (payload) => updateMicDeviceList(arrayToObject(payload)), "/get/list_mic_device": (payload) => updateMicDeviceList(arrayToObject(payload)),
"/config/choice_mic_device": updateSelectedMicDevice, "/get/selected_mic_device": updateSelectedMicDevice,
"/controller/callback_set_mic_device": updateSelectedMicDevice, "/set/selected_mic_device": updateSelectedMicDevice,
"/controller/list_speaker_device": (payload) => updateSpeakerDeviceList(arrayToObject(payload)), "/get/list_speaker_device": (payload) => updateSpeakerDeviceList(arrayToObject(payload)),
"/config/choice_speaker_device": updateSelectedSpeakerDevice, "/get/selected_speaker_device": updateSelectedSpeakerDevice,
"/controller/callback_set_speaker_device": updateSelectedSpeakerDevice, "/set/selected_speaker_device": updateSelectedSpeakerDevice,
"/action/check_mic_threshold_energy": updateVolumeVariable_Mic, "/action/check_mic_threshold_energy": updateVolumeVariable_Mic,
"/action/check_speaker_threshold_energy": updateVolumeVariable_Speaker, "/action/check_speaker_threshold_energy": updateVolumeVariable_Speaker,
"/controller/callback_enable_check_mic_threshold": updateMicThresholdCheckStatus, "/set/enable_check_mic_threshold": updateMicThresholdCheckStatus,
"/controller/callback_disable_check_mic_threshold": updateMicThresholdCheckStatus, "/set/disable_check_mic_threshold": updateMicThresholdCheckStatus,
"/controller/callback_enable_check_speaker_threshold": updateSpeakerThresholdCheckStatus, "/set/enable_check_speaker_threshold": updateSpeakerThresholdCheckStatus,
"/controller/callback_disable_check_speaker_threshold": updateSpeakerThresholdCheckStatus, "/set/disable_check_speaker_threshold": updateSpeakerThresholdCheckStatus,
"/config/enable_auto_clear_message_box": updateEnableAutoClearMessageBox, "/get/auto_clear_message_box": updateEnableAutoClearMessageBox,
"/controller/callback_enable_auto_clear_chatbox": updateEnableAutoClearMessageBox, "/set/enable_auto_clear_message_box": updateEnableAutoClearMessageBox,
"/controller/callback_disable_auto_clear_chatbox": updateEnableAutoClearMessageBox, "/set/disable_auto_clear_message_box": updateEnableAutoClearMessageBox,
"/config/send_message_button_type": updateSendMessageButtonType, "/get/send_message_button_type": updateSendMessageButtonType,
"/controller/callback_set_send_message_button_type": updateSendMessageButtonType, "/set/send_message_button_type": updateSendMessageButtonType,
"/config/input_mic_energy_threshold": updateMicThreshold, "/get/mic_energy_threshold": updateMicThreshold,
"/controller/callback_set_mic_energy_threshold": updateMicThreshold, "/set/mic_energy_threshold": updateMicThreshold,
"/config/input_speaker_energy_threshold": updateSpeakerThreshold, "/get/speaker_energy_threshold": updateSpeakerThreshold,
"/controller/callback_set_speaker_energy_threshold": updateSpeakerThreshold, "/set/speaker_energy_threshold": updateSpeakerThreshold,
"/config/input_mic_dynamic_energy_threshold": updateEnableAutomaticMicThreshold, "/get/mic_dynamic_energy_threshold": updateEnableAutomaticMicThreshold,
"/controller/callback_enable_mic_dynamic_energy_threshold": updateEnableAutomaticMicThreshold, "/set/enable_mic_dynamic_energy_threshold": updateEnableAutomaticMicThreshold,
"/controller/callback_disable_mic_dynamic_energy_threshold": updateEnableAutomaticMicThreshold, "/set/disable_mic_dynamic_energy_threshold": updateEnableAutomaticMicThreshold,
"/config/input_speaker_dynamic_energy_threshold": updateEnableAutomaticSpeakerThreshold, "/get/speaker_dynamic_energy_threshold": updateEnableAutomaticSpeakerThreshold,
"/controller/callback_enable_speaker_dynamic_energy_threshold": updateEnableAutomaticSpeakerThreshold, "/set/enable_speaker_dynamic_energy_threshold": updateEnableAutomaticSpeakerThreshold,
"/config/ui_language": updateUiLanguage, "/get/ui_language": updateUiLanguage,
"/controller/callback_set_ui_language": updateUiLanguage, "/set/ui_language": updateUiLanguage,
"/controller/callback_messagebox_send": updateSentMessageLogById, "/run/send_message_box": updateSentMessageLogById,
"/action/transcription_send_mic_message": addSentMessageLog, "/action/transcription_send_mic_message": addSentMessageLog,
"/action/transcription_receive_speaker_message": addReceivedMessageLog "/action/transcription_receive_speaker_message": addReceivedMessageLog
}; };

2
src-ui/logics/useSelectableLanguageList.js
View File

@@ -6,7 +6,7 @@ export const useSelectableLanguageList = () => {
const { currentSelectableLanguageList, updateSelectableLanguageList } = useStore_SelectableLanguageList(); const { currentSelectableLanguageList, updateSelectableLanguageList } = useStore_SelectableLanguageList();
const getSelectableLanguageList = () => { const getSelectableLanguageList = () => {
asyncStdoutToPython("/controller/list_language_and_country"); asyncStdoutToPython("/get/list_languages");
}; };
return { return {

8
src-ui/logics/useVolume.js
View File

@@ -18,11 +18,11 @@ export const useVolume = () => {
return { return {
volumeCheckStart_Mic: () => { volumeCheckStart_Mic: () => {
updateMicThresholdCheckStatus(asyncPending); updateMicThresholdCheckStatus(asyncPending);
asyncStdoutToPython("/controller/callback_enable_check_mic_threshold"); asyncStdoutToPython("/set/enable_check_mic_threshold");
}, },
volumeCheckStop_Mic: () => { volumeCheckStop_Mic: () => {
updateMicThresholdCheckStatus(asyncPending); updateMicThresholdCheckStatus(asyncPending);
asyncStdoutToPython("/controller/callback_disable_check_mic_threshold"); asyncStdoutToPython("/set/disable_check_mic_threshold");
}, },
updateVolumeVariable_Mic: (payload) => { updateVolumeVariable_Mic: (payload) => {
updateMicVolume(payload); updateMicVolume(payload);
@@ -36,11 +36,11 @@ export const useVolume = () => {
volumeCheckStart_Speaker: () => { volumeCheckStart_Speaker: () => {
updateSpeakerVolume("0"); updateSpeakerVolume("0");
updateSpeakerThresholdCheckStatus(asyncPending); updateSpeakerThresholdCheckStatus(asyncPending);
asyncStdoutToPython("/controller/callback_enable_check_speaker_threshold"); asyncStdoutToPython("/set/enable_check_speaker_threshold");
}, },
volumeCheckStop_Speaker: () => { volumeCheckStop_Speaker: () => {
updateSpeakerThresholdCheckStatus(asyncPending); updateSpeakerThresholdCheckStatus(asyncPending);
asyncStdoutToPython("/controller/callback_disable_check_speaker_threshold"); asyncStdoutToPython("/set/disable_check_speaker_threshold");
}, },
updateVolumeVariable_Speaker: (payload) => { updateVolumeVariable_Speaker: (payload) => {
updateSpeakerVolume(payload); updateSpeakerVolume(payload);