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

Merge branch 'model_getset' into for_webui

Browse Source
This commit is contained in:
misyaguziya
2024-09-20 05:36:03 +09:00
parent 16f63c3e20 de44599827
commit 0bf479bdf1
25 changed files with 1893 additions and 1839 deletions
Download Patch File Download Diff File Expand all files Collapse all files

508
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):
@@ -240,43 +240,43 @@ 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('SELECTED_TAB_YOUR_LANGUAGES') @json_serializable('SELECTED_YOUR_LANGUAGES')
def SELECTED_TAB_YOUR_LANGUAGES(self): def SELECTED_YOUR_LANGUAGES(self):
return self._SELECTED_TAB_YOUR_LANGUAGES return self._SELECTED_YOUR_LANGUAGES
@SELECTED_TAB_YOUR_LANGUAGES.setter @SELECTED_YOUR_LANGUAGES.setter
def SELECTED_TAB_YOUR_LANGUAGES(self, value): def SELECTED_YOUR_LANGUAGES(self, value):
try: try:
if isinstance(value, dict): if isinstance(value, dict):
value_old = self.SELECTED_TAB_YOUR_LANGUAGES value_old = self.SELECTED_YOUR_LANGUAGES
for k0, v0 in value.items(): for k0, v0 in value.items():
for k1, v1 in v0.items(): for k1, v1 in v0.items():
language = v1["language"] language = v1["language"]
country = v1["country"] country = v1["country"]
if language not in list(transcription_lang.keys()) or country not in list(transcription_lang[language].keys()): if language not in list(transcription_lang.keys()) or country not in list(transcription_lang[language].keys()):
value[k0][k1] = value_old[k0][k1] value[k0][k1] = value_old[k0][k1]
self._SELECTED_TAB_YOUR_LANGUAGES = value self._SELECTED_YOUR_LANGUAGES = value
except Exception: except Exception:
pass pass
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('SELECTED_TAB_TARGET_LANGUAGES') @json_serializable('SELECTED_TARGET_LANGUAGES')
def SELECTED_TAB_TARGET_LANGUAGES(self): def SELECTED_TARGET_LANGUAGES(self):
return self._SELECTED_TAB_TARGET_LANGUAGES return self._SELECTED_TARGET_LANGUAGES
@SELECTED_TAB_TARGET_LANGUAGES.setter @SELECTED_TARGET_LANGUAGES.setter
def SELECTED_TAB_TARGET_LANGUAGES(self, value): def SELECTED_TARGET_LANGUAGES(self, value):
try: try:
if isinstance(value, dict): if isinstance(value, dict):
value_old = self.SELECTED_TAB_TARGET_LANGUAGES value_old = self.SELECTED_TARGET_LANGUAGES
for k0, v0 in value.items(): for k0, v0 in value.items():
for k1, v1 in v0.items(): for k1, v1 in v0.items():
language = v1["language"] language = v1["language"]
country = v1["country"] country = v1["country"]
if language not in list(transcription_lang.keys()) or country not in list(transcription_lang[language].keys()): if language not in list(transcription_lang.keys()) or country not in list(transcription_lang[language].keys()):
value[k0][k1] = value_old[k0][k1] value[k0][k1] = value_old[k0][k1]
self._SELECTED_TAB_TARGET_LANGUAGES = value self._SELECTED_TARGET_LANGUAGES = value
except Exception: except Exception:
pass pass
saveJson(self.PATH_CONFIG, inspect.currentframe().f_code.co_name, value) saveJson(self.PATH_CONFIG, inspect.currentframe().f_code.co_name, value)
@@ -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('IS_MAIN_WINDOW_SIDEBAR_COMPACT_MODE') @json_serializable('MAIN_WINDOW_SIDEBAR_COMPACT_MODE')
def IS_MAIN_WINDOW_SIDEBAR_COMPACT_MODE(self): def MAIN_WINDOW_SIDEBAR_COMPACT_MODE(self):
return self._IS_MAIN_WINDOW_SIDEBAR_COMPACT_MODE return self._MAIN_WINDOW_SIDEBAR_COMPACT_MODE
@IS_MAIN_WINDOW_SIDEBAR_COMPACT_MODE.setter @MAIN_WINDOW_SIDEBAR_COMPACT_MODE.setter
def IS_MAIN_WINDOW_SIDEBAR_COMPACT_MODE(self, value): def MAIN_WINDOW_SIDEBAR_COMPACT_MODE(self, value):
if isinstance(value, bool): if isinstance(value, bool):
self._IS_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_AUTOMATIC_SELECTION') @json_serializable('AUTO_MIC_SELECT')
def ENABLE_MIC_AUTOMATIC_SELECTION(self): def AUTO_MIC_SELECT(self):
return self._ENABLE_MIC_AUTOMATIC_SELECTION return self._AUTO_MIC_SELECT
@ENABLE_MIC_AUTOMATIC_SELECTION.setter @AUTO_MIC_SELECT.setter
def ENABLE_MIC_AUTOMATIC_SELECTION(self, value): def AUTO_MIC_SELECT(self, value):
if isinstance(value, bool): if isinstance(value, bool):
self._ENABLE_MIC_AUTOMATIC_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_AUTOMATIC_SELECTION') @json_serializable('AUTO_SPEAKER_SELECT')
def ENABLE_SPEAKER_AUTOMATIC_SELECTION(self): def AUTO_SPEAKER_SELECT(self):
return self._ENABLE_SPEAKER_AUTOMATIC_SELECTION return self._AUTO_SPEAKER_SELECT
@ENABLE_SPEAKER_AUTOMATIC_SELECTION.setter @AUTO_SPEAKER_SELECT.setter
def ENABLE_SPEAKER_AUTOMATIC_SELECTION(self, value): def AUTO_SPEAKER_SELECT(self, value):
if isinstance(value, bool): if isinstance(value, bool):
self._ENABLE_SPEAKER_AUTOMATIC_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:
@@ -1015,7 +1015,7 @@ class Config:
"2":"CTranslate2", "2":"CTranslate2",
"3":"CTranslate2", "3":"CTranslate2",
} }
self._SELECTED_TAB_YOUR_LANGUAGES = { self._SELECTED_YOUR_LANGUAGES = {
"1":{ "1":{
"primary":{ "primary":{
"language":"Japanese", "language":"Japanese",
@@ -1035,7 +1035,7 @@ class Config:
}, },
}, },
} }
self._SELECTED_TAB_TARGET_LANGUAGES = { self._SELECTED_TARGET_LANGUAGES = {
"1":{ "1":{
"primary":{ "primary":{
"language":"English", "language":"English",
@@ -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._IS_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_AUTOMATIC_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_AUTOMATIC_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:

104
src-python/model.py
View File

@@ -214,13 +214,13 @@ class Model:
def getInputTranslate(self, message): def getInputTranslate(self, message):
translator_name=config.SELECTED_TRANSLATOR_ENGINES[config.SELECTED_TAB_NO] translator_name=config.SELECTED_TRANSLATOR_ENGINES[config.SELECTED_TAB_NO]
source_language=config.SELECTED_TAB_YOUR_LANGUAGES[config.SELECTED_TAB_NO]["primary"]["language"] source_language=config.SELECTED_YOUR_LANGUAGES[config.SELECTED_TAB_NO]["primary"]["language"]
target_languages=config.SELECTED_TAB_TARGET_LANGUAGES[config.SELECTED_TAB_NO] target_languages=config.SELECTED_TARGET_LANGUAGES[config.SELECTED_TAB_NO]
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:
@@ -238,9 +238,9 @@ class Model:
def getOutputTranslate(self, message): def getOutputTranslate(self, message):
translator_name=config.SELECTED_TRANSLATOR_ENGINES[config.SELECTED_TAB_NO] translator_name=config.SELECTED_TRANSLATOR_ENGINES[config.SELECTED_TAB_NO]
source_language=config.SELECTED_TAB_TARGET_LANGUAGES[config.SELECTED_TAB_NO]["primary"]["language"] source_language=config.SELECTED_TARGET_LANGUAGES[config.SELECTED_TAB_NO]["primary"]["language"]
target_language=config.SELECTED_TAB_YOUR_LANGUAGES[config.SELECTED_TAB_NO]["primary"]["language"] target_language=config.SELECTED_YOUR_LANGUAGES[config.SELECTED_TAB_NO]["primary"]["language"]
target_country=config.SELECTED_TAB_YOUR_LANGUAGES[config.SELECTED_TAB_NO]["primary"]["country"] target_country=config.SELECTED_YOUR_LANGUAGES[config.SELECTED_TAB_NO]["primary"]["country"]
translation, success_flag = self.getTranslate( translation, success_flag = self.getTranslate(
translator_name, translator_name,
@@ -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_AUTOMATIC_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,
@@ -468,10 +468,10 @@ class Model:
try: try:
res = self.mic_transcriber.transcribeAudioQueue( res = self.mic_transcriber.transcribeAudioQueue(
self.mic_audio_queue, self.mic_audio_queue,
config.SELECTED_TAB_YOUR_LANGUAGES[config.SELECTED_TAB_NO]["primary"]["language"], config.SELECTED_YOUR_LANGUAGES[config.SELECTED_TAB_NO]["primary"]["language"],
config.SELECTED_TAB_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_AUTOMATIC_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_AUTOMATIC_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,
@@ -641,10 +641,10 @@ class Model:
try: try:
res = self.speaker_transcriber.transcribeAudioQueue( res = self.speaker_transcriber.transcribeAudioQueue(
speaker_audio_queue, speaker_audio_queue,
config.SELECTED_TAB_TARGET_LANGUAGES[config.SELECTED_TAB_NO]["primary"]["language"], config.SELECTED_TARGET_LANGUAGES[config.SELECTED_TAB_NO]["primary"]["language"],
config.SELECTED_TAB_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_AUTOMATIC_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)
@@ -732,8 +732,8 @@ class Model:
self.speaker_energy_recorder = None self.speaker_energy_recorder = None
def createOverlayImageShort(self, message, translation): def createOverlayImageShort(self, message, translation):
your_language = config.SELECTED_TAB_TARGET_LANGUAGES[config.SELECTED_TAB_NO]["primary"]["language"] your_language = config.SELECTED_TARGET_LANGUAGES[config.SELECTED_TAB_NO]["primary"]["language"]
target_language = config.SELECTED_TAB_YOUR_LANGUAGES[config.SELECTED_TAB_NO]["primary"]["language"] target_language = config.SELECTED_YOUR_LANGUAGES[config.SELECTED_TAB_NO]["primary"]["language"]
ui_type = config.OVERLAY_UI_TYPE ui_type = config.OVERLAY_UI_TYPE
self.pre_overlay_message = { self.pre_overlay_message = {
"message" : message, "message" : message,

12
src-python/models/transcription/transcription_utils.py
View File

@@ -125,11 +125,7 @@ class DeviceManager:
sleep(1) sleep(1)
enumerator.UnregisterEndpointNotificationCallback(cb) enumerator.UnregisterEndpointNotificationCallback(cb)
self.update() self.update()
self.noticeDefaultDevice()
if self.callback_default_input_device is not None:
self.callback_default_input_device(self.default_input_device["host"]["name"], self.default_input_device["device"]["name"])
if self.callback_default_output_device is not None:
self.callback_default_output_device(self.default_output_device["device"]["name"])
cb = Client() cb = Client()
enumerator = AudioUtilities.GetDeviceEnumerator() enumerator = AudioUtilities.GetDeviceEnumerator()
@@ -160,6 +156,12 @@ class DeviceManager:
def clearCallbackDefaultOutputDevice(self): def clearCallbackDefaultOutputDevice(self):
self.callback_default_output_device = None self.callback_default_output_device = None
def noticeDefaultDevice(self):
if self.callback_default_input_device is not None:
self.callback_default_input_device(self.default_input_device["host"]["name"], self.default_input_device["device"]["name"])
if self.callback_default_output_device is not None:
self.callback_default_output_device(self.default_output_device["device"]["name"])
def getInputDevices(self): def getInputDevices(self):
return self.input_devices return self.input_devices

2216
src-python/webui_controller.py
View File

File diff suppressed because it is too large Load Diff

686
src-python/webui_mainloop.py
View File

@@ -1,251 +1,309 @@
import sys import sys
import json import json
import time import time
from config import config
from threading import Thread from threading import Thread
from queue import Queue from queue import Queue
import webui_controller as controller import webui_controller as controller
from utils import printLog, printResponse, encodeBase64 from utils import printLog, printResponse, encodeBase64
config_mapping = { mapping = {
"/config/version": {"status": True, "variable":"VERSION"}, "/get/version": {"status": True, "variable":controller.getVersion},
"/config/transparency_range": {"status": True, "variable":"TRANSPARENCY_RANGE"}, "/get/transparency_range": {"status": True, "variable":controller.getTransparencyRange},
"/config/appearance_theme_list": {"status": True, "variable":"APPEARANCE_THEME_LIST"}, "/get/appearance_theme_list": {"status": True, "variable":controller.getAppearanceThemesList},
"/config/ui_scaling_list": {"status": True, "variable":"UI_SCALING_LIST"}, "/get/ui_scaling_list": {"status": True, "variable":controller.getUiScalingList},
"/config/textbox_ui_scaling_range": {"status": True, "variable":"TEXTBOX_UI_SCALING_RANGE"}, "/get/textbox_ui_scaling_range": {"status": True, "variable":controller.getTextboxUiScalingRange},
"/config/message_box_ratio_range": {"status": True, "variable":"MESSAGE_BOX_RATIO_RANGE"}, "/get/message_box_ratio_range": {"status": True, "variable":controller.getMessageBoxRatioRange},
"/config/selectable_ctranslate2_weight_type_dict": {"status": True, "variable":"SELECTABLE_CTRANSLATE2_WEIGHT_TYPE_DICT"}, "/get/selectable_ctranslate2_weight_type_dict": {"status": True, "variable":controller.getSelectableCtranslate2WeightTypeDict},
"/config/selectable_whisper_weight_type_dict": {"status": True, "variable":"SELECTABLE_WHISPER_WEIGHT_TYPE_DICT"}, "/get/selectable_whisper_weight_type_dict": {"status": True, "variable":controller.getSelectableWhisperModelTypeDict},
"/config/max_mic_energy_threshold": {"status": True, "variable":"MAX_MIC_ENERGY_THRESHOLD"}, "/get/max_mic_energy_threshold": {"status": True, "variable":controller.getMaxMicEnergyThreshold},
"/config/max_speaker_energy_threshold": {"status": True, "variable":"MAX_SPEAKER_ENERGY_THRESHOLD"}, "/get/max_speaker_energy_threshold": {"status": True, "variable":controller.getMaxSpeakerEnergyThreshold},
# "/config/enable_translation": {"status": True, "variable":"ENABLE_TRANSLATION"},
# "/config/enable_transcription_send": {"status": True, "variable":"ENABLE_TRANSCRIPTION_SEND"},
# "/config/enable_transcription_receive": {"status": True, "variable":"ENABLE_TRANSCRIPTION_RECEIVE"},
# "/config/enable_foreground": {"status": True, "variable":"ENABLE_FOREGROUND"},
# "/config/is_reset_button_displayed_for_translation": {"status": True, "variable":"IS_RESET_BUTTON_DISPLAYED_FOR_TRANSLATION"},
# "/config/is_reset_button_displayed_for_whisper": {"status": True, "variable":"IS_RESET_BUTTON_DISPLAYED_FOR_WHISPER"},
"/config/selected_tab_no": {"status": True, "variable":"SELECTED_TAB_NO"},
"/config/selected_translator_engines": {"status": False, "variable":"SELECTED_TRANSLATOR_ENGINES"},
"/config/selected_tab_your_languages": {"status": True, "variable":"SELECTED_TAB_YOUR_LANGUAGES"},
"/config/selected_tab_target_languages": {"status": True, "variable":"SELECTED_TAB_TARGET_LANGUAGES"},
"/config/selected_transcription_engine": {"status": False, "variable":"SELECTED_TRANSCRIPTION_ENGINE"},
"/config/enable_multi_translation": {"status": True, "variable":"ENABLE_MULTI_LANGUAGE_TRANSLATION"},
"/config/enable_convert_message_to_romaji": {"status": True, "variable":"ENABLE_CONVERT_MESSAGE_TO_ROMAJI"},
"/config/enable_convert_message_to_hiragana": {"status": True, "variable":"ENABLE_CONVERT_MESSAGE_TO_HIRAGANA"},
"/config/is_main_window_sidebar_compact_mode": {"status": True, "variable":"IS_MAIN_WINDOW_SIDEBAR_COMPACT_MODE"},
"/config/transparency": {"status": True, "variable":"TRANSPARENCY"},
"/config/appearance_theme": {"status": True, "variable":"APPEARANCE_THEME"},
"/config/ui_scaling": {"status": True, "variable":"UI_SCALING"},
"/config/textbox_ui_scaling": {"status": True, "variable":"TEXTBOX_UI_SCALING"},
"/config/message_box_ratio": {"status": True, "variable":"MESSAGE_BOX_RATIO"},
"/config/font_family": {"status": True, "variable":"FONT_FAMILY"},
"/config/ui_language": {"status": True, "variable":"UI_LANGUAGE"},
"/config/enable_restore_main_window_geometry": {"status": True, "variable":"ENABLE_RESTORE_MAIN_WINDOW_GEOMETRY"},
"/config/main_window_geometry": {"status": True, "variable":"MAIN_WINDOW_GEOMETRY"},
"/config/enable_mic_automatic_selection": {"status": True, "variable":"ENABLE_MIC_AUTOMATIC_SELECTION"},
"/config/choice_mic_host": {"status": True, "variable":"CHOICE_MIC_HOST"},
"/config/choice_mic_device": {"status": True, "variable":"CHOICE_MIC_DEVICE"},
"/config/input_mic_energy_threshold": {"status": True, "variable":"INPUT_MIC_ENERGY_THRESHOLD"},
"/config/input_mic_dynamic_energy_threshold": {"status": True, "variable":"INPUT_MIC_DYNAMIC_ENERGY_THRESHOLD"},
"/config/input_mic_record_timeout": {"status": True, "variable":"INPUT_MIC_RECORD_TIMEOUT"},
"/config/input_mic_phrase_timeout": {"status": True, "variable":"INPUT_MIC_PHRASE_TIMEOUT"},
"/config/input_mic_max_phrases": {"status": True, "variable":"INPUT_MIC_MAX_PHRASES"},
"/config/input_mic_word_filter": {"status": True, "variable":"INPUT_MIC_WORD_FILTER"},
"/config/input_mic_avg_logprob": {"status": True, "variable":"INPUT_MIC_AVG_LOGPROB"},
"/config/input_mic_no_speech_prob": {"status": True, "variable":"INPUT_MIC_NO_SPEECH_PROB"},
"/config/enable_speaker_automatic_selection": {"status": True, "variable":"ENABLE_SPEAKER_AUTOMATIC_SELECTION"},
"/config/choice_speaker_device": {"status": True, "variable":"CHOICE_SPEAKER_DEVICE"},
"/config/input_speaker_energy_threshold": {"status": True, "variable":"INPUT_SPEAKER_ENERGY_THRESHOLD"},
"/config/input_speaker_dynamic_energy_threshold": {"status": True, "variable":"INPUT_SPEAKER_DYNAMIC_ENERGY_THRESHOLD"},
"/config/input_speaker_record_timeout": {"status": True, "variable":"INPUT_SPEAKER_RECORD_TIMEOUT"},
"/config/input_speaker_phrase_timeout": {"status": True, "variable":"INPUT_SPEAKER_PHRASE_TIMEOUT"},
"/config/input_speaker_max_phrases": {"status": True, "variable":"INPUT_SPEAKER_MAX_PHRASES"},
"/config/input_speaker_avg_logprob": {"status": True, "variable":"INPUT_SPEAKER_AVG_LOGPROB"},
"/config/input_speaker_no_speech_prob": {"status": True, "variable":"INPUT_SPEAKER_NO_SPEECH_PROB"},
"/config/osc_ip_address": {"status": True, "variable":"OSC_IP_ADDRESS"},
"/config/osc_port": {"status": True, "variable":"OSC_PORT"},
"/config/auth_keys": {"status": False, "variable":"AUTH_KEYS"},
"/config/use_translation_feature": {"status": True, "variable":"USE_TRANSLATION_FEATURE"},
"/config/use_whisper_feature": {"status": True, "variable":"USE_WHISPER_FEATURE"},
"/config/ctranslate2_weight_type": {"status": True, "variable":"CTRANSLATE2_WEIGHT_TYPE"},
"/config/whisper_weight_type": {"status": True, "variable":"WHISPER_WEIGHT_TYPE"},
"/config/enable_auto_clear_message_box": {"status": True, "variable":"ENABLE_AUTO_CLEAR_MESSAGE_BOX"},
"/config/enable_send_only_translated_messages": {"status": True, "variable":"ENABLE_SEND_ONLY_TRANSLATED_MESSAGES"},
"/config/send_message_button_type": {"status": True, "variable":"SEND_MESSAGE_BUTTON_TYPE"},
"/config/overlay_settings": {"status": True, "variable":"OVERLAY_SETTINGS"},
"/config/enable_overlay_small_log": {"status": True, "variable":"ENABLE_OVERLAY_SMALL_LOG"},
"/config/overlay_small_log_settings": {"status": True, "variable":"OVERLAY_SMALL_LOG_SETTINGS"},
"/config/overlay_ui_type": {"status": True, "variable":"OVERLAY_UI_TYPE"},
"/config/enable_send_message_to_vrc": {"status": True, "variable":"ENABLE_SEND_MESSAGE_TO_VRC"},
"/config/send_message_format": {"status": True, "variable":"SEND_MESSAGE_FORMAT"},
"/config/send_message_format_with_t": {"status": True, "variable":"SEND_MESSAGE_FORMAT_WITH_T"},
"/config/received_message_format": {"status": True, "variable":"RECEIVED_MESSAGE_FORMAT"},
"/config/received_message_format_with_t": {"status": True, "variable":"RECEIVED_MESSAGE_FORMAT_WITH_T"},
"/config/enable_speaker2chatbox_pass": {"status": True, "variable":"ENABLE_SPEAKER2CHATBOX_PASS"},
"/config/enable_send_received_message_to_vrc": {"status": True, "variable":"ENABLE_SEND_RECEIVED_MESSAGE_TO_VRC"},
"/config/enable_logger": {"status": True, "variable":"ENABLE_LOGGER"},
"/config/enable_vrc_mic_mute_sync": {"status": True, "variable":"ENABLE_VRC_MIC_MUTE_SYNC"},
}
controller_mapping = { "/set/enable_translation": {"status": False, "variable":controller.setEnableTranslation},
"/controller/list_language_and_country": {"status": True, "variable":controller.getListLanguageAndCountry}, "/set/disable_translation": {"status": False, "variable":controller.setDisableTranslation},
"/controller/list_mic_host": {"status": True, "variable":controller.getListInputHost},
"/controller/list_mic_device": {"status": True, "variable":controller.getListInputDevice}, "/set/enable_foreground": {"status": True, "variable":controller.setEnableForeground},
"/controller/list_speaker_device": {"status": True, "variable":controller.getListOutputDevice}, "/set/disable_foreground": {"status": True, "variable":controller.setDisableForeground},
# "/controller/callback_update_software": {"status": True, "variable":controller.callbackUpdateSoftware},
# "/controller/callback_restart_software": {"status": True, "variable":controller.callbackRestartSoftware}, "/set/enable_config_window": {"status": True, "variable":controller.setEnableConfigWindow},
"/controller/callback_filepath_logs": {"status": True, "variable":controller.callbackFilepathLogs}, "/set/disable_config_window": {"status": True, "variable":controller.setDisableConfigWindow},
"/controller/callback_filepath_config_file": {"status": True, "variable":controller.callbackFilepathConfigFile},
# "/controller/callback_enable_easter_egg": {"status": True, "variable":controller.callbackEnableEasterEgg}, "/get/selected_tab_no": {"status": True, "variable":controller.getSelectedTabNo},
"/controller/callback_open_config_window": {"status": True, "variable":controller.callbackOpenConfigWindow}, "/set/selected_tab_no": {"status": True, "variable":controller.setSelectedTabNo},
"/controller/callback_close_config_window": {"status": True, "variable":controller.callbackCloseConfigWindow},
"/controller/callback_enable_multi_language_translation": {"status": True, "variable":controller.callbackEnableMultiLanguageTranslation}, "/get/list_translation_engines": {"status": True, "variable":controller.getTranslationEngines},
"/controller/callback_disable_multi_language_translation": {"status": True, "variable":controller.callbackDisableMultiLanguageTranslation}, "/get/list_languages": {"status": True, "variable":controller.getListLanguageAndCountry},
"/controller/callback_enable_convert_message_to_romaji": {"status": True, "variable":controller.callbackEnableConvertMessageToRomaji}, "/get/list_mic_host": {"status": True, "variable":controller.getListInputHost},
"/controller/callback_disable_convert_message_to_romaji": {"status": True, "variable":controller.callbackDisableConvertMessageToRomaji}, "/get/list_mic_device": {"status": True, "variable":controller.getListInputDevice},
"/controller/callback_enable_convert_message_to_hiragana": {"status": True, "variable":controller.callbackEnableConvertMessageToHiragana}, "/get/list_speaker_device": {"status": True, "variable":controller.getListOutputDevice},
"/controller/callback_disable_convert_message_to_hiragana": {"status": True, "variable":controller.callbackDisableConvertMessageToHiragana},
"/controller/callback_enable_main_window_sidebar_compact_mode": {"status": True, "variable":controller.callbackEnableMainWindowSidebarCompactMode}, "/get/selected_translator_engines": {"status": False, "variable":controller.getSelectedTranslatorEngines},
"/controller/callback_disable_main_window_sidebar_compact_mode": {"status": True, "variable":controller.callbackDisableMainWindowSidebarCompactMode}, "/set/selected_translator_engines": {"status": True, "variable":controller.setSelectedTranslatorEngines},
"/controller/callback_enable_translation": {"status": False, "variable":controller.callbackEnableTranslation},
"/controller/callback_disable_translation": {"status": False, "variable":controller.callbackDisableTranslation}, "/get/selected_your_languages": {"status": True, "variable":controller.getSelectedYourLanguages},
"/controller/callback_enable_transcription_send": {"status": False, "variable":controller.callbackEnableTranscriptionSend}, "/set/selected_your_languages": {"status": True, "variable":controller.setSelectedYourLanguages},
"/controller/callback_disable_transcription_send": {"status": False, "variable":controller.callbackDisableTranscriptionSend},
"/controller/callback_enable_transcription_receive": {"status": False, "variable":controller.callbackEnableTranscriptionReceive}, "/get/selected_target_languages": {"status": True, "variable":controller.getSelectedTargetLanguages},
"/controller/callback_disable_transcription_receive": {"status": False, "variable":controller.callbackDisableTranscriptionReceive}, "/set/selected_target_languages": {"status": True, "variable":controller.setSelectedTargetLanguages},
"/controller/callback_messagebox_send": {"status": False, "variable":controller.callbackMessageBoxSend},
"/controller/callback_messagebox_typing": {"status": False, "variable":controller.callbackMessageBoxTyping}, "/get/selected_transcription_engine": {"status": False, "variable":controller.getSelectedTranscriptionEngine},
"/controller/callback_messagebox_typing_stop": {"status": False, "variable":controller.callbackMessageBoxTypingStop},
"/controller/callback_enable_foreground": {"status": True, "variable":controller.callbackEnableForeground}, "/get/multi_language_translation": {"status": True, "variable":controller.getMultiLanguageTranslation},
"/controller/callback_disable_foreground": {"status": True, "variable":controller.callbackDisableForeground}, "/set/enable_multi_language_translation": {"status": True, "variable":controller.setEnableMultiLanguageTranslation},
"/controller/set_your_language_and_country": {"status": True, "variable":controller.setYourLanguageAndCountry}, "/set/disable_multi_language_translation": {"status": True, "variable":controller.setDisableMultiLanguageTranslation},
"/controller/set_target_language_and_country": {"status": True, "variable":controller.setTargetLanguageAndCountry},
"/controller/swap_your_language_and_target_language": {"status": True, "variable":controller.swapYourLanguageAndTargetLanguage}, "/get/convert_message_to_romaji": {"status": True, "variable":controller.getConvertMessageToRomaji},
"/controller/callback_selected_language_preset_tab": {"status": True, "variable":controller.callbackSelectedLanguagePresetTab}, "/set/enable_convert_message_to_romaji": {"status": True, "variable":controller.setEnableConvertMessageToRomaji},
"/controller/list_translation_engines": {"status": True, "variable":controller.getTranslationEngines}, "/set/disable_convert_message_to_romaji": {"status": True, "variable":controller.setDisableConvertMessageToRomaji},
"/controller/callback_set_translation_engines": {"status": True, "variable":controller.callbackSetSelectedTranslationEngines},
"/controller/callback_set_transparency": {"status": True, "variable":controller.callbackSetTransparency}, "/get/convert_message_to_hiragana": {"status": True, "variable":controller.getConvertMessageToHiragana},
"/controller/callback_set_appearance": {"status": True, "variable":controller.callbackSetAppearance}, "/set/enable_convert_message_to_hiragana": {"status": True, "variable":controller.setEnableConvertMessageToHiragana},
"/controller/callback_set_ui_scaling": {"status": True, "variable":controller.callbackSetUiScaling}, "/set/disable_convert_message_to_hiragana": {"status": True, "variable":controller.setDisableConvertMessageToHiragana},
"/controller/callback_set_textbox_ui_scaling": {"status": True, "variable":controller.callbackSetTextboxUiScaling},
"/controller/callback_set_message_box_ratio": {"status": True, "variable":controller.callbackSetMessageBoxRatio}, "/get/main_window_sidebar_compact_mode": {"status": True, "variable":controller.getMainWindowSidebarCompactMode},
"/controller/callback_set_font_family": {"status": True, "variable":controller.callbackSetFontFamily}, "/set/enable_main_window_sidebar_compact_mode": {"status": True, "variable":controller.setEnableMainWindowSidebarCompactMode},
"/controller/callback_set_ui_language": {"status": True, "variable":controller.callbackSetUiLanguage}, "/set/disable_main_window_sidebar_compact_mode": {"status": True, "variable":controller.setDisableMainWindowSidebarCompactMode},
"/controller/callback_enable_restore_main_window_geometry": {"status": True, "variable":controller.callbackEnableRestoreMainWindowGeometry},
"/controller/callback_disable_restore_main_window_geometry": {"status": True, "variable":controller.callbackDisableRestoreMainWindowGeometry}, "/get/transparency": {"status": True, "variable":controller.getTransparency},
"/controller/callback_enable_use_translation_feature": {"status": True, "variable":controller.callbackEnableUseTranslationFeature}, "/set/transparency": {"status": True, "variable":controller.setTransparency},
"/controller/callback_disable_use_translation_feature": {"status": True, "variable":controller.callbackDisableUseTranslationFeature},
"/controller/callback_set_ctranslate2_weight_type": {"status": True, "variable":controller.callbackSetCtranslate2WeightType}, "/get/appearance_theme": {"status": True, "variable":controller.getAppearanceTheme},
"/controller/callback_download_ctranslate2_weight": {"status": True, "variable":controller.callbackDownloadCtranslate2Weight}, "/set/appearance_theme": {"status": True, "variable":controller.setAppearanceTheme},
"/controller/callback_set_deepl_auth_key": {"status": True, "variable":controller.callbackSetDeeplAuthKey},
"/controller/callback_clear_deepl_auth_key": {"status": True, "variable":controller.callbackClearDeeplAuthKey}, "/get/ui_scaling": {"status": True, "variable":controller.getUiScaling},
"/controller/callback_enable_mic_automatic_selection": {"status": False, "variable":controller.callbackEnableMicAutomaticSelection}, "/set/ui_scaling": {"status": True, "variable":controller.setUiScaling},
"/controller/callback_disable_mic_automatic_selection": {"status": False, "variable":controller.callbackDisableMicAutomaticSelection},
"/controller/callback_set_mic_host": {"status": True, "variable":controller.callbackSetMicHost}, "/get/textbox_ui_scaling": {"status": True, "variable":controller.getTextboxUiScaling},
"/controller/callback_set_mic_device": {"status": True, "variable":controller.callbackSetMicDevice}, "/set/textbox_ui_scaling": {"status": True, "variable":controller.setTextboxUiScaling},
"/controller/callback_set_mic_energy_threshold": {"status": True, "variable":controller.callbackSetMicEnergyThreshold},
"/controller/callback_enable_mic_dynamic_energy_threshold": {"status": True, "variable":controller.callbackEnableMicDynamicEnergyThreshold}, "/get/message_box_ratio": {"status": True, "variable":controller.getMessageBoxRatio},
"/controller/callback_disable_mic_dynamic_energy_threshold": {"status": True, "variable":controller.callbackDisableMicDynamicEnergyThreshold}, "/set/message_box_ratio": {"status": True, "variable":controller.setMessageBoxRatio},
"/controller/callback_enable_check_mic_threshold": {"status": True, "variable":controller.callbackEnableCheckMicThreshold},
"/controller/callback_disable_check_mic_threshold": {"status": True, "variable":controller.callbackDisableCheckMicThreshold}, "/get/font_family": {"status": True, "variable":controller.getFontFamily},
"/controller/callback_set_mic_record_timeout": {"status": True, "variable":controller.callbackSetMicRecordTimeout}, "/set/font_family": {"status": True, "variable":controller.setFontFamily},
"/controller/callback_set_mic_phrase_timeout": {"status": True, "variable":controller.callbackSetMicPhraseTimeout},
"/controller/callback_set_mic_max_phrases": {"status": True, "variable":controller.callbackSetMicMaxPhrases}, "/get/ui_language": {"status": True, "variable":controller.getUiLanguage},
"/controller/callback_set_mic_word_filter": {"status": False, "variable":controller.callbackSetMicWordFilter}, "/set/ui_language": {"status": True, "variable":controller.setUiLanguage},
"/controller/callback_delete_mic_word_filter": {"status": False, "variable":controller.callbackDeleteMicWordFilter},
"/controller/callback_enable_speaker_automatic_selection": {"status": False, "variable":controller.callbackEnableSpeakerAutomaticSelection}, "/get/restore_main_window_geometry": {"status": True, "variable":controller.getRestoreMainWindowGeometry},
"/controller/callback_disable_speaker_automatic_selection": {"status": False, "variable":controller.callbackDisableSpeakerAutomaticSelection}, "/set/enable_restore_main_window_geometry": {"status": True, "variable":controller.setEnableRestoreMainWindowGeometry},
"/controller/callback_set_speaker_device": {"status": True, "variable":controller.callbackSetSpeakerDevice}, "/set/disable_restore_main_window_geometry": {"status": True, "variable":controller.setDisableRestoreMainWindowGeometry},
"/controller/callback_set_speaker_energy_threshold": {"status": True, "variable":controller.callbackSetSpeakerEnergyThreshold},
"/controller/callback_enable_speaker_dynamic_energy_threshold": {"status": True, "variable":controller.callbackEnableSpeakerDynamicEnergyThreshold}, "/get/main_window_geometry": {"status": True, "variable":controller.getMainWindowGeometry},
"/controller/callback_disable_speaker_dynamic_energy_threshold": {"status": True, "variable":controller.callbackDisableSpeakerDynamicEnergyThreshold}, "/set/main_window_geometry": {"status": True, "variable":controller.setMainWindowGeometry},
"/controller/callback_enable_check_speaker_threshold": {"status": True, "variable":controller.callbackEnableCheckSpeakerThreshold},
"/controller/callback_disable_check_speaker_threshold": {"status": True, "variable":controller.callbackDisableCheckSpeakerThreshold}, "/get/auto_mic_select": {"status": True, "variable":controller.getAutoMicSelect},
"/controller/callback_set_speaker_record_timeout": {"status": True, "variable":controller.callbackSetSpeakerRecordTimeout}, "/set/enable_auto_mic_select": {"status": True, "variable":controller.setEnableAutoMicSelect},
"/controller/callback_set_speaker_phrase_timeout": {"status": True, "variable":controller.callbackSetSpeakerPhraseTimeout}, "/set/disable_auto_mic_select": {"status": True, "variable":controller.setDisableAutoMicSelect},
"/controller/callback_set_speaker_max_phrases": {"status": True, "variable":controller.callbackSetSpeakerMaxPhrases},
"/controller/callback_enable_use_whisper_feature": {"status": True, "variable":controller.callbackEnableUseWhisperFeature}, "/get/selected_mic_host": {"status": True, "variable":controller.getSelectedMicHost},
"/controller/callback_disable_use_whisper_feature": {"status": True, "variable":controller.callbackDisableUseWhisperFeature}, "/set/selected_mic_host": {"status": True, "variable":controller.setSelectedMicHost},
"/controller/callback_set_whisper_weight_type": {"status": True, "variable":controller.callbackSetWhisperWeightType},
"/controller/callback_download_whisper_weight": {"status": True, "variable":controller.callbackDownloadWhisperWeight}, "/get/selected_mic_device": {"status": True, "variable":controller.getSelectedMicDevice},
"/controller/callback_set_overlay_settings_opacity": {"status": True, "variable":controller.callbackSetOverlaySettingsOpacity}, "/set/selected_mic_device": {"status": True, "variable":controller.setSelectedMicDevice},
"/controller/callback_set_overlay_settings_ui_scaling": {"status": True, "variable":controller.callbackSetOverlaySettingsUiScaling},
"/controller/callback_enable_overlay_small_log": {"status": True, "variable":controller.callbackEnableOverlaySmallLog}, "/get/mic_energy_threshold": {"status": True, "variable":controller.getMicEnergyThreshold},
"/controller/callback_disable_overlay_small_log": {"status": True, "variable":controller.callbackDisableOverlaySmallLog}, "/set/mic_energy_threshold": {"status": True, "variable":controller.setMicEnergyThreshold},
"/controller/callback_set_overlay_small_log_settings_x_pos": {"status": True, "variable":controller.callbackSetOverlaySmallLogSettingsXPos},
"/controller/callback_set_overlay_small_log_settings_y_pos": {"status": True, "variable":controller.callbackSetOverlaySmallLogSettingsYPos}, "/get/mic_dynamic_energy_threshold": {"status": True, "variable":controller.getMicDynamicEnergyThreshold},
"/controller/callback_set_overlay_small_log_settings_z_pos": {"status": True, "variable":controller.callbackSetOverlaySmallLogSettingsZPos}, "/set/enable_mic_dynamic_energy_threshold": {"status": True, "variable":controller.setEnableMicDynamicEnergyThreshold},
"/controller/callback_set_overlay_small_log_settings_x_rotation": {"status": True, "variable":controller.callbackSetOverlaySmallLogSettingsXRotation}, "/set/disable_mic_dynamic_energy_threshold": {"status": True, "variable":controller.setDisableMicDynamicEnergyThreshold},
"/controller/callback_set_overlay_small_log_settings_y_rotation": {"status": True, "variable":controller.callbackSetOverlaySmallLogSettingsYRotation},
"/controller/callback_set_overlay_small_log_settings_z_rotation": {"status": True, "variable":controller.callbackSetOverlaySmallLogSettingsZRotation}, "/get/mic_record_timeout": {"status": True, "variable":controller.getMicRecordTimeout},
"/controller/callback_enable_auto_clear_chatbox": {"status": True, "variable":controller.callbackEnableAutoClearMessageBox}, "/set/mic_record_timeout": {"status": True, "variable":controller.setMicRecordTimeout},
"/controller/callback_disable_auto_clear_chatbox": {"status": True, "variable":controller.callbackDisableAutoClearMessageBox},
"/controller/callback_enable_send_only_translated_messages": {"status": True, "variable":controller.callbackEnableSendOnlyTranslatedMessages}, "/get/mic_phrase_timeout": {"status": True, "variable":controller.getMicPhraseTimeout},
"/controller/callback_disable_send_only_translated_messages": {"status": True, "variable":controller.callbackDisableSendOnlyTranslatedMessages}, "/set/mic_phrase_timeout": {"status": True, "variable":controller.setMicPhraseTimeout},
"/controller/callback_set_send_message_button_type": {"status": True, "variable":controller.callbackSetSendMessageButtonType},
"/controller/callback_enable_auto_export_message_logs": {"status": True, "variable":controller.callbackEnableAutoExportMessageLogs}, "/get/mic_max_phrases": {"status": True, "variable":controller.getMicMaxPhrases},
"/controller/callback_disable_auto_export_message_logs": {"status": True, "variable":controller.callbackDisableAutoExportMessageLogs}, "/set/mic_max_phrases": {"status": True, "variable":controller.setMicMaxPhrases},
"/controller/callback_enable_vrc_mic_mute_sync": {"status": False, "variable":controller.callbackEnableVrcMicMuteSync},
"/controller/callback_disable_vrc_mic_mute_sync": {"status": False, "variable":controller.callbackDisableVrcMicMuteSync}, "/get/mic_word_filter": {"status": True, "variable":controller.getMicWordFilter},
"/controller/callback_enable_send_message_to_vrc": {"status": True, "variable":controller.callbackEnableSendMessageToVrc}, "/set/mic_word_filter": {"status": True, "variable":controller.setMicWordFilter},
"/controller/callback_disable_send_message_to_vrc": {"status": True, "variable":controller.callbackDisableSendMessageToVrc}, "/del/mic_word_filter": {"status": True, "variable":controller.delMicWordFilter},
"/controller/callback_set_send_message_format": {"status": True, "variable":controller.callbackSetSendMessageFormat},
"/controller/callback_set_send_message_format_with_t": {"status": True, "variable":controller.callbackSetSendMessageFormatWithT}, "/get/mic_avg_logprob": {"status": True, "variable":controller.getMicAvgLogprob},
"/controller/callback_set_received_message_format": {"status": True, "variable":controller.callbackSetReceivedMessageFormat}, "/set/mic_avg_logprob": {"status": True, "variable":controller.setMicAvgLogprob},
"/controller/callback_set_received_message_format_with_t": {"status": True, "variable":controller.callbackSetReceivedMessageFormatWithT},
"/controller/callback_enable_send_received_message_to_vrc": {"status": True, "variable":controller.callbackEnableSendReceivedMessageToVrc}, "/get/mic_no_speech_prob": {"status": True, "variable":controller.getMicNoSpeechProb},
"/controller/callback_disable_send_received_message_to_vrc": {"status": True, "variable":controller.callbackDisableSendReceivedMessageToVrc}, "/set/mic_no_speech_prob": {"status": True, "variable":controller.setMicNoSpeechProb},
"/controller/callback_enable_logger": {"status": False, "variable":controller.callbackEnableLogger},
"/controller/callback_disable_logger": {"status": False, "variable":controller.callbackDisableLogger}, "/get/auto_speaker_select": {"status": True, "variable":controller.getAutoSpeakerSelect},
"/controller/callback_set_osc_ip_address": {"status": True, "variable":controller.callbackSetOscIpAddress}, "/set/enable_auto_speaker_select": {"status": True, "variable":controller.setEnableAutoSpeakerSelect},
"/controller/callback_set_osc_port": {"status": True, "variable":controller.callbackSetOscPort}, "/set/disable_auto_speaker_select": {"status": True, "variable":controller.setDisableAutoSpeakerSelect},
"/get/selected_speaker_device": {"status": True, "variable":controller.getSelectedSpeakerDevice},
"/set/selected_speaker_device": {"status": True, "variable":controller.setSelectedSpeakerDevice},
"/get/speaker_energy_threshold": {"status": True, "variable":controller.getSpeakerEnergyThreshold},
"/set/speaker_energy_threshold": {"status": True, "variable":controller.setSpeakerEnergyThreshold},
"/get/speaker_dynamic_energy_threshold": {"status": True, "variable":controller.getSpeakerDynamicEnergyThreshold},
"/set/enable_speaker_dynamic_energy_threshold": {"status": True, "variable":controller.setEnableSpeakerDynamicEnergyThreshold},
"/set/disable_speaker_dynamic_energy_threshold": {"status": True, "variable":controller.setDisableSpeakerDynamicEnergyThreshold},
"/get/speaker_record_timeout": {"status": True, "variable":controller.getSpeakerRecordTimeout},
"/set/speaker_record_timeout": {"status": True, "variable":controller.setSpeakerRecordTimeout},
"/get/speaker_phrase_timeout": {"status": True, "variable":controller.getSpeakerPhraseTimeout},
"/set/speaker_phrase_timeout": {"status": True, "variable":controller.setSpeakerPhraseTimeout},
"/get/speaker_max_phrases": {"status": True, "variable":controller.getSpeakerMaxPhrases},
"/set/speaker_max_phrases": {"status": True, "variable":controller.setSpeakerMaxPhrases},
"/get/speaker_avg_logprob": {"status": True, "variable":controller.getSpeakerAvgLogprob},
"/set/speaker_avg_logprob": {"status": True, "variable":controller.setSpeakerAvgLogprob},
"/get/speaker_no_speech_prob": {"status": True, "variable":controller.getSpeakerNoSpeechProb},
"/set/speaker_no_speech_prob": {"status": True, "variable":controller.setSpeakerNoSpeechProb},
"/get/osc_ip_address": {"status": True, "variable":controller.getOscIpAddress},
"/set/osc_ip_address": {"status": True, "variable":controller.setOscIpAddress},
"/get/osc_port": {"status": True, "variable":controller.getOscPort},
"/set/osc_port": {"status": True, "variable":controller.setOscPort},
"/get/deepl_auth_key": {"status": False, "variable":controller.getDeepLAuthKey},
"/set/deepl_auth_key": {"status": False, "variable":controller.setDeeplAuthKey},
"/del/deepl_auth_key": {"status": False, "variable":controller.delDeeplAuthKey},
"/get/use_translation_feature": {"status": True, "variable":controller.getUseTranslationFeature},
"/set/enable_use_translation_feature": {"status": True, "variable":controller.setEnableUseTranslationFeature},
"/set/disable_use_translation_feature": {"status": True, "variable":controller.setDisableUseTranslationFeature},
"/get/use_whisper_feature": {"status": True, "variable":controller.getUseWhisperFeature},
"/set/enable_use_whisper_feature": {"status": True, "variable":controller.setEnableUseWhisperFeature},
"/set/disable_use_whisper_feature": {"status": True, "variable":controller.setDisableUseWhisperFeature},
"/get/ctranslate2_weight_type": {"status": True, "variable":controller.getCtranslate2WeightType},
"/set/ctranslate2_weight_type": {"status": True, "variable":controller.setCtranslate2WeightType},
"/get/whisper_weight_type": {"status": True, "variable":controller.getWhisperWeightType},
"/set/whisper_weight_type": {"status": True, "variable":controller.setWhisperWeightType},
"/get/auto_clear_message_box": {"status": True, "variable":controller.getAutoClearMessageBox},
"/set/enable_auto_clear_message_box": {"status": True, "variable":controller.setEnableAutoClearMessageBox},
"/set/disable_auto_clear_message_box": {"status": True, "variable":controller.setDisableAutoClearMessageBox},
"/get/send_only_translated_messages": {"status": True, "variable":controller.getSendOnlyTranslatedMessages},
"/set/enable_send_only_translated_messages": {"status": True, "variable":controller.setEnableSendOnlyTranslatedMessages},
"/set/disable_send_only_translated_messages": {"status": True, "variable":controller.setDisableSendOnlyTranslatedMessages},
"/get/send_message_button_type": {"status": True, "variable":controller.getSendMessageButtonType},
"/set/send_message_button_type": {"status": True, "variable":controller.setSendMessageButtonType},
"/get/overlay_settings": {"status": True, "variable":controller.getOverlaySettings},
"/set/overlay_settings": {"status": True, "variable":controller.setOverlaySettings},
"/get/overlay_small_log_settings": {"status": True, "variable":controller.getOverlaySmallLogSettings},
"/set/overlay_small_log_settings": {"status": True, "variable":controller.setOverlaySmallLogSettings},
"/get/overlay_small_log": {"status": True, "variable":controller.getOverlaySmallLog},
"/set/enable_overlay_small_log": {"status": True, "variable":controller.setEnableOverlaySmallLog},
"/set/disable_overlay_small_log": {"status": True, "variable":controller.setDisableOverlaySmallLog},
"/get/send_message_to_vrc": {"status": True, "variable":controller.getSendMessageToVrc},
"/set/enable_send_message_to_vrc": {"status": True, "variable":controller.setEnableSendMessageToVrc},
"/set/disable_send_message_to_vrc": {"status": True, "variable":controller.setDisableSendMessageToVrc},
"/get/send_message_format": {"status": True, "variable":controller.getSendMessageFormat},
"/set/send_message_format": {"status": True, "variable":controller.setSendMessageFormat},
"/get/send_message_format_with_t": {"status": True, "variable":controller.getSendMessageFormatWithT},
"/set/send_message_format_with_t": {"status": True, "variable":controller.setSendMessageFormatWithT},
"/get/received_message_format": {"status": True, "variable":controller.getReceivedMessageFormat},
"/set/received_message_format": {"status": True, "variable":controller.setReceivedMessageFormat},
"/get/received_message_format_with_t": {"status": True, "variable":controller.getReceivedMessageFormatWithT},
"/set/received_message_format_with_t": {"status": True, "variable":controller.setReceivedMessageFormatWithT},
"/get/speaker2chatbox_pass": {"status": True, "variable":controller.getSpeaker2ChatboxPass},
"/set/speaker2chatbox_pass": {"status": True, "variable":controller.setSpeaker2ChatboxPass},
"/get/send_received_message_to_vrc": {"status": True, "variable":controller.getSendReceivedMessageToVrc},
"/set/enable_send_received_message_to_vrc": {"status": True, "variable":controller.setEnableSendReceivedMessageToVrc},
"/set/disable_send_received_message_to_vrc": {"status": True, "variable":controller.setDisableSendReceivedMessageToVrc},
"/get/logger": {"status": True, "variable":controller.getLogger},
"/set/enable_logger": {"status": True, "variable":controller.setEnableLogger},
"/set/disable_logger": {"status": True, "variable":controller.setDisableLogger},
"/get/vrc_mic_mute_sync": {"status": True, "variable":controller.getVrcMicMuteSync},
"/set/enable_vrc_mic_mute_sync": {"status": True, "variable":controller.setEnableVrcMicMuteSync},
"/set/disable_vrc_mic_mute_sync": {"status": True, "variable":controller.setDisableVrcMicMuteSync},
"/set/enable_check_mic_threshold": {"status": True, "variable":controller.setEnableCheckMicThreshold},
"/set/disable_check_mic_threshold": {"status": True, "variable":controller.setDisableCheckMicThreshold},
"/set/enable_check_speaker_threshold": {"status": True, "variable":controller.setEnableCheckSpeakerThreshold},
"/set/disable_check_speaker_threshold": {"status": True, "variable":controller.setDisableCheckSpeakerThreshold},
# "/run/update_software": {"status": True, "variable":controller.updateSoftware},
# "/run/restart_software": {"status": True, "variable":controller.restartSoftware},
"/run/open_filepath_logs": {"status": True, "variable":controller.openFilepathLogs},
"/run/open_filepath_config_file": {"status": True, "variable":controller.openFilepathConfigFile},
"/set/enable_transcription_send": {"status": False, "variable":controller.setEnableTranscriptionSend},
"/set/disable_transcription_send": {"status": False, "variable":controller.setDisableTranscriptionSend},
"/set/enable_transcription_receive": {"status": False, "variable":controller.setEnableTranscriptionReceive},
"/set/disable_transcription_receive": {"status": False, "variable":controller.setDisableTranscriptionReceive},
"/run/send_message_box": {"status": False, "variable":controller.sendMessageBox},
"/run/typing_message_box": {"status": False, "variable":controller.typingMessageBox},
"/run/stop_typing_message_box": {"status": False, "variable":controller.stopTypingMessageBox},
"/run/swap_your_language_and_target_language": {"status": True, "variable":controller.swapYourLanguageAndTargetLanguage},
"/run/download_ctranslate2_weight": {"status": True, "variable":controller.downloadCtranslate2Weight},
"/run/download_whisper_weight": {"status": True, "variable":controller.downloadWhisperWeight},
} }
action_mapping = { action_mapping = {
"/controller/callback_update_software": { "/run/update_software": {
"download":"/action/download_software", "download":"/action/download_software",
"update":"/action/update_software" "update":"/action/update_software"
}, },
"/controller/callback_close_config_window": { "/set/disable_config_window": {
"mic":"/action/transcription_send_mic_message", "mic":"/action/transcription_send_mic_message",
"speaker":"/action/transcription_receive_speaker_message", "speaker":"/action/transcription_receive_speaker_message",
"error_device":"/action/error_device", "error_device":"/action/error_device",
"error_translation_engine":"/action/error_translation_engine", "error_translation_engine":"/action/error_translation_engine",
"word_filter":"/action/word_filter", "word_filter":"/action/word_filter",
}, },
"/controller/callback_enable_transcription_send": { "/set/enable_transcription_send": {
"mic":"/action/transcription_send_mic_message", "mic":"/action/transcription_send_mic_message",
"error_device":"/action/error_device", "error_device":"/action/error_device",
"error_translation_engine":"/action/error_translation_engine", "error_translation_engine":"/action/error_translation_engine",
"word_filter":"/action/word_filter", "word_filter":"/action/word_filter",
}, },
"/controller/callback_enable_transcription_receive": { "/set/enable_transcription_receive": {
"speaker":"/action/transcription_receive_speaker_message", "speaker":"/action/transcription_receive_speaker_message",
"error_device":"/action/error_device", "error_device":"/action/error_device",
"error_translation_engine":"/action/error_translation_engine", "error_translation_engine":"/action/error_translation_engine",
}, },
"/controller/callback_enable_check_mic_threshold": { "/set/enable_check_mic_threshold": {
"mic":"/action/check_mic_threshold_energy", "mic":"/action/check_mic_threshold_energy",
"error_device":"/action/error_device", "error_device":"/action/error_device",
}, },
"/controller/callback_enable_check_speaker_threshold": { "/set/enable_check_speaker_threshold": {
"speaker":"/action/check_speaker_threshold_energy", "speaker":"/action/check_speaker_threshold_energy",
"error_device":"/action/error_device", "error_device":"/action/error_device",
}, },
"/controller/callback_messagebox_send": { "/run/send_message_box": {
"error_translation_engine":"/action/error_translation_engine" "error_translation_engine":"/action/error_translation_engine"
}, },
"/controller/callback_download_ctranslate2_weight": { "/run/download_ctranslate2_weight": {
"download":"/action/download_ctranslate2_weight" "download":"/action/download_ctranslate2_weight"
}, },
"/controller/callback_download_whisper_weight": { "/run/download_whisper_weight": {
"download":"/action/download_whisper_weight" "download":"/action/download_whisper_weight"
}, },
"/controller/callback_enable_mic_automatic_selection": { "/set/enable_auto_mic_select": {
"mic":"/controller/callback_set_mic_host", "mic":"/set/selected_mic_host",
}, },
"/controller/callback_enable_speaker_automatic_selection": { "/set/enable_auto_speaker_select": {
"speaker":"/controller/callback_set_speaker_device", "speaker":"/set/selected_speaker_device",
} }
} }
@@ -263,8 +321,7 @@ class Action:
class Main: class Main:
def __init__(self) -> None: def __init__(self) -> None:
self.queue_config = Queue() self.queue = Queue()
self.queue_controller = Queue()
def receiver(self) -> None: def receiver(self) -> None:
while True: while True:
@@ -276,35 +333,15 @@ class Main:
data = received_data.get("data", None) data = received_data.get("data", None)
data = encodeBase64(data) if data is not None else None data = encodeBase64(data) if data is not None else None
printLog(endpoint, {"receive_data":data}) printLog(endpoint, {"receive_data":data})
self.queue.put((endpoint, data))
match endpoint.split("/")[1]:
case "config":
self.queue_config.put(endpoint)
case "controller":
self.queue_controller.put((endpoint, data))
case _:
pass
def startReceiver(self) -> None: def startReceiver(self) -> None:
th_receiver = Thread(target=self.receiver) th_receiver = Thread(target=self.receiver)
th_receiver.daemon = True th_receiver.daemon = True
th_receiver.start() th_receiver.start()
def handleConfigRequest(self, endpoint): def handleRequest(self, endpoint, data=None):
handler = config_mapping.get(endpoint) handler = mapping.get(endpoint)
if handler is None:
response = "Invalid endpoint"
status = 404
elif handler["status"] is False:
response = "Locked endpoint"
status = 423
else:
response = getattr(config, handler["variable"])
status = 200
return response, status
def handleControllerRequest(self, endpoint, data=None):
handler = controller_mapping.get(endpoint)
if handler is None: if handler is None:
response = "Invalid endpoint" response = "Invalid endpoint"
status = 404 status = 404
@@ -325,12 +362,12 @@ class Main:
status = 500 status = 500
return result, status return result, status
def configHandler(self) -> None: def handler(self) -> None:
while True: while True:
if not self.queue_config.empty(): if not self.queue.empty():
endpoint = self.queue_config.get()
try: try:
result, status = self.handleConfigRequest(endpoint) endpoint, data = self.queue.get()
result, status = self.handleRequest(endpoint, data)
except Exception as e: except Exception as e:
import traceback import traceback
with open('error.log', 'a') as f: with open('error.log', 'a') as f:
@@ -339,41 +376,16 @@ class Main:
status = 500 status = 500
if status == 423: if status == 423:
self.queue_config.put(endpoint) self.queue.put((endpoint, data))
else: else:
printLog(endpoint, {"send_data":result}) printLog(endpoint, {"send_data":result})
printResponse(status, endpoint, result) printResponse(status, endpoint, result)
time.sleep(0.1) time.sleep(0.1)
def startConfigHandler(self) -> None: def startHandler(self) -> None:
th_config = Thread(target=self.configHandler) th_handler = Thread(target=self.handler)
th_config.daemon = True th_handler.daemon = True
th_config.start() th_handler.start()
def controllerHandler(self) -> None:
while True:
if not self.queue_controller.empty():
try:
endpoint, data = self.queue_controller.get()
result, status = self.handleControllerRequest(endpoint, data)
except Exception as e:
import traceback
with open('error.log', 'a') as f:
traceback.print_exc(file=f)
result = str(e)
status = 500
if status == 423:
self.queue_controller.put((endpoint, data))
else:
printLog(endpoint, {"send_data":result})
printResponse(status, endpoint, result)
time.sleep(0.1)
def startControllerHandler(self) -> None:
th_controller = Thread(target=self.controllerHandler)
th_controller.daemon = True
th_controller.start()
def loop(self) -> None: def loop(self) -> None:
while True: while True:
@@ -382,21 +394,18 @@ class Main:
if __name__ == "__main__": if __name__ == "__main__":
main = Main() main = Main()
main.startReceiver() main.startReceiver()
main.startConfigHandler() main.startHandler()
main.startControllerHandler()
controller.init({ controller.init({
"download_ctranslate2": Action(action_mapping["/controller/callback_download_ctranslate2_weight"]).transmit, "download_ctranslate2": Action(action_mapping["/run/download_ctranslate2_weight"]).transmit,
"download_whisper": Action(action_mapping["/controller/callback_download_whisper_weight"]).transmit, "download_whisper": Action(action_mapping["/run/download_whisper_weight"]).transmit,
"update_selected_mic_device": Action(action_mapping["/controller/callback_enable_mic_automatic_selection"]).transmit, "update_selected_mic_device": Action(action_mapping["/set/enable_auto_mic_select"]).transmit,
"update_selected_speaker_device": Action(action_mapping["/controller/callback_enable_speaker_automatic_selection"]).transmit, "update_selected_speaker_device": Action(action_mapping["/set/enable_auto_speaker_select"]).transmit,
}) })
# mappingのすべてのstatusをTrueにする # mappingのすべてのstatusをTrueにする
for key in config_mapping.keys(): for key in mapping.keys():
config_mapping[key]["status"] = True mapping[key]["status"] = True
for key in controller_mapping.keys():
controller_mapping[key]["status"] = True
process = "main" process = "main"
match process: match process:
@@ -406,32 +415,27 @@ if __name__ == "__main__":
case "test": case "test":
for _ in range(100): for _ in range(100):
time.sleep(0.5) time.sleep(0.5)
endpoint = "/controller/list_mic_host" endpoint = "/get/list_mic_host"
result, status = main.handleControllerRequest(endpoint) result, status = main.handleRequest(endpoint)
printResponse(status, endpoint, result) printResponse(status, endpoint, result)
case "test_all": case "test_all":
import time import time
for endpoint, value in config_mapping.items(): for endpoint, value in mapping.items():
result, status = main.handleConfigRequest(endpoint)
printResponse(status, endpoint, result)
time.sleep(0.1)
for endpoint, value in controller_mapping.items():
printLog("endpoint", endpoint) printLog("endpoint", endpoint)
match endpoint: match endpoint:
case "/controller/callback_messagebox_send": case "/run/send_message_box":
# handleControllerRequest("/controller/callback_enable_translation") # handleRequest("/set/enable_translation")
# handleControllerRequest("/controller/callback_enable_convert_message_to_romaji") # handleRequest("/set/enable_convert_message_to_romaji")
data = {"id":"123456", "message":"テスト"} data = {"id":"123456", "message":"テスト"}
case "/controller/callback_set_translation_engines": case "/set/selected_translator_engines":
data = { data = {
"1":"CTranslate2", "1":"CTranslate2",
"2":"CTranslate2", "2":"CTranslate2",
"3":"CTranslate2", "3":"CTranslate2",
} }
case "/controller/set_your_language_and_country": case "/set/selected_your_languages":
data = { data = {
"1":{ "1":{
"primary":{ "primary":{
@@ -452,7 +456,7 @@ if __name__ == "__main__":
}, },
}, },
} }
case "/controller/set_target_language_and_country": case "/set/selected_target_languages":
data ={ data ={
"1":{ "1":{
"primary": { "primary": {
@@ -497,85 +501,95 @@ if __name__ == "__main__":
}, },
}, },
} }
case "/controller/callback_set_transparency": case "/set/transparency":
data = 0.5 data = 0.5
case "/controller/callback_set_appearance": case "/set/appearance":
data = "Dark" data = "Dark"
case "/controller/callback_set_ui_scaling": case "/set/ui_scaling":
data = 1.5 data = 1.5
case "/controller/callback_set_textbox_ui_scaling": case "/set/textbox_ui_scaling":
data = 1.5 data = 1.5
case "/controller/callback_set_message_box_ratio": case "/set/message_box_ratio":
data = 0.5 data = 0.5
case "/controller/callback_set_font_family": case "/set/font_family":
data = "Yu Gothic UI" data = "Yu Gothic UI"
case "/controller/callback_set_ui_language": case "/set/ui_language":
data = "ja" data = "ja"
case "/controller/callback_set_ctranslate2_weight_type": case "/set/ctranslate2_weight_type":
data = "Small" data = "Small"
case "/controller/callback_set_deepl_auth_key": case "/set/deepl_auth_key":
data = "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee:fx" data = "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee:fx"
case "/controller/callback_set_mic_host": case "/set/selected_mic_host":
data = "MME" data = "MME"
case "/controller/callback_set_mic_device": case "/set/selected_mic_device":
data = "マイク (Realtek High Definition Audio)" data = "マイク (Realtek High Definition Audio)"
case "/controller/callback_set_mic_energy_threshold": case "/set/mic_energy_threshold":
data = 0.5 data = 0.5
case "/controller/callback_set_mic_record_timeout": case "/set/mic_record_timeout":
data = 1
case "/set/mic_phrase_timeout":
data = 5 data = 5
case "/controller/callback_set_mic_phrase_timeout": case "/set/input_set_mic_max_phrases":
data = 5 data = 5
case "/controller/callback_set_mic_max_phrases": case "/set/mic_word_filter":
data = 5
case "/controller/callback_set_mic_word_filter":
data = "test0, test1, test2" data = "test0, test1, test2"
case "/controller/callback_delete_mic_word_filter": case "/del/mic_word_filter":
data = "test1" data = "test1"
case "/controller/callback_set_speaker_device": case "/set/selected_speaker_device":
data = "スピーカー (Realtek High Definition Audio)" data = "スピーカー (Realtek High Definition Audio)"
case "/controller/callback_set_speaker_energy_threshold": case "/set/speaker_energy_threshold":
data = 0.5 data = 0.5
case "/controller/callback_set_speaker_record_timeout": case "/set/speaker_record_timeout":
data = 5 data = 5
case "/controller/callback_set_speaker_phrase_timeout": case "/set/speaker_phrase_timeout":
data = 5 data = 5
case "/controller/callback_set_speaker_max_phrases": case "/set/speaker_max_phrases":
data = 5 data = 5
case "/controller/callback_set_whisper_weight_type": case "/set/whisper_weight_type":
data = "base" data = "base"
case "/controller/callback_set_overlay_settings_opacity": case "/set/overlay_settings":
data = 0.5 data = {
case "/controller/callback_set_overlay_settings_ui_scaling": "opacity": 0.5,
data = 1.5 "ui_scaling": 1.5,
case "/controller/callback_set_overlay_small_log_settings_x_pos": }
data = 0 case "/set/overlay_small_log_settings":
case "/controller/callback_set_overlay_small_log_settings_y_pos": data = {
data = 0 "x_pos": 0,
case "/controller/callback_set_overlay_small_log_settings_z_pos": "y_pos": 0,
data = 0 "z_pos": 0,
case "/controller/callback_set_overlay_small_log_settings_x_rotation": "x_rotation": 0,
data = 0 "y_rotation": 0,
case "/controller/callback_set_overlay_small_log_settings_y_rotation": "z_rotation": 0,
data = 0 "display_duration": 5,
case "/controller/callback_set_overlay_small_log_settings_z_rotation": "fadeout_duration": 0.5,
data = 0 }
case "/controller/callback_set_send_message_button_type": case "/set/send_message_button_type":
data = "show" data = "show"
case "/controller/callback_set_send_message_format": case "/set/send_message_format":
data = "[message]" data = "[message]"
case "/controller/callback_set_send_message_format_with_t": case "/set/send_message_format_with_t":
data = "[message]([translation])" data = "[message]([translation])"
case "/controller/callback_set_received_message_format": case "/set/received_message_format":
data = "[message]" data = "[message]"
case "/controller/callback_set_received_message_format_with_t": case "/set/received_message_format_with_t":
data = "[message]([translation])" data = "[message]([translation])"
case "/controller/callback_set_osc_ip_address": case "/set/osc_ip_address":
data = "127.0.0.1" data = "127.0.0.1"
case "/controller/callback_set_osc_port": case "/set/osc_port":
data = 8000 data = 8000
case "/set/speaker_no_speech_prob":
data = 0.5
case "/set/speaker_avg_logprob":
data = 0.5
case "/set/mic_no_speech_prob":
data = 0.5
case "/set/mic_avg_logprob":
data = 0.5
case "/set/mic_max_phrases":
data = 5
case _: case _:
data = None data = None
result, status = main.handleControllerRequest(endpoint, data) result, status = main.handleRequest(endpoint, data)
printResponse(status, endpoint, result) printResponse(status, endpoint, result)
time.sleep(0.5) time.sleep(0.5)

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);