From d3b66b70004178c6282d1a02ec31dac17a3ae44c Mon Sep 17 00:00:00 2001 From: misyaguziya Date: Fri, 20 Sep 2024 03:00:55 +0900 Subject: [PATCH 1/3] =?UTF-8?q?=F0=9F=91=8D=EF=B8=8F[Update]=20Model:=20en?= =?UTF-8?q?dpoint=E3=82=92get/set/run=E3=81=AE=E5=BD=A2=E3=81=AB=E5=A4=89?= =?UTF-8?q?=E6=9B=B4?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src-python/config.py | 74 +- src-python/model.py | 30 +- src-python/webui_controller.py | 2197 ++++++++++++++++---------------- src-python/webui_mainloop.py | 686 +++++----- 4 files changed, 1521 insertions(+), 1466 deletions(-) diff --git a/src-python/config.py b/src-python/config.py index 576ff20b..1f823e01 100644 --- a/src-python/config.py +++ b/src-python/config.py @@ -240,43 +240,43 @@ class Config: saveJson(self.PATH_CONFIG, inspect.currentframe().f_code.co_name, value) @property - @json_serializable('SELECTED_TAB_YOUR_LANGUAGES') - def SELECTED_TAB_YOUR_LANGUAGES(self): - return self._SELECTED_TAB_YOUR_LANGUAGES + @json_serializable('SELECTED_YOUR_LANGUAGES') + def SELECTED_YOUR_LANGUAGES(self): + return self._SELECTED_YOUR_LANGUAGES - @SELECTED_TAB_YOUR_LANGUAGES.setter - def SELECTED_TAB_YOUR_LANGUAGES(self, value): + @SELECTED_YOUR_LANGUAGES.setter + def SELECTED_YOUR_LANGUAGES(self, value): try: if isinstance(value, dict): - value_old = self.SELECTED_TAB_YOUR_LANGUAGES + value_old = self.SELECTED_YOUR_LANGUAGES for k0, v0 in value.items(): for k1, v1 in v0.items(): language = v1["language"] country = v1["country"] if language not in list(transcription_lang.keys()) or country not in list(transcription_lang[language].keys()): value[k0][k1] = value_old[k0][k1] - self._SELECTED_TAB_YOUR_LANGUAGES = value + self._SELECTED_YOUR_LANGUAGES = value except Exception: pass saveJson(self.PATH_CONFIG, inspect.currentframe().f_code.co_name, value) @property - @json_serializable('SELECTED_TAB_TARGET_LANGUAGES') - def SELECTED_TAB_TARGET_LANGUAGES(self): - return self._SELECTED_TAB_TARGET_LANGUAGES + @json_serializable('SELECTED_TARGET_LANGUAGES') + def SELECTED_TARGET_LANGUAGES(self): + return self._SELECTED_TARGET_LANGUAGES - @SELECTED_TAB_TARGET_LANGUAGES.setter - def SELECTED_TAB_TARGET_LANGUAGES(self, value): + @SELECTED_TARGET_LANGUAGES.setter + def SELECTED_TARGET_LANGUAGES(self, value): try: if isinstance(value, dict): - value_old = self.SELECTED_TAB_TARGET_LANGUAGES + value_old = self.SELECTED_TARGET_LANGUAGES for k0, v0 in value.items(): for k1, v1 in v0.items(): language = v1["language"] country = v1["country"] if language not in list(transcription_lang.keys()) or country not in list(transcription_lang[language].keys()): value[k0][k1] = value_old[k0][k1] - self._SELECTED_TAB_TARGET_LANGUAGES = value + self._SELECTED_TARGET_LANGUAGES = value except Exception: pass saveJson(self.PATH_CONFIG, inspect.currentframe().f_code.co_name, value) @@ -326,14 +326,14 @@ class Config: saveJson(self.PATH_CONFIG, inspect.currentframe().f_code.co_name, value) @property - @json_serializable('IS_MAIN_WINDOW_SIDEBAR_COMPACT_MODE') - def IS_MAIN_WINDOW_SIDEBAR_COMPACT_MODE(self): - return self._IS_MAIN_WINDOW_SIDEBAR_COMPACT_MODE + @json_serializable('ENABLE_MAIN_WINDOW_SIDEBAR_COMPACT_MODE') + def ENABLE_MAIN_WINDOW_SIDEBAR_COMPACT_MODE(self): + return self._ENABLE_MAIN_WINDOW_SIDEBAR_COMPACT_MODE - @IS_MAIN_WINDOW_SIDEBAR_COMPACT_MODE.setter - def IS_MAIN_WINDOW_SIDEBAR_COMPACT_MODE(self, value): + @ENABLE_MAIN_WINDOW_SIDEBAR_COMPACT_MODE.setter + def ENABLE_MAIN_WINDOW_SIDEBAR_COMPACT_MODE(self, value): if isinstance(value, bool): - self._IS_MAIN_WINDOW_SIDEBAR_COMPACT_MODE = value + self._ENABLE_MAIN_WINDOW_SIDEBAR_COMPACT_MODE = value saveJson(self.PATH_CONFIG, inspect.currentframe().f_code.co_name, value) ## Config Window @@ -442,14 +442,14 @@ class Config: saveJson(self.PATH_CONFIG, inspect.currentframe().f_code.co_name, self.MAIN_WINDOW_GEOMETRY) @property - @json_serializable('ENABLE_MIC_AUTOMATIC_SELECTION') - def ENABLE_MIC_AUTOMATIC_SELECTION(self): - return self._ENABLE_MIC_AUTOMATIC_SELECTION + @json_serializable('ENABLE_MIC_AUTO_SELECTION') + def ENABLE_MIC_AUTO_SELECTION(self): + return self._ENABLE_MIC_AUTO_SELECTION - @ENABLE_MIC_AUTOMATIC_SELECTION.setter - def ENABLE_MIC_AUTOMATIC_SELECTION(self, value): + @ENABLE_MIC_AUTO_SELECTION.setter + def ENABLE_MIC_AUTO_SELECTION(self, value): if isinstance(value, bool): - self._ENABLE_MIC_AUTOMATIC_SELECTION = value + self._ENABLE_MIC_AUTO_SELECTION = value saveJson(self.PATH_CONFIG, inspect.currentframe().f_code.co_name, value) @property @@ -563,14 +563,14 @@ class Config: saveJson(self.PATH_CONFIG, inspect.currentframe().f_code.co_name, value) @property - @json_serializable('ENABLE_SPEAKER_AUTOMATIC_SELECTION') - def ENABLE_SPEAKER_AUTOMATIC_SELECTION(self): - return self._ENABLE_SPEAKER_AUTOMATIC_SELECTION + @json_serializable('ENABLE_SPEAKER_AUTO_SELECTION') + def ENABLE_SPEAKER_AUTO_SELECTION(self): + return self._ENABLE_SPEAKER_AUTO_SELECTION - @ENABLE_SPEAKER_AUTOMATIC_SELECTION.setter - def ENABLE_SPEAKER_AUTOMATIC_SELECTION(self, value): + @ENABLE_SPEAKER_AUTO_SELECTION.setter + def ENABLE_SPEAKER_AUTO_SELECTION(self, value): if isinstance(value, bool): - self._ENABLE_SPEAKER_AUTOMATIC_SELECTION = value + self._ENABLE_SPEAKER_AUTO_SELECTION = value saveJson(self.PATH_CONFIG, inspect.currentframe().f_code.co_name, value) @property @@ -1015,7 +1015,7 @@ class Config: "2":"CTranslate2", "3":"CTranslate2", } - self._SELECTED_TAB_YOUR_LANGUAGES = { + self._SELECTED_YOUR_LANGUAGES = { "1":{ "primary":{ "language":"Japanese", @@ -1035,7 +1035,7 @@ class Config: }, }, } - self._SELECTED_TAB_TARGET_LANGUAGES = { + self._SELECTED_TARGET_LANGUAGES = { "1":{ "primary":{ "language":"English", @@ -1083,7 +1083,7 @@ class Config: self._ENABLE_MULTI_LANGUAGE_TRANSLATION = False self._ENABLE_CONVERT_MESSAGE_TO_ROMAJI = False self._ENABLE_CONVERT_MESSAGE_TO_HIRAGANA = False - self._IS_MAIN_WINDOW_SIDEBAR_COMPACT_MODE = False + self._ENABLE_MAIN_WINDOW_SIDEBAR_COMPACT_MODE = False ## Config Window self._TRANSPARENCY = 100 @@ -1100,7 +1100,7 @@ class Config: "width": "870", "height": "654", } - self._ENABLE_MIC_AUTOMATIC_SELECTION = True + self._ENABLE_MIC_AUTO_SELECTION = True self._CHOICE_MIC_HOST = device_manager.getDefaultInputDevice()["host"]["name"] self._CHOICE_MIC_DEVICE = device_manager.getDefaultInputDevice()["device"]["name"] self._INPUT_MIC_ENERGY_THRESHOLD = 300 @@ -1111,7 +1111,7 @@ class Config: self._INPUT_MIC_WORD_FILTER = [] self._INPUT_MIC_AVG_LOGPROB=-0.8 self._INPUT_MIC_NO_SPEECH_PROB=0.6 - self._ENABLE_SPEAKER_AUTOMATIC_SELECTION = True + self._ENABLE_SPEAKER_AUTO_SELECTION = True self._CHOICE_SPEAKER_DEVICE = device_manager.getDefaultOutputDevice()["device"]["name"] self._INPUT_SPEAKER_ENERGY_THRESHOLD = 300 self._INPUT_SPEAKER_DYNAMIC_ENERGY_THRESHOLD = False diff --git a/src-python/model.py b/src-python/model.py index cee10773..116a3a99 100644 --- a/src-python/model.py +++ b/src-python/model.py @@ -214,8 +214,8 @@ class Model: def getInputTranslate(self, message): translator_name=config.SELECTED_TRANSLATOR_ENGINES[config.SELECTED_TAB_NO] - source_language=config.SELECTED_TAB_YOUR_LANGUAGES[config.SELECTED_TAB_NO]["primary"]["language"] - target_languages=config.SELECTED_TAB_TARGET_LANGUAGES[config.SELECTED_TAB_NO] + source_language=config.SELECTED_YOUR_LANGUAGES[config.SELECTED_TAB_NO]["primary"]["language"] + target_languages=config.SELECTED_TARGET_LANGUAGES[config.SELECTED_TAB_NO] translations = [] success_flags = [] @@ -238,9 +238,9 @@ class Model: def getOutputTranslate(self, message): translator_name=config.SELECTED_TRANSLATOR_ENGINES[config.SELECTED_TAB_NO] - source_language=config.SELECTED_TAB_TARGET_LANGUAGES[config.SELECTED_TAB_NO]["primary"]["language"] - target_language=config.SELECTED_TAB_YOUR_LANGUAGES[config.SELECTED_TAB_NO]["primary"]["language"] - target_country=config.SELECTED_TAB_YOUR_LANGUAGES[config.SELECTED_TAB_NO]["primary"]["country"] + source_language=config.SELECTED_TARGET_LANGUAGES[config.SELECTED_TAB_NO]["primary"]["language"] + target_language=config.SELECTED_YOUR_LANGUAGES[config.SELECTED_TAB_NO]["primary"]["language"] + target_country=config.SELECTED_YOUR_LANGUAGES[config.SELECTED_TAB_NO]["primary"]["country"] translation, success_flag = self.getTranslate( translator_name, @@ -424,7 +424,7 @@ class Model: return result def startMicTranscript(self, fnc): - if config.ENABLE_MIC_AUTOMATIC_SELECTION is True: + if config.ENABLE_MIC_AUTO_SELECTION is True: default_device = device_manager.getDefaultInputDevice() mic_host_name = default_device["host"]["name"] mic_device_name = default_device["device"]["name"] @@ -468,8 +468,8 @@ class Model: try: res = self.mic_transcriber.transcribeAudioQueue( self.mic_audio_queue, - config.SELECTED_TAB_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"]["language"], + config.SELECTED_YOUR_LANGUAGES[config.SELECTED_TAB_NO]["primary"]["country"], config.INPUT_MIC_AVG_LOGPROB, config.INPUT_MIC_NO_SPEECH_PROB ) @@ -558,7 +558,7 @@ class Model: if isinstance(fnc, Callable): self.check_mic_energy_fnc = fnc - if config.ENABLE_MIC_AUTOMATIC_SELECTION is True: + if config.ENABLE_MIC_AUTO_SELECTION is True: default_device = device_manager.getDefaultInputDevice() mic_host_name = default_device["host"]["name"] mic_device_name = default_device["device"]["name"] @@ -600,7 +600,7 @@ class Model: self.mic_energy_recorder = None def startSpeakerTranscript(self, fnc): - if config.ENABLE_SPEAKER_AUTOMATIC_SELECTION is True: + if config.ENABLE_SPEAKER_AUTO_SELECTION is True: default_device = device_manager.getDefaultOutputDevice() speaker_device_name = default_device["device"]["name"] else: @@ -641,8 +641,8 @@ class Model: try: res = self.speaker_transcriber.transcribeAudioQueue( speaker_audio_queue, - config.SELECTED_TAB_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"]["language"], + config.SELECTED_TARGET_LANGUAGES[config.SELECTED_TAB_NO]["primary"]["country"], config.INPUT_SPEAKER_AVG_LOGPROB, config.INPUT_SPEAKER_NO_SPEECH_PROB ) @@ -692,7 +692,7 @@ class Model: if isinstance(fnc, Callable): self.check_speaker_energy_fnc = fnc - if config.ENABLE_SPEAKER_AUTOMATIC_SELECTION is True: + if config.ENABLE_SPEAKER_AUTO_SELECTION is True: default_device = device_manager.getDefaultOutputDevice() speaker_device_name = default_device["device"]["name"] else: @@ -732,8 +732,8 @@ class Model: self.speaker_energy_recorder = None def createOverlayImageShort(self, message, translation): - your_language = config.SELECTED_TAB_TARGET_LANGUAGES[config.SELECTED_TAB_NO]["primary"]["language"] - target_language = config.SELECTED_TAB_YOUR_LANGUAGES[config.SELECTED_TAB_NO]["primary"]["language"] + your_language = config.SELECTED_TARGET_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 self.pre_overlay_message = { "message" : message, diff --git a/src-python/webui_controller.py b/src-python/webui_controller.py index ee7b0815..33943c5e 100644 --- a/src-python/webui_controller.py +++ b/src-python/webui_controller.py @@ -8,7 +8,7 @@ from model import model from utils import isUniqueStrings, printLog from models.transcription.transcription_utils import device_manager -# Common +# response functions class DownloadSoftwareProgressBar: def __init__(self, action): self.action = action @@ -35,55 +35,64 @@ class UpdateSoftwareProgressBar: } }) -def callbackUpdateSoftware(data, action, *args, **kwargs) -> dict: - printLog("Update callbackUpdateSoftware") - download = DownloadSoftwareProgressBar(action) - update = UpdateSoftwareProgressBar(action) - model.updateSoftware(restart=True, download=download.set, update=update.set) - return {"status":200, "result":True} +class UpdateSelectedMicDevice: + def __init__(self, action): + self.action = action -def callbackRestartSoftware(*args, **kwargs) -> dict: - printLog("Restart callbackRestartSoftware") - model.reStartSoftware() - return {"status":200, "result":True} + def set(self, host, device) -> None: + config.CHOICE_MIC_HOST = host + config.CHOICE_MIC_DEVICE = device + printLog("Update Host/Mic Device", f"{host}/{device}") + self.action("mic", { + "status":200, + "result":{"host":host, "device":device} + }) -def callbackFilepathLogs(*args, **kwargs) -> dict: - printLog("Open Logs Folder") - Popen(['explorer', config.PATH_LOGS.replace('/', '\\')], shell=True) - return {"status":200, "result":True} +class UpdateSelectedSpeakerDevice: + def __init__(self, action): + self.action = action -def callbackFilepathConfigFile(*args, **kwargs) -> dict: - printLog("Open Config File") - Popen(['explorer', config.PATH_LOCAL.replace('/', '\\')], shell=True) - return {"status":200, "result":True} + def set(self, device) -> None: + config.CHOICE_SPEAKER_DEVICE = device + printLog("Update Speaker Device", device) + self.action("speaker", { + "status":200, + "result":device + }) -# def callbackEnableEasterEgg(): -# printLog("Enable Easter Egg") -# config.IS_EASTER_EGG_ENABLED = True -# config.OVERLAY_UI_TYPE = "sakura" -# return {"status":200, "result":config.IS_EASTER_EGG_ENABLED} +class ProgressBarMicEnergy: + def __init__(self, action): + self.action = action -def messageFormatter(format_type:str, translation:list, message:list): - if format_type == "RECEIVED": - FORMAT_WITH_T = config.RECEIVED_MESSAGE_FORMAT_WITH_T - FORMAT = config.RECEIVED_MESSAGE_FORMAT - elif format_type == "SEND": - FORMAT_WITH_T = config.SEND_MESSAGE_FORMAT_WITH_T - FORMAT = config.SEND_MESSAGE_FORMAT - else: - raise ValueError("format_type is not found", format_type) + def set(self, energy) -> None: + if energy is False: + self.action("error_device", {"status":400,"result": {"message":"No mic device detected."}}) + else: + self.action("mic", {"status":200, "result":energy}) - if len(translation) > 0: - osc_message = FORMAT_WITH_T.replace("[message]", "/".join(message)) - osc_message = osc_message.replace("[translation]", "/".join(translation)) - else: - osc_message = FORMAT.replace("[message]", "/".join(message)) - return osc_message +class ProgressBarSpeakerEnergy: + def __init__(self, action): + self.action = action -def changeToCTranslate2Process(): - config.SELECTED_TRANSLATOR_ENGINES[config.SELECTED_TAB_NO] = "CTranslate2" + def set(self, energy) -> None: + if energy is False: + self.action("error_device", {"status":400,"result": {"message":"No mic device detected."}}) + else: + self.action("speaker", {"status":200, "result":energy}) + +class DownloadWhisperProgressBar: + def __init__(self, action): + self.action = action + + def set(self, progress) -> None: + printLog("Whisper Weight Download Progress", progress) + self.action("download", { + "status":200, + "result":{ + "progress":progress + } + }) -# func transcription send message class MicMessage: def __init__(self, action:Callable[[dict], None]) -> None: self.action = action @@ -124,7 +133,7 @@ class MicMessage: }) if config.ENABLE_CONVERT_MESSAGE_TO_ROMAJI is True or config.ENABLE_CONVERT_MESSAGE_TO_HIRAGANA is True: - if config.SELECTED_TAB_TARGET_LANGUAGES[config.SELECTED_TAB_NO]["primary"]["language"] == "Japanese": + if config.SELECTED_TARGET_LANGUAGES[config.SELECTED_TAB_NO]["primary"]["language"] == "Japanese": transliteration = model.convertMessageToTransliteration(translation[0]) if config.ENABLE_TRANSCRIPTION_SEND is True: @@ -157,42 +166,6 @@ class MicMessage: # overlay_image = model.createOverlayImageLong("send", message, translation) # model.updateOverlay(overlay_image) -def startTranscriptionSendMessage(action:Callable[[dict], None]) -> None: - mic_message = MicMessage(action) - model.startMicTranscript(mic_message.send) - -def stopTranscriptionSendMessage() -> None: - model.stopMicTranscript() - -def startThreadingTranscriptionSendMessage(action:Callable[[dict], None]) -> None: - th_startTranscriptionSendMessage = Thread(target=startTranscriptionSendMessage, args=(action,)) - th_startTranscriptionSendMessage.daemon = True - th_startTranscriptionSendMessage.start() - -def stopThreadingTranscriptionSendMessage() -> None: - th_stopTranscriptionSendMessage = Thread(target=stopTranscriptionSendMessage) - th_stopTranscriptionSendMessage.daemon = True - th_stopTranscriptionSendMessage.start() - th_stopTranscriptionSendMessage.join() - -def startTranscriptionSendMessageOnCloseConfigWindow(action:Callable[[dict], None]) -> None: - mic_message = MicMessage(action) - model.startMicTranscript(mic_message.send) - -def stopTranscriptionSendMessageOnOpenConfigWindow(): - model.stopMicTranscript() - -def startThreadingTranscriptionSendMessageOnCloseConfigWindow(action:Callable[[dict], None]) -> None: - th_startTranscriptionSendMessage = Thread(target=startTranscriptionSendMessageOnCloseConfigWindow, args=(action,)) - th_startTranscriptionSendMessage.daemon = True - th_startTranscriptionSendMessage.start() - -def stopThreadingTranscriptionSendMessageOnOpenConfigWindow() -> None: - th_stopTranscriptionSendMessage = Thread(target=stopTranscriptionSendMessageOnOpenConfigWindow) - th_stopTranscriptionSendMessage.daemon = True - th_stopTranscriptionSendMessage.start() - -# func transcription receive message class SpeakerMessage: def __init__(self, action:Callable[[dict], None]) -> None: self.action = action @@ -224,7 +197,7 @@ class SpeakerMessage: }) if config.ENABLE_CONVERT_MESSAGE_TO_ROMAJI is True or config.ENABLE_CONVERT_MESSAGE_TO_HIRAGANA is True: - if config.SELECTED_TAB_TARGET_LANGUAGES[config.SELECTED_TAB_NO]["primary"]["language"] == "Japanese": + if config.SELECTED_TARGET_LANGUAGES[config.SELECTED_TAB_NO]["primary"]["language"] == "Japanese": transliteration = model.convertMessageToTransliteration(message) if config.ENABLE_TRANSCRIPTION_RECEIVE is True: @@ -257,6 +230,1068 @@ class SpeakerMessage: translation = " (" + "/".join(translation) + ")" model.logger.info(f"[RECEIVED] {message}{translation}") +class ChatMessage: + def __init__(self, action:Callable[[dict], None]) -> None: + self.action = action + + def send(self, data): + id = data["id"] + message = data["message"] + if len(message) > 0: + # addSentMessageLog(message) + translation = [] + transliteration = [] + if config.ENABLE_TRANSLATION is False: + pass + else: + if config.USE_EXCLUDE_WORDS is True: + replacement_message, replacement_dict = replaceExclamationsWithRandom(message) + translation, success = model.getInputTranslate(replacement_message) + + message = removeExclamations(message) + for i in range(len(translation)): + translation[i] = restoreText(translation[i], replacement_dict) + else: + translation, success = model.getInputTranslate(message) + + if all(success) is not True: + changeToCTranslate2Process() + self.action("error_translation_engine", { + "status":400, + "result":{ + "message":"translation engine limit error" + } + }) + + if config.ENABLE_CONVERT_MESSAGE_TO_ROMAJI is True or config.ENABLE_CONVERT_MESSAGE_TO_HIRAGANA is True: + if config.SELECTED_TARGET_LANGUAGES[config.SELECTED_TAB_NO]["primary"]["language"] == "Japanese": + transliteration = model.convertMessageToTransliteration(translation[0]) + + # send OSC message + if config.ENABLE_SEND_MESSAGE_TO_VRC is True: + if config.ENABLE_SEND_ONLY_TRANSLATED_MESSAGES is True: + if config.ENABLE_TRANSLATION is False: + osc_message = messageFormatter("SEND", "", [message]) + else: + osc_message = messageFormatter("SEND", "", translation) + else: + osc_message = messageFormatter("SEND", translation, [message]) + model.oscSendMessage(osc_message) + + # if config.ENABLE_OVERLAY_SMALL_LOG is True: + # overlay_image = model.createOverlayImageShort(message, translation) + # model.updateOverlay(overlay_image) + # overlay_image = model.createOverlayImageLong("send", message, translation) + # model.updateOverlay(overlay_image) + + # update textbox message log (Sent) + if config.ENABLE_LOGGER is True: + if len(translation) > 0: + translation_text = " (" + "/".join(translation) + ")" + model.logger.info(f"[SENT] {message}{translation_text}") + + return {"status":200, + "result":{ + "id":id, + "message":message, + "translation":translation, + "transliteration":transliteration, + }, + } + +class DownloadCTranslate2ProgressBar: + def __init__(self, action): + self.action = action + + def set(self, progress) -> None: + printLog("CTranslate2 Weight Download Progress", progress) + self.action("download", { + "status":200, + "result":{ + "progress":progress + } + }) + +# getter/setter functions + +def getVersion(*args, **kwargs) -> dict: + return {"status":200, "result":config.VERSION} + +def getTransparencyRange(*args, **kwargs) -> dict: + return {"status":200, "result":config.TRANSPARENCY_RANGE} + +def getAppearanceThemesList(*args, **kwargs) -> dict: + return {"status":200, "result":config.APPEARANCE_THEME_LIST} + +def getUiScalingList(*args, **kwargs) -> dict: + return {"status":200, "result":config.UI_SCALING_LIST} + +def getTextboxUiScalingRange(*args, **kwargs) -> dict: + return {"status":200, "result":config.TEXTBOX_UI_SCALING_RANGE} + +def getMessageBoxRatioRange(*args, **kwargs) -> dict: + return {"status":200, "result":config.MESSAGE_BOX_RATIO_RANGE} + +def getSelectableCtranslate2WeightTypeDict(*args, **kwargs) -> dict: + return {"status":200, "result":config.SELECTABLE_CTRANSLATE2_WEIGHT_TYPE_DICT} + +def getSelectableWhisperModelTypeDict(*args, **kwargs) -> dict: + return {"status":200, "result":config.SELECTABLE_WHISPER_WEIGHT_TYPE_DICT} + +def getMaxMicEnergyThreshold(*args, **kwargs) -> dict: + return {"status":200, "result":config.MAX_MIC_ENERGY_THRESHOLD} + +def getMaxSpeakerEnergyThreshold(*args, **kwargs) -> dict: + return {"status":200, "result":config.MAX_SPEAKER_ENERGY_THRESHOLD} + +def setEnableTranslation(*args, **kwargs) -> dict: + config.ENABLE_TRANSLATION = True + if model.isLoadedCTranslate2Model() is False: + model.changeTranslatorCTranslate2Model() + return {"status":200, "result":config.ENABLE_TRANSLATION} + +def setDisableTranslation(*args, **kwargs) -> dict: + config.ENABLE_TRANSLATION = False + return {"status":200, "result":config.ENABLE_TRANSLATION} + +def setEnableForeground(*args, **kwargs) -> dict: + config.ENABLE_FOREGROUND = True + return {"status":200, "result":config.ENABLE_FOREGROUND} + +def setDisableForeground(*args, **kwargs) -> dict: + config.ENABLE_FOREGROUND = False + return {"status":200, "result":config.ENABLE_FOREGROUND} + +def setEnableConfigWindow(*args, **kwargs) -> dict: + if config.ENABLE_TRANSCRIPTION_SEND is True: + stopThreadingTranscriptionSendMessageOnOpenConfigWindow() + if config.ENABLE_TRANSCRIPTION_RECEIVE is True: + stopThreadingTranscriptionReceiveMessageOnOpenConfigWindow() + return {"status":200, "result":True} + +def setDisableConfigWindow(data, action, *args, **kwargs) -> dict: + model.stopCheckMicEnergy() + model.stopCheckSpeakerEnergy() + + if config.ENABLE_TRANSCRIPTION_SEND is True: + startThreadingTranscriptionSendMessageOnCloseConfigWindow(action) + if config.ENABLE_TRANSCRIPTION_RECEIVE is True: + sleep(2) + if config.ENABLE_TRANSCRIPTION_RECEIVE is True: + startThreadingTranscriptionReceiveMessageOnCloseConfigWindow(action) + return {"status":200, "result":True} + +def getSelectedTabNo(*args, **kwargs) -> dict: + return {"status":200, "result":config.SELECTED_TAB_NO} + +def setSelectedTabNo(selected_tab_no:str, *args, **kwargs) -> dict: + printLog("setSelectedTabNo", selected_tab_no) + config.SELECTED_TAB_NO = selected_tab_no + updateTranslationEngineAndEngineList() + return {"status":200, "result":config.SELECTED_TAB_NO} + +def getTranslationEngines(*args, **kwargs) -> dict: + engines = model.findTranslationEngines( + config.SELECTED_YOUR_LANGUAGES[config.SELECTED_TAB_NO], + config.SELECTED_TARGET_LANGUAGES[config.SELECTED_TAB_NO], + config.ENABLE_MULTI_LANGUAGE_TRANSLATION, + ) + return {"status":200, "result":engines} + +def getListLanguageAndCountry(*args, **kwargs) -> dict: + return {"status":200, "result": model.getListLanguageAndCountry()} + +def getListInputHost(*args, **kwargs) -> dict: + return {"status":200, "result": model.getListInputHost()} + +def getListInputDevice(*args, **kwargs) -> dict: + return {"status":200, "result": model.getListInputDevice()} + +def getListOutputDevice(*args, **kwargs) -> dict: + return {"status":200, "result": model.getListOutputDevice()} + +def getSelectedTranslatorEngines(*args, **kwargs) -> dict: + return {"status":200, "result":config.SELECTED_TRANSLATOR_ENGINES} + +def setSelectedTranslatorEngines(engines:dict, *args, **kwargs) -> dict: + printLog("setSelectedTranslatorEngines", engines) + config.SELECTED_TRANSLATOR_ENGINES = engines + return {"status":200,"result":config.SELECTED_TRANSLATOR_ENGINES} + +def getSelectedYourLanguages(*args, **kwargs) -> dict: + return {"status":200, "result":config.SELECTED_YOUR_LANGUAGES} + +def setSelectedYourLanguages(select:dict, *args, **kwargs) -> dict: + config.SELECTED_YOUR_LANGUAGES = select + updateTranslationEngineAndEngineList() + return {"status":200, "result":config.SELECTED_YOUR_LANGUAGES} + +def getSelectedTargetLanguages(*args, **kwargs) -> dict: + return {"status":200, "result":config.SELECTED_TARGET_LANGUAGES} + +def setSelectedTargetLanguages(select:dict, *args, **kwargs) -> dict: + config.SELECTED_TARGET_LANGUAGES = select + updateTranslationEngineAndEngineList() + return {"status":200, "result":config.SELECTED_TARGET_LANGUAGES} + +def getSelectedTranscriptionEngine(*args, **kwargs) -> dict: + return {"status":200, "result":config.SELECTED_TRANSCRIPTION_ENGINE} + +def getEnableMultiLanguageTranslation(*args, **kwargs) -> dict: + return {"status":200, "result":config.ENABLE_MULTI_LANGUAGE_TRANSLATION} + +def setEnableMultiLanguageTranslation(*args, **kwargs) -> dict: + config.ENABLE_MULTI_LANGUAGE_TRANSLATION = True + return {"status":200, "result":config.ENABLE_MULTI_LANGUAGE_TRANSLATION} + +def setDisableMultiLanguageTranslation(*args, **kwargs) -> dict: + config.ENABLE_MULTI_LANGUAGE_TRANSLATION = False + return {"status":200, "result":config.ENABLE_MULTI_LANGUAGE_TRANSLATION} + +def getEnableConvertMessageToRomaji(*args, **kwargs) -> dict: + return {"status":200, "result":config.ENABLE_CONVERT_MESSAGE_TO_ROMAJI} + +def setEnableConvertMessageToRomaji(*args, **kwargs) -> dict: + config.ENABLE_CONVERT_MESSAGE_TO_ROMAJI = True + return {"status":200, "result":config.ENABLE_CONVERT_MESSAGE_TO_ROMAJI} + +def setDisableConvertMessageToRomaji(*args, **kwargs) -> dict: + config.ENABLE_CONVERT_MESSAGE_TO_ROMAJI = False + return {"status":200, "result":config.ENABLE_CONVERT_MESSAGE_TO_ROMAJI} + +def getEnableConvertMessageToHiragana(*args, **kwargs) -> dict: + return {"status":200, "result":config.ENABLE_CONVERT_MESSAGE_TO_HIRAGANA} + +def setEnableConvertMessageToHiragana(*args, **kwargs) -> dict: + config.ENABLE_CONVERT_MESSAGE_TO_HIRAGANA = True + return {"status":200, "result":config.ENABLE_CONVERT_MESSAGE_TO_HIRAGANA} + +def setDisableConvertMessageToHiragana(*args, **kwargs) -> dict: + config.ENABLE_CONVERT_MESSAGE_TO_HIRAGANA = False + return {"status":200, "result":config.ENABLE_CONVERT_MESSAGE_TO_HIRAGANA} + +def getEnableMainWindowSidebarCompactMode(*args, **kwargs) -> dict: + return {"status":200, "result":config.ENABLE_MAIN_WINDOW_SIDEBAR_COMPACT_MODE} + +def setEnableMainWindowSidebarCompactMode(*args, **kwargs) -> dict: + config.ENABLE_MAIN_WINDOW_SIDEBAR_COMPACT_MODE = True + return {"status":200, "result":config.ENABLE_MAIN_WINDOW_SIDEBAR_COMPACT_MODE} + +def setDisableMainWindowSidebarCompactMode(*args, **kwargs) -> dict: + config.ENABLE_MAIN_WINDOW_SIDEBAR_COMPACT_MODE = False + return {"status":200, "result":config.ENABLE_MAIN_WINDOW_SIDEBAR_COMPACT_MODE} + +def getTransparency(*args, **kwargs) -> dict: + return {"status":200, "result":config.TRANSPARENCY} + +def setTransparency(data, *args, **kwargs) -> dict: + config.TRANSPARENCY = int(data) + return {"status":200, "result":config.TRANSPARENCY} + +def getAppearanceTheme(*args, **kwargs) -> dict: + return {"status":200, "result":config.APPEARANCE_THEME} + +def setAppearanceTheme(data, *args, **kwargs) -> dict: + config.APPEARANCE_THEME = data + return {"status":200, "result":config.APPEARANCE_THEME} + +def getUiScaling(*args, **kwargs) -> dict: + return {"status":200, "result":config.UI_SCALING} + +def setUiScaling(data, *args, **kwargs) -> dict: + config.UI_SCALING = data + return {"status":200, "result":config.UI_SCALING} + +def getTextboxUiScaling(*args, **kwargs) -> dict: + return {"status":200, "result":config.TEXTBOX_UI_SCALING} + +def setTextboxUiScaling(data, *args, **kwargs) -> dict: + config.TEXTBOX_UI_SCALING = int(data) + return {"status":200, "result":config.TEXTBOX_UI_SCALING} + +def getMessageBoxRatio(*args, **kwargs) -> dict: + return {"status":200, "result":config.MESSAGE_BOX_RATIO} + +def setMessageBoxRatio(data, *args, **kwargs) -> dict: + config.MESSAGE_BOX_RATIO = int(data) + return {"status":200, "result":config.MESSAGE_BOX_RATIO} + +def getFontFamily(*args, **kwargs) -> dict: + return {"status":200, "result":config.FONT_FAMILY} + +def setFontFamily(data, *args, **kwargs) -> dict: + config.FONT_FAMILY = data + return {"status":200, "result":config.FONT_FAMILY} + +def getUiLanguage(*args, **kwargs) -> dict: + return {"status":200, "result":config.UI_LANGUAGE} + +def setUiLanguage(data, *args, **kwargs) -> dict: + config.UI_LANGUAGE = data + return {"status":200, "result":config.UI_LANGUAGE} + +def getEnableRestoreMainWindowGeometry(*args, **kwargs) -> dict: + return {"status":200, "result":config.ENABLE_RESTORE_MAIN_WINDOW_GEOMETRY} + +def setEnableRestoreMainWindowGeometry(*args, **kwargs) -> dict: + config.ENABLE_RESTORE_MAIN_WINDOW_GEOMETRY = True + return {"status":200, "result":config.ENABLE_RESTORE_MAIN_WINDOW_GEOMETRY} + +def setDisableRestoreMainWindowGeometry(*args, **kwargs) -> dict: + config.ENABLE_RESTORE_MAIN_WINDOW_GEOMETRY = False + return {"status":200, "result":config.ENABLE_RESTORE_MAIN_WINDOW_GEOMETRY} + +def getMainWindowGeometry(*args, **kwargs) -> dict: + return {"status":200, "result":config.MAIN_WINDOW_GEOMETRY} + +def setMainWindowGeometry(data, *args, **kwargs) -> dict: + config.MAIN_WINDOW_GEOMETRY = data + return {"status":200, "result":config.MAIN_WINDOW_GEOMETRY} + +def getEnableMicAutoSelection(*args, **kwargs) -> dict: + return {"status":200, "result":config.ENABLE_MIC_AUTO_SELECTION} + +def setEnableMicAutoSelection(data, action, *args, **kwargs) -> dict: + update_device = UpdateSelectedMicDevice(action) + device_manager.setCallbackDefaultInputDevice(update_device.set) + config.ENABLE_MIC_AUTO_SELECTION = True + return {"status":200, "result":config.ENABLE_MIC_AUTO_SELECTION} + +def setDisableMicAutoSelection(*args, **kwargs) -> dict: + device_manager.clearCallbackDefaultInputDevice() + config.ENABLE_MIC_AUTO_SELECTION = False + return {"status":200, "result":config.ENABLE_MIC_AUTO_SELECTION} + +def getChoiceMicHost(*args, **kwargs) -> dict: + return {"status":200, "result":config.CHOICE_MIC_HOST} + +def setChoiceMicHost(data, *args, **kwargs) -> dict: + config.CHOICE_MIC_HOST = data + config.CHOICE_MIC_DEVICE = model.getInputDefaultDevice() + if config.ENABLE_CHECK_ENERGY_SEND is True: + model.stopCheckMicEnergy() + model.startCheckMicEnergy() + return {"status":200, + "result":{ + "host":config.CHOICE_MIC_HOST, + "device":config.CHOICE_MIC_DEVICE, + }, + } + +def getChoiceMicDevice(*args, **kwargs) -> dict: + return {"status":200, "result":config.CHOICE_MIC_DEVICE} + +def setChoiceMicDevice(data, *args, **kwargs) -> dict: + config.CHOICE_MIC_DEVICE = data + if config.ENABLE_CHECK_ENERGY_SEND is True: + model.stopCheckMicEnergy() + model.startCheckMicEnergy() + return {"status":200, "result": config.CHOICE_MIC_DEVICE} + +def getInputMicEnergyThreshold(*args, **kwargs) -> dict: + return {"status":200, "result":config.INPUT_MIC_ENERGY_THRESHOLD} + +def setInputMicEnergyThreshold(data, *args, **kwargs) -> dict: + status = 400 + data = int(data) + if 0 <= data <= config.MAX_MIC_ENERGY_THRESHOLD: + config.INPUT_MIC_ENERGY_THRESHOLD = data + status = 200 + return {"status": status, "result": config.INPUT_MIC_ENERGY_THRESHOLD} + +def getInputMicDynamicEnergyThreshold(*args, **kwargs) -> dict: + return {"status":200, "result":config.INPUT_MIC_DYNAMIC_ENERGY_THRESHOLD} + +def setEnableInputMicDynamicEnergyThreshold(*args, **kwargs) -> dict: + config.INPUT_MIC_DYNAMIC_ENERGY_THRESHOLD = True + return {"status":200, "result":config.INPUT_MIC_DYNAMIC_ENERGY_THRESHOLD} + +def setDisableInputMicDynamicEnergyThreshold(*args, **kwargs) -> dict: + config.INPUT_MIC_DYNAMIC_ENERGY_THRESHOLD = False + return {"status":200, "result":config.INPUT_MIC_DYNAMIC_ENERGY_THRESHOLD} + +def getInputMicRecordTimeout(*args, **kwargs) -> dict: + return {"status":200, "result":config.INPUT_MIC_RECORD_TIMEOUT} + +def setInputMicRecordTimeout(data, *args, **kwargs) -> dict: + printLog("Set Mic Record Timeout", data) + try: + data = int(data) + if 0 <= data <= config.INPUT_MIC_PHRASE_TIMEOUT: + config.INPUT_MIC_RECORD_TIMEOUT = data + else: + raise ValueError() + except Exception: + response = {"status":400, "result":{"message":"Error Mic Record Timeout"}} + else: + response = {"status":200, "result":config.INPUT_MIC_RECORD_TIMEOUT} + return response + +def getInputMicPhraseTimeout(*args, **kwargs) -> dict: + return {"status":200, "result":config.INPUT_MIC_PHRASE_TIMEOUT} + +def setInputMicPhraseTimeout(data, *args, **kwargs) -> dict: + printLog("Set Mic Phrase Timeout", data) + try: + data = int(data) + if data >= config.INPUT_MIC_RECORD_TIMEOUT: + config.INPUT_MIC_PHRASE_TIMEOUT = data + else: + raise ValueError() + except Exception: + response = {"status":400, "result":{"message":"Error Mic Phrase Timeout"}} + else: + response = {"status":200, "result":config.INPUT_MIC_PHRASE_TIMEOUT} + return response + +def getInputMicMaxPhrases(*args, **kwargs) -> dict: + return {"status":200, "result":config.INPUT_MIC_MAX_PHRASES} + +def setInputMicMaxPhrases(data, *args, **kwargs) -> dict: + try: + data = int(data) + if 0 <= data: + config.INPUT_MIC_MAX_PHRASES = data + else: + raise ValueError() + except Exception: + response = {"status":400, "result":{"message":"Error Mic Max Phrases"}} + else: + response = {"status":200, "result":config.INPUT_MIC_MAX_PHRASES} + return response + +def getInputMicWordFilter(*args, **kwargs) -> dict: + return {"status":200, "result":config.INPUT_MIC_WORD_FILTER} + +def setInputMicWordFilter(data, *args, **kwargs) -> dict: + data = str(data) + data = [w.strip() for w in data.split(",") if len(w.strip()) > 0] + # Copy the list + new_input_mic_word_filter_list = config.INPUT_MIC_WORD_FILTER + new_added_value = [] + for value in data: + if value in new_input_mic_word_filter_list: + # If the value is already in the list, do nothing. + pass + else: + new_input_mic_word_filter_list.append(value) + new_added_value.append(value) + config.INPUT_MIC_WORD_FILTER = new_input_mic_word_filter_list + + model.resetKeywordProcessor() + model.addKeywords() + return {"status":200, "result":config.INPUT_MIC_WORD_FILTER} + +def delInputMicWordFilter(data, *args, **kwargs) -> dict: + try: + new_input_mic_word_filter_list = config.INPUT_MIC_WORD_FILTER + new_input_mic_word_filter_list.remove(str(data)) + config.INPUT_MIC_WORD_FILTER = new_input_mic_word_filter_list + model.resetKeywordProcessor() + model.addKeywords() + except Exception: + printLog("Delete Mic Word Filter", "There was no the target word in config.INPUT_MIC_WORD_FILTER") + return {"status":200, "result":config.INPUT_MIC_WORD_FILTER} + +def getInputMicAvgLogprob(*args, **kwargs) -> dict: + return {"status":200, "result":config.INPUT_MIC_AVG_LOGPROB} + +def setInputMicAvgLogprob(data, *args, **kwargs) -> dict: + config.INPUT_MIC_AVG_LOGPROB = float(data) + return {"status":200, "result":config.INPUT_MIC_AVG_LOGPROB} + +def getInputMicNoSpeechProb(*args, **kwargs) -> dict: + return {"status":200, "result":config.INPUT_MIC_NO_SPEECH_PROB} + +def setInputMicNoSpeechProb(data, *args, **kwargs) -> dict: + config.INPUT_MIC_NO_SPEECH_PROB = float(data) + return {"status":200, "result":config.INPUT_MIC_NO_SPEECH_PROB} + +def getEnableSpeakerAutoSelection(*args, **kwargs) -> dict: + return {"status":200, "result":config.ENABLE_SPEAKER_AUTO_SELECTION} + +def setEnableSpeakerAutoSelection(data, action, *args, **kwargs) -> dict: + update_device = UpdateSelectedSpeakerDevice(action) + device_manager.setCallbackDefaultOutputDevice(update_device.set) + config.ENABLE_SPEAKER_AUTO_SELECTION = True + return {"status":200, "result":config.ENABLE_SPEAKER_AUTO_SELECTION} + +def setDisableSpeakerAutoSelection(*args, **kwargs) -> dict: + device_manager.clearCallbackDefaultInputDevice() + config.ENABLE_SPEAKER_AUTO_SELECTION = False + return {"status":200, "result":config.ENABLE_SPEAKER_AUTO_SELECTION} + +def getChoiceSpeakerDevice(*args, **kwargs) -> dict: + return {"status":200, "result":config.CHOICE_SPEAKER_DEVICE} + +def setChoiceSpeakerDevice(data, *args, **kwargs) -> dict: + config.CHOICE_SPEAKER_DEVICE = data + if config.ENABLE_CHECK_ENERGY_RECEIVE is True: + model.stopCheckSpeakerEnergy() + model.startCheckSpeakerEnergy() + return {"status":200, "result":config.CHOICE_SPEAKER_DEVICE} + +def getInputSpeakerEnergyThreshold(*args, **kwargs) -> dict: + return {"status":200, "result":config.INPUT_SPEAKER_ENERGY_THRESHOLD} + +def setInputSpeakerEnergyThreshold(data, *args, **kwargs) -> dict: + printLog("Set Speaker Energy Threshold", data) + try: + data = int(data) + if 0 <= data <= config.MAX_SPEAKER_ENERGY_THRESHOLD: + config.INPUT_SPEAKER_ENERGY_THRESHOLD = data + else: + raise ValueError() + except Exception: + response = {"status":400, "result":{"message":"Error Set Speaker Energy Threshold"}} + else: + response = {"status":200, "result":config.INPUT_SPEAKER_ENERGY_THRESHOLD} + return response + +def getInputSpeakerDynamicEnergyThreshold(*args, **kwargs) -> dict: + return {"status":200, "result":config.INPUT_SPEAKER_DYNAMIC_ENERGY_THRESHOLD} + +def setEnableInputSpeakerDynamicEnergyThreshold(*args, **kwargs) -> dict: + config.INPUT_SPEAKER_DYNAMIC_ENERGY_THRESHOLD = True + return {"status":200, "result":config.INPUT_SPEAKER_DYNAMIC_ENERGY_THRESHOLD} + +def setDisableInputSpeakerDynamicEnergyThreshold(*args, **kwargs) -> dict: + config.INPUT_SPEAKER_DYNAMIC_ENERGY_THRESHOLD = False + return {"status":200, "result":config.INPUT_SPEAKER_DYNAMIC_ENERGY_THRESHOLD} + +def getInputSpeakerRecordTimeout(*args, **kwargs) -> dict: + return {"status":200, "result":config.INPUT_SPEAKER_RECORD_TIMEOUT} + +def setInputSpeakerRecordTimeout(data, *args, **kwargs) -> dict: + try: + data = int(data) + if 0 <= data <= config.INPUT_SPEAKER_PHRASE_TIMEOUT: + config.INPUT_SPEAKER_RECORD_TIMEOUT = data + else: + raise ValueError() + except Exception: + response = {"status":400, "result":{"message":"Error Speaker Record Timeout"}} + else: + response = {"status":200, "result":config.INPUT_SPEAKER_RECORD_TIMEOUT} + return response + +def getInputSpeakerPhraseTimeout(*args, **kwargs) -> dict: + return {"status":200, "result":config.INPUT_SPEAKER_PHRASE_TIMEOUT} + +def setInputSpeakerPhraseTimeout(data, *args, **kwargs) -> dict: + try: + data = int(data) + if 0 <= data and data >= config.INPUT_SPEAKER_RECORD_TIMEOUT: + config.INPUT_SPEAKER_PHRASE_TIMEOUT = data + else: + raise ValueError() + except Exception: + response = {"status":400, "result":{"message":"Error Speaker Phrase Timeout"}} + else: + response = {"status":200, "result":config.INPUT_SPEAKER_PHRASE_TIMEOUT} + return response + +def getInputSpeakerMaxPhrases(*args, **kwargs) -> dict: + return {"status":200, "result":config.INPUT_SPEAKER_MAX_PHRASES} + +def setInputSpeakerMaxPhrases(data, *args, **kwargs) -> dict: + printLog("Set Speaker Max Phrases", data) + try: + data = int(data) + if 0 <= data: + config.INPUT_SPEAKER_MAX_PHRASES = data + else: + raise ValueError() + except Exception: + response = {"status":400, "result":{"message":"Error Speaker Max Phrases"}} + else: + response = {"status":200, "result":config.INPUT_SPEAKER_MAX_PHRASES} + return response + +def getInputSpeakerAvgLogprob(*args, **kwargs) -> dict: + return {"status":200, "result":config.INPUT_SPEAKER_AVG_LOGPROB} + +def setInputSpeakerAvgLogprob(data, *args, **kwargs) -> dict: + config.INPUT_SPEAKER_AVG_LOGPROB = float(data) + return {"status":200, "result":config.INPUT_SPEAKER_AVG_LOGPROB} + +def getInputSpeakerNoSpeechProb(*args, **kwargs) -> dict: + return {"status":200, "result":config.INPUT_SPEAKER_NO_SPEECH_PROB} + +def setInputSpeakerNoSpeechProb(data, *args, **kwargs) -> dict: + config.INPUT_SPEAKER_NO_SPEECH_PROB = float(data) + return {"status":200, "result":config.INPUT_SPEAKER_NO_SPEECH_PROB} + +def getOscIpAddress(*args, **kwargs) -> dict: + return {"status":200, "result":config.OSC_IP_ADDRESS} + +def setOscIpAddress(data, *args, **kwargs) -> dict: + config.OSC_IP_ADDRESS = data + return {"status":200, "result":config.OSC_IP_ADDRESS} + +def getOscPort(*args, **kwargs) -> dict: + return {"status":200, "result":config.OSC_PORT} + +def setOscPort(data, *args, **kwargs) -> dict: + config.OSC_PORT = int(data) + return {"status":200, "result":config.OSC_PORT} + +def getDeepLAuthKey(*args, **kwargs) -> dict: + return {"status":200, "result":config.AUTH_KEYS["DeepL_API"]} + +def setDeeplAuthKey(data, *args, **kwargs) -> dict: + printLog("Set DeepL Auth Key", data) + status = 400 + if len(data) == 36 or len(data) == 39: + result = model.authenticationTranslatorDeepLAuthKey(auth_key=data) + if result is True: + key = data + status = 200 + else: + key = None + auth_keys = config.AUTH_KEYS + auth_keys["DeepL_API"] = key + config.AUTH_KEYS = auth_keys + updateTranslationEngineAndEngineList() + return {"status":status, "result":config.AUTH_KEYS["DeepL_API"]} + +def delDeeplAuthKey(*args, **kwargs) -> dict: + auth_keys = config.AUTH_KEYS + auth_keys["DeepL_API"] = None + config.AUTH_KEYS = auth_keys + updateTranslationEngineAndEngineList() + return {"status":200, "result":config.AUTH_KEYS["DeepL_API"]} + +def getUseTranslationFeature(*args, **kwargs) -> dict: + return {"status":200, "result":config.USE_TRANSLATION_FEATURE} + +def setEnableUseTranslationFeature(*args, **kwargs) -> dict: + config.USE_TRANSLATION_FEATURE = True + if model.checkCTranslatorCTranslate2ModelWeight(): + config.IS_RESET_BUTTON_DISPLAYED_FOR_TRANSLATION = False + def callback(): + model.changeTranslatorCTranslate2Model() + th_callback = Thread(target=callback) + th_callback.daemon = True + th_callback.start() + else: + config.IS_RESET_BUTTON_DISPLAYED_FOR_TRANSLATION = True + return {"status":200, + "result":{ + "feature":config.USE_TRANSLATION_FEATURE, + "reset":config.IS_RESET_BUTTON_DISPLAYED_FOR_TRANSLATION, + }, + } + +def setDisableUseTranslationFeature(*args, **kwargs) -> dict: + config.USE_TRANSLATION_FEATURE = False + config.IS_RESET_BUTTON_DISPLAYED_FOR_TRANSLATION = False + return {"status":200, + "result":{ + "feature":config.USE_TRANSLATION_FEATURE, + "reset":config.IS_RESET_BUTTON_DISPLAYED_FOR_TRANSLATION, + }, + } + +def getUseWhisperFeature(*args, **kwargs) -> dict: + return {"status":200, "result":config.USE_WHISPER_FEATURE} + +def setEnableUseWhisperFeature(*args, **kwargs) -> dict: + config.USE_WHISPER_FEATURE = True + if model.checkTranscriptionWhisperModelWeight() is True: + config.IS_RESET_BUTTON_DISPLAYED_FOR_WHISPER = False + config.SELECTED_TRANSCRIPTION_ENGINE = "Whisper" + else: + config.IS_RESET_BUTTON_DISPLAYED_FOR_WHISPER = True + config.SELECTED_TRANSCRIPTION_ENGINE = "Google" + return {"status":200, + "result":{ + "feature":config.USE_WHISPER_FEATURE, + "transcription_engine":config.SELECTED_TRANSCRIPTION_ENGINE, + "reset":config.IS_RESET_BUTTON_DISPLAYED_FOR_WHISPER, + }, + } + +def setDisableUseWhisperFeature(*args, **kwargs) -> dict: + config.USE_WHISPER_FEATURE = False + config.IS_RESET_BUTTON_DISPLAYED_FOR_WHISPER = False + config.SELECTED_TRANSCRIPTION_ENGINE = "Google" + return {"status":200, + "result":{ + "feature":config.USE_WHISPER_FEATURE, + "transcription_engine":config.SELECTED_TRANSCRIPTION_ENGINE, + "reset":config.IS_RESET_BUTTON_DISPLAYED_FOR_WHISPER, + }, + } + +def getCtranslate2WeightType(*args, **kwargs) -> dict: + return {"status":200, "result":config.CTRANSLATE2_WEIGHT_TYPE} + +def setCtranslate2WeightType(data, *args, **kwargs) -> dict: + config.CTRANSLATE2_WEIGHT_TYPE = str(data) + if model.checkCTranslatorCTranslate2ModelWeight(): + config.IS_RESET_BUTTON_DISPLAYED_FOR_TRANSLATION = False + def callback(): + model.changeTranslatorCTranslate2Model() + th_callback = Thread(target=callback) + th_callback.daemon = True + th_callback.start() + else: + config.IS_RESET_BUTTON_DISPLAYED_FOR_TRANSLATION = True + return {"status":200, + "result":{ + "feature":config.CTRANSLATE2_WEIGHT_TYPE, + "reset":config.IS_RESET_BUTTON_DISPLAYED_FOR_TRANSLATION, + }, + } + +def getWhisperWeightType(*args, **kwargs) -> dict: + return {"status":200, "result":config.WHISPER_WEIGHT_TYPE} + +def setWhisperWeightType(data, *args, **kwargs) -> dict: + config.WHISPER_WEIGHT_TYPE = str(data) + if model.checkTranscriptionWhisperModelWeight() is True: + config.IS_RESET_BUTTON_DISPLAYED_FOR_WHISPER = False + config.SELECTED_TRANSCRIPTION_ENGINE = "Whisper" + else: + config.IS_RESET_BUTTON_DISPLAYED_FOR_WHISPER = True + config.SELECTED_TRANSCRIPTION_ENGINE = "Google" + return {"status":200, + "result":{ + "weight_type":config.WHISPER_WEIGHT_TYPE, + "transcription_engine":config.SELECTED_TRANSCRIPTION_ENGINE, + "reset":config.IS_RESET_BUTTON_DISPLAYED_FOR_WHISPER, + } + } + +def getEnableAutoClearMessageBox(*args, **kwargs) -> dict: + return {"status":200, "result":config.ENABLE_AUTO_CLEAR_MESSAGE_BOX} + +def setEnableAutoClearMessageBox(*args, **kwargs) -> dict: + config.ENABLE_AUTO_CLEAR_MESSAGE_BOX = True + return {"status":200, "result":config.ENABLE_AUTO_CLEAR_MESSAGE_BOX} + +def setDisableAutoClearMessageBox(*args, **kwargs) -> dict: + config.ENABLE_AUTO_CLEAR_MESSAGE_BOX = False + return {"status":200, "result":config.ENABLE_AUTO_CLEAR_MESSAGE_BOX} + +def getEnableSendOnlyTranslatedMessages(*args, **kwargs) -> dict: + return {"status":200, "result":config.ENABLE_SEND_ONLY_TRANSLATED_MESSAGES} + +def setEnableSendOnlyTranslatedMessages(*args, **kwargs) -> dict: + config.ENABLE_SEND_ONLY_TRANSLATED_MESSAGES = True + return {"status":200, "result":config.ENABLE_SEND_ONLY_TRANSLATED_MESSAGES} + +def setDisableSendOnlyTranslatedMessages(*args, **kwargs) -> dict: + config.ENABLE_SEND_ONLY_TRANSLATED_MESSAGES = False + return {"status":200, "result":config.ENABLE_SEND_ONLY_TRANSLATED_MESSAGES} + +def getSendMessageButtonType(*args, **kwargs) -> dict: + return {"status":200, "result":config.SEND_MESSAGE_BUTTON_TYPE} + +def setSendMessageButtonType(data, *args, **kwargs) -> dict: + config.SEND_MESSAGE_BUTTON_TYPE = data + return {"status":200, "result":config.SEND_MESSAGE_BUTTON_TYPE} + +def getOverlaySettings(*args, **kwargs) -> dict: + return {"status":200, "result":config.OVERLAY_SETTINGS} + +def setOverlaySettings(data, *args, **kwargs) -> dict: + config.OVERLAY_SETTINGS = data + model.updateOverlayImageOpacity() + model.updateOverlayImageUiScaling() + return {"status":200, "result":config.OVERLAY_SETTINGS} + +def getOverlaySmallLogSettings(*args, **kwargs) -> dict: + return {"status":200, "result":config.OVERLAY_SMALL_LOG_SETTINGS} + +def setOverlaySmallLogSettings(data, *args, **kwargs) -> dict: + config.OVERLAY_SMALL_LOG_SETTINGS = data + model.updateOverlayPosition() + return {"status":200, "result":config.OVERLAY_SMALL_LOG_SETTINGS} + +def getEnableOverlaySmallLog(*args, **kwargs) -> dict: + return {"status":200, "result":config.ENABLE_OVERLAY_SMALL_LOG} + +def setEnableOverlaySmallLog(*args, **kwargs) -> dict: + config.ENABLE_OVERLAY_SMALL_LOG = True + if config.ENABLE_OVERLAY_SMALL_LOG is True and config.ENABLE_TRANSCRIPTION_RECEIVE is True: + if model.overlay.initialized is False and model.overlay.checkSteamvrRunning() is True: + model.startOverlay() + return {"status":200, "result":config.ENABLE_OVERLAY_SMALL_LOG} + +def setDisableOverlaySmallLog(*args, **kwargs) -> dict: + config.ENABLE_OVERLAY_SMALL_LOG = False + if config.ENABLE_OVERLAY_SMALL_LOG is False: + model.clearOverlayImage() + model.shutdownOverlay() + return {"status":200, "result":config.ENABLE_OVERLAY_SMALL_LOG} + +def getEnableSendMessageToVrc(*args, **kwargs) -> dict: + return {"status":200, "result":config.ENABLE_SEND_MESSAGE_TO_VRC} + +def setEnableSendMessageToVrc(*args, **kwargs) -> dict: + config.ENABLE_SEND_MESSAGE_TO_VRC = True + return {"status":200, "result":config.ENABLE_SEND_MESSAGE_TO_VRC} + +def setDisableSendMessageToVrc(*args, **kwargs) -> dict: + config.ENABLE_SEND_MESSAGE_TO_VRC = False + return {"status":200, "result":config.ENABLE_SEND_MESSAGE_TO_VRC} + +def getSendMessageFormat(*args, **kwargs) -> dict: + return {"status":200, "result":config.SEND_MESSAGE_FORMAT} + +def setSendMessageFormat(data, *args, **kwargs) -> dict: + if isUniqueStrings(["[message]"], data) is True: + config.SEND_MESSAGE_FORMAT = data + return {"status":200, "result":config.SEND_MESSAGE_FORMAT} + +def getSendMessageFormatWithT(*args, **kwargs) -> dict: + return {"status":200, "result":config.SEND_MESSAGE_FORMAT_WITH_T} + +def setSendMessageFormatWithT(data, *args, **kwargs) -> dict: + if len(data) > 0: + if isUniqueStrings(["[message]", "[translation]"], data) is True: + config.SEND_MESSAGE_FORMAT_WITH_T = data + return {"status":200, "result":config.SEND_MESSAGE_FORMAT_WITH_T} + +def getReceivedMessageFormat(*args, **kwargs) -> dict: + return {"status":200, "result":config.RECEIVED_MESSAGE_FORMAT} + +def setReceivedMessageFormat(data, *args, **kwargs) -> dict: + if isUniqueStrings(["[message]"], data) is True: + config.RECEIVED_MESSAGE_FORMAT = data + return {"status":200, "result":config.RECEIVED_MESSAGE_FORMAT} + +def getReceivedMessageFormatWithT(*args, **kwargs) -> dict: + return {"status":200, "result":config.RECEIVED_MESSAGE_FORMAT_WITH_T} + +def setReceivedMessageFormatWithT(data, *args, **kwargs) -> dict: + if len(data) > 0: + if isUniqueStrings(["[message]", "[translation]"], data) is True: + config.RECEIVED_MESSAGE_FORMAT_WITH_T = data + return {"status":200, "result":config.RECEIVED_MESSAGE_FORMAT_WITH_T} + +def getEnableSpeaker2ChatboxPass(*args, **kwargs) -> dict: + return {"status":200, "result":config.ENABLE_SPEAKER2CHATBOX_PASS} + +def setEnableSpeaker2ChatboxPass(*args, **kwargs) -> dict: + config.ENABLE_SPEAKER2CHATBOX_PASS = True + return {"status":200, "result":config.ENABLE_SPEAKER2CHATBOX_PASS} + +def setDisableSpeaker2ChatboxPass(*args, **kwargs) -> dict: + config.ENABLE_SPEAKER2CHATBOX_PASS = False + return {"status":200, "result":config.ENABLE_SPEAKER2CHATBOX_PASS} + +def getEnableSendReceivedMessageToVrc(*args, **kwargs) -> dict: + return {"status":200, "result":config.ENABLE_SEND_RECEIVED_MESSAGE_TO_VRC} + +def setEnableSendReceivedMessageToVrc(*args, **kwargs) -> dict: + config.ENABLE_SEND_RECEIVED_MESSAGE_TO_VRC = True + return {"status":200, "result":config.ENABLE_SEND_RECEIVED_MESSAGE_TO_VRC} + +def setDisableSendReceivedMessageToVrc(*args, **kwargs) -> dict: + config.ENABLE_SEND_RECEIVED_MESSAGE_TO_VRC = False + return {"status":200, "result":config.ENABLE_SEND_RECEIVED_MESSAGE_TO_VRC} + +def getEnableLogger(*args, **kwargs) -> dict: + return {"status":200, "result":config.ENABLE_LOGGER} + +def setEnableLogger(*args, **kwargs) -> dict: + config.ENABLE_LOGGER = True + model.startLogger() + return {"status":200, "result":config.ENABLE_LOGGER} + +def setDisableLogger(*args, **kwargs) -> dict: + model.stopLogger() + config.ENABLE_LOGGER = False + return {"status":200, "result":config.ENABLE_LOGGER} + +def getEnableVrcMicMuteSync(*args, **kwargs) -> dict: + return {"status":200, "result":config.ENABLE_VRC_MIC_MUTE_SYNC} + +def setEnableVrcMicMuteSync(*args, **kwargs) -> dict: + config.ENABLE_VRC_MIC_MUTE_SYNC = True + model.startCheckMuteSelfStatus() + model.changeMicTranscriptStatus() + return {"status":200, "result":config.ENABLE_VRC_MIC_MUTE_SYNC} + +def setDisableVrcMicMuteSync(*args, **kwargs) -> dict: + config.ENABLE_VRC_MIC_MUTE_SYNC = False + model.stopCheckMuteSelfStatus() + model.changeMicTranscriptStatus() + return {"status":200, "result":config.ENABLE_VRC_MIC_MUTE_SYNC} + +def setEnableCheckSpeakerThreshold(data, action, *args, **kwargs) -> dict: + progressbar_speaker_energy = ProgressBarSpeakerEnergy(action) + model.startCheckSpeakerEnergy( + progressbar_speaker_energy.set, + ) + config.ENABLE_CHECK_ENERGY_RECEIVE = True + return {"status":200, "result":config.ENABLE_CHECK_ENERGY_RECEIVE} + +def setDisableCheckSpeakerThreshold(*args, **kwargs) -> dict: + model.stopCheckSpeakerEnergy() + config.ENABLE_CHECK_ENERGY_RECEIVE = False + return {"status":200, "result":config.ENABLE_CHECK_ENERGY_RECEIVE} + +def setEnableCheckMicThreshold(data, action, *args, **kwargs) -> dict: + progressbar_mic_energy = ProgressBarMicEnergy(action) + model.startCheckMicEnergy( + progressbar_mic_energy.set, + ) + config.ENABLE_CHECK_ENERGY_SEND = True + return {"status":200, "result":config.ENABLE_CHECK_ENERGY_SEND} + +def setDisableCheckMicThreshold(*args, **kwargs) -> dict: + model.stopCheckMicEnergy() + config.ENABLE_CHECK_ENERGY_SEND = False + return {"status":200, "result":config.ENABLE_CHECK_ENERGY_SEND} + +# def updateSoftware(data, action, *args, **kwargs) -> dict: +# printLog("Update callbackUpdateSoftware") +# download = DownloadSoftwareProgressBar(action) +# update = UpdateSoftwareProgressBar(action) +# model.updateSoftware(restart=True, download=download.set, update=update.set) +# return {"status":200, "result":True} + +# def restartSoftware(*args, **kwargs) -> dict: +# printLog("Restart callbackRestartSoftware") +# model.reStartSoftware() +# return {"status":200, "result":True} + +def openFilepathLogs(*args, **kwargs) -> dict: + Popen(['explorer', config.PATH_LOGS.replace('/', '\\')], shell=True) + return {"status":200, "result":True} + +def openFilepathConfigFile(*args, **kwargs) -> dict: + Popen(['explorer', config.PATH_LOCAL.replace('/', '\\')], shell=True) + return {"status":200, "result":True} + +def setEnableTranscriptionSend(data, action, *args, **kwargs) -> dict: + startThreadingTranscriptionSendMessage(action) + config.ENABLE_TRANSCRIPTION_SEND = True + return {"status":200, "result":config.ENABLE_TRANSCRIPTION_SEND} + +def setDisableTranscriptionSend(*args, **kwargs) -> dict: + stopThreadingTranscriptionSendMessage() + config.ENABLE_TRANSCRIPTION_SEND = False + return {"status":200, "result":config.ENABLE_TRANSCRIPTION_SEND} + +def setEnableTranscriptionReceive(data, action, *args, **kwargs) -> dict: + startThreadingTranscriptionReceiveMessage(action) + if config.ENABLE_OVERLAY_SMALL_LOG is True: + if model.overlay.initialized is False and model.overlay.checkSteamvrRunning() is True: + model.startOverlay() + config.ENABLE_TRANSCRIPTION_RECEIVE = True + return {"status":200, "result":config.ENABLE_TRANSCRIPTION_RECEIVE} + +def setDisableTranscriptionReceive(*args, **kwargs) -> dict: + printLog("Disable Transcription Receive") + stopThreadingTranscriptionReceiveMessage() + config.ENABLE_TRANSCRIPTION_RECEIVE = False + return {"status":200, "result":config.ENABLE_TRANSCRIPTION_RECEIVE} + +def sendMessageBox(data, action, *args, **kwargs) -> dict: + chat = ChatMessage(action) + response = chat.send(data) + return response + +def typingMessageBox(*args, **kwargs) -> dict: + if config.ENABLE_SEND_MESSAGE_TO_VRC is True: + model.oscStartSendTyping() + return {"status":200, "result":True} + +def stopTypingMessageBox(*args, **kwargs) -> dict: + if config.ENABLE_SEND_MESSAGE_TO_VRC is True: + model.oscStopSendTyping() + return {"status":200, "result":True} + +def swapYourLanguageAndTargetLanguage(*args, **kwargs) -> dict: + your_languages = config.SELECTED_YOUR_LANGUAGES + your_language_primary = your_languages[config.SELECTED_TAB_NO]["primary"] + + target_languages = config.SELECTED_TARGET_LANGUAGES + target_language_primary = target_languages[config.SELECTED_TAB_NO]["primary"] + + your_languages[config.SELECTED_TAB_NO]["primary"] = target_language_primary + target_languages[config.SELECTED_TAB_NO]["primary"] = your_language_primary + + setSelectedYourLanguages(your_languages) + setSelectedTargetLanguages(target_languages) + return { + "status":200, + "result":{ + "your":config.SELECTED_YOUR_LANGUAGES, + "target":config.SELECTED_TARGET_LANGUAGES, + } + } + +def downloadCtranslate2Weight(data, action, *args, **kwargs) -> dict: + download = DownloadCTranslate2ProgressBar(action) + startThreadingDownloadCtranslate2Weight(download.set) + return {"status":200} + +def downloadWhisperWeight(data, action, *args, **kwargs) -> dict: + download = DownloadWhisperProgressBar(action) + startThreadingDownloadWhisperWeight(download.set) + return {"status":200} + +def messageFormatter(format_type:str, translation:list, message:list) -> str: + if format_type == "RECEIVED": + FORMAT_WITH_T = config.RECEIVED_MESSAGE_FORMAT_WITH_T + FORMAT = config.RECEIVED_MESSAGE_FORMAT + elif format_type == "SEND": + FORMAT_WITH_T = config.SEND_MESSAGE_FORMAT_WITH_T + FORMAT = config.SEND_MESSAGE_FORMAT + else: + raise ValueError("format_type is not found", format_type) + + if len(translation) > 0: + osc_message = FORMAT_WITH_T.replace("[message]", "/".join(message)) + osc_message = osc_message.replace("[translation]", "/".join(translation)) + else: + osc_message = FORMAT.replace("[message]", "/".join(message)) + return osc_message + +def changeToCTranslate2Process() -> None: + config.SELECTED_TRANSLATOR_ENGINES[config.SELECTED_TAB_NO] = "CTranslate2" + +def startTranscriptionSendMessage(action:Callable[[dict], None]) -> None: + mic_message = MicMessage(action) + model.startMicTranscript(mic_message.send) + +def stopTranscriptionSendMessage() -> None: + model.stopMicTranscript() + +def startThreadingTranscriptionSendMessage(action:Callable[[dict], None]) -> None: + th_startTranscriptionSendMessage = Thread(target=startTranscriptionSendMessage, args=(action,)) + th_startTranscriptionSendMessage.daemon = True + th_startTranscriptionSendMessage.start() + +def stopThreadingTranscriptionSendMessage() -> None: + th_stopTranscriptionSendMessage = Thread(target=stopTranscriptionSendMessage) + th_stopTranscriptionSendMessage.daemon = True + th_stopTranscriptionSendMessage.start() + th_stopTranscriptionSendMessage.join() + +def startTranscriptionSendMessageOnCloseConfigWindow(action:Callable[[dict], None]) -> None: + mic_message = MicMessage(action) + model.startMicTranscript(mic_message.send) + +def stopTranscriptionSendMessageOnOpenConfigWindow() -> None: + model.stopMicTranscript() + +def startThreadingTranscriptionSendMessageOnCloseConfigWindow(action:Callable[[dict], None]) -> None: + th_startTranscriptionSendMessage = Thread(target=startTranscriptionSendMessageOnCloseConfigWindow, args=(action,)) + th_startTranscriptionSendMessage.daemon = True + th_startTranscriptionSendMessage.start() + +def stopThreadingTranscriptionSendMessageOnOpenConfigWindow() -> None: + th_stopTranscriptionSendMessage = Thread(target=stopTranscriptionSendMessageOnOpenConfigWindow) + th_stopTranscriptionSendMessage.daemon = True + th_stopTranscriptionSendMessage.start() + def startTranscriptionReceiveMessage(action:Callable[[dict], None]) -> None: speaker_message = SpeakerMessage(action) model.startSpeakerTranscript(speaker_message.receive) @@ -279,7 +1314,7 @@ def startTranscriptionReceiveMessageOnCloseConfigWindow(action:Callable[[dict], speaker_message = SpeakerMessage(action) model.startSpeakerTranscript(speaker_message.receive) -def stopTranscriptionReceiveMessageOnOpenConfigWindow(): +def stopTranscriptionReceiveMessageOnOpenConfigWindow() -> None: model.stopSpeakerTranscript() def startThreadingTranscriptionReceiveMessageOnCloseConfigWindow(action:Callable[[dict], None]) -> None: @@ -287,12 +1322,11 @@ def startThreadingTranscriptionReceiveMessageOnCloseConfigWindow(action:Callable th_startTranscriptionReceiveMessage.daemon = True th_startTranscriptionReceiveMessage.start() -def stopThreadingTranscriptionReceiveMessageOnOpenConfigWindow(): +def stopThreadingTranscriptionReceiveMessageOnOpenConfigWindow() -> None: th_stopTranscriptionReceiveMessage = Thread(target=stopTranscriptionReceiveMessageOnOpenConfigWindow) th_stopTranscriptionReceiveMessage.daemon = True th_stopTranscriptionReceiveMessage.start() -# func message box def replaceExclamationsWithRandom(text): # ![...] にマッチする正規表現 pattern = r'!\[(.*?)\]' @@ -330,121 +1364,6 @@ def removeExclamations(text): cleaned_text = re.sub(pattern, r'\1', text) return cleaned_text -class ChatMessage: - def __init__(self, action:Callable[[dict], None]) -> None: - self.action = action - - def send(self, data): - id = data["id"] - message = data["message"] - if len(message) > 0: - # addSentMessageLog(message) - translation = [] - transliteration = [] - if config.ENABLE_TRANSLATION is False: - pass - else: - if config.USE_EXCLUDE_WORDS is True: - replacement_message, replacement_dict = replaceExclamationsWithRandom(message) - translation, success = model.getInputTranslate(replacement_message) - - message = removeExclamations(message) - for i in range(len(translation)): - translation[i] = restoreText(translation[i], replacement_dict) - else: - translation, success = model.getInputTranslate(message) - - if all(success) is not True: - changeToCTranslate2Process() - self.action("error_translation_engine", { - "status":400, - "result":{ - "message":"translation engine limit error" - } - }) - - if config.ENABLE_CONVERT_MESSAGE_TO_ROMAJI is True or config.ENABLE_CONVERT_MESSAGE_TO_HIRAGANA is True: - if config.SELECTED_TAB_TARGET_LANGUAGES[config.SELECTED_TAB_NO]["primary"]["language"] == "Japanese": - transliteration = model.convertMessageToTransliteration(translation[0]) - - # send OSC message - if config.ENABLE_SEND_MESSAGE_TO_VRC is True: - if config.ENABLE_SEND_ONLY_TRANSLATED_MESSAGES is True: - if config.ENABLE_TRANSLATION is False: - osc_message = messageFormatter("SEND", "", [message]) - else: - osc_message = messageFormatter("SEND", "", translation) - else: - osc_message = messageFormatter("SEND", translation, [message]) - model.oscSendMessage(osc_message) - - # if config.ENABLE_OVERLAY_SMALL_LOG is True: - # overlay_image = model.createOverlayImageShort(message, translation) - # model.updateOverlay(overlay_image) - # overlay_image = model.createOverlayImageLong("send", message, translation) - # model.updateOverlay(overlay_image) - - # update textbox message log (Sent) - if config.ENABLE_LOGGER is True: - if len(translation) > 0: - translation_text = " (" + "/".join(translation) + ")" - model.logger.info(f"[SENT] {message}{translation_text}") - - return {"status":200, - "result":{ - "id":id, - "message":message, - "translation":translation, - "transliteration":transliteration, - }, - } - -def callbackMessageBoxSend(data, action, *args, **kwargs) -> dict: - chat = ChatMessage(action) - response = chat.send(data) - return response - -def callbackMessageBoxTyping(*args, **kwargs) -> dict: - if config.ENABLE_SEND_MESSAGE_TO_VRC is True: - model.oscStartSendTyping() - return {"status":200, "result":True} - -def callbackMessageBoxTypingStop(*args, **kwargs) -> dict: - if config.ENABLE_SEND_MESSAGE_TO_VRC is True: - model.oscStopSendTyping() - return {"status":200, "result":True} - -# def addSentMessageLog(sent_message): -# config.SENT_MESSAGES_LOG.append(sent_message) -# config.CURRENT_SENT_MESSAGES_LOG_INDEX = len(config.SENT_MESSAGES_LOG) - -# def updateMessageBox(index_offset): -# if len(config.SENT_MESSAGES_LOG) == 0: -# return -# try: -# new_index = config.CURRENT_SENT_MESSAGES_LOG_INDEX + index_offset -# target_message_text = config.SENT_MESSAGES_LOG[new_index] -# # view.replaceMessageBox(target_message_text) -# config.CURRENT_SENT_MESSAGES_LOG_INDEX = new_index -# except IndexError: -# pass - -# def messageBoxUpKeyPress(): -# if config.CURRENT_SENT_MESSAGES_LOG_INDEX > 0: -# updateMessageBox(-1) - -# def messageBoxDownKeyPress(): -# if config.CURRENT_SENT_MESSAGES_LOG_INDEX < len(config.SENT_MESSAGES_LOG) - 1: -# updateMessageBox(1) - -def getTranslationEngines(*args, **kwargs) -> dict: - engines = model.findTranslationEngines( - config.SELECTED_TAB_YOUR_LANGUAGES[config.SELECTED_TAB_NO], - config.SELECTED_TAB_TARGET_LANGUAGES[config.SELECTED_TAB_NO], - config.ENABLE_MULTI_LANGUAGE_TRANSLATION, - ) - return {"status":200, "result":engines} - def updateTranslationEngineAndEngineList(): engine = config.SELECTED_TRANSLATOR_ENGINES[config.SELECTED_TAB_NO] engines = getTranslationEngines()["result"] @@ -452,894 +1371,16 @@ def updateTranslationEngineAndEngineList(): engine = engines[0] config.SELECTED_TRANSLATOR_ENGINES[config.SELECTED_TAB_NO] = engine -def setYourLanguageAndCountry(select:dict, *args, **kwargs) -> dict: - printLog("setYourLanguageAndCountry", select) - config.SELECTED_TAB_YOUR_LANGUAGES = select - updateTranslationEngineAndEngineList() - return {"status":200, "result":config.SELECTED_TAB_YOUR_LANGUAGES} - -def setTargetLanguageAndCountry(select:dict, *args, **kwargs) -> dict: - printLog("setTargetLanguageAndCountry", select) - config.SELECTED_TAB_TARGET_LANGUAGES = select - updateTranslationEngineAndEngineList() - return {"status":200, "result":config.SELECTED_TAB_TARGET_LANGUAGES} - -def swapYourLanguageAndTargetLanguage(*args, **kwargs) -> dict: - printLog("swapYourLanguageAndTargetLanguage") - your_languages = config.SELECTED_TAB_YOUR_LANGUAGES - your_language_primary = your_languages[config.SELECTED_TAB_NO]["primary"] - - target_languages = config.SELECTED_TAB_TARGET_LANGUAGES - target_language_primary = target_languages[config.SELECTED_TAB_NO]["primary"] - - your_languages[config.SELECTED_TAB_NO]["primary"] = target_language_primary - target_languages[config.SELECTED_TAB_NO]["primary"] = your_language_primary - - setYourLanguageAndCountry(your_languages) - setTargetLanguageAndCountry(target_languages) - return { - "status":200, - "result":{ - "your":config.SELECTED_TAB_YOUR_LANGUAGES, - "target":config.SELECTED_TAB_TARGET_LANGUAGES, - } - } - -def callbackSelectedLanguagePresetTab(selected_tab_no:str, *args, **kwargs) -> dict: - printLog("callbackSelectedLanguagePresetTab", selected_tab_no) - config.SELECTED_TAB_NO = selected_tab_no - updateTranslationEngineAndEngineList() - return {"status":200, "result":config.SELECTED_TAB_NO} - -def callbackSetSelectedTranslationEngines(engines:dict, *args, **kwargs) -> dict: - printLog("callbackSelectedTranslationEngine", engines) - config.SELECTED_TRANSLATOR_ENGINES = engines - return {"status":200,"result":{config.SELECTED_TRANSLATOR_ENGINES}} - -# command func -def callbackEnableTranslation(*args, **kwargs) -> dict: - printLog("Enable Translation") - config.ENABLE_TRANSLATION = True - if model.isLoadedCTranslate2Model() is False: - model.changeTranslatorCTranslate2Model() - return {"status":200, "result":config.ENABLE_TRANSLATION} - -def callbackDisableTranslation(*args, **kwargs) -> dict: - printLog("Disable Translation") - config.ENABLE_TRANSLATION = False - return {"status":200, "result":config.ENABLE_TRANSLATION} - -def callbackEnableTranscriptionSend(data, action, *args, **kwargs) -> dict: - printLog("Enable Transcription Send") - startThreadingTranscriptionSendMessage(action) - config.ENABLE_TRANSCRIPTION_SEND = True - return {"status":200, "result":config.ENABLE_TRANSCRIPTION_SEND} - -def callbackDisableTranscriptionSend(*args, **kwargs) -> dict: - printLog("Disable Transcription Send") - stopThreadingTranscriptionSendMessage() - config.ENABLE_TRANSCRIPTION_SEND = False - return {"status":200, "result":config.ENABLE_TRANSCRIPTION_SEND} - -def callbackEnableTranscriptionReceive(data, action, *args, **kwargs) -> dict: - printLog("Enable Transcription Receive") - - startThreadingTranscriptionReceiveMessage(action) - - if config.ENABLE_OVERLAY_SMALL_LOG is True: - if model.overlay.initialized is False and model.overlay.checkSteamvrRunning() is True: - model.startOverlay() - config.ENABLE_TRANSCRIPTION_RECEIVE = True - return {"status":200, "result":config.ENABLE_TRANSCRIPTION_RECEIVE} - -def callbackDisableTranscriptionReceive(*args, **kwargs) -> dict: - printLog("Disable Transcription Receive") - stopThreadingTranscriptionReceiveMessage() - config.ENABLE_TRANSCRIPTION_RECEIVE = False - return {"status":200, "result":config.ENABLE_TRANSCRIPTION_RECEIVE} - -def callbackEnableForeground(*args, **kwargs) -> dict: - printLog("Enable Foreground") - config.ENABLE_FOREGROUND = True - return {"status":200, "result":config.ENABLE_FOREGROUND} - -def callbackDisableForeground(*args, **kwargs) -> dict: - printLog("Disable Foreground") - config.ENABLE_FOREGROUND = False - return {"status":200, "result":config.ENABLE_FOREGROUND} - -def callbackEnableMultiLanguageTranslation(*args, **kwargs) -> dict: - printLog("Enable Multi Language Translation") - config.ENABLE_MULTI_LANGUAGE_TRANSLATION = True - return {"status":200, "result":config.ENABLE_MULTI_LANGUAGE_TRANSLATION} - -def callbackDisableMultiLanguageTranslation(*args, **kwargs) -> dict: - printLog("Disable Multi Language Translation") - config.ENABLE_MULTI_LANGUAGE_TRANSLATION = False - return {"status":200, "result":config.ENABLE_MULTI_LANGUAGE_TRANSLATION} - -def callbackEnableConvertMessageToRomaji(*args, **kwargs) -> dict: - printLog("Enable Convert Message To Romaji") - config.ENABLE_CONVERT_MESSAGE_TO_ROMAJI = True - return {"status":200, "result":config.ENABLE_CONVERT_MESSAGE_TO_ROMAJI} - -def callbackDisableConvertMessageToRomaji(*args, **kwargs) -> dict: - printLog("Disable Convert Message To Romaji") - config.ENABLE_CONVERT_MESSAGE_TO_ROMAJI = False - return {"status":200, "result":config.ENABLE_CONVERT_MESSAGE_TO_ROMAJI} - -def callbackEnableConvertMessageToHiragana(*args, **kwargs) -> dict: - printLog("Enable Convert Message To Hiragana") - config.ENABLE_CONVERT_MESSAGE_TO_HIRAGANA = True - return {"status":200, "result":config.ENABLE_CONVERT_MESSAGE_TO_HIRAGANA} - -def callbackDisableConvertMessageToHiragana(*args, **kwargs) -> dict: - printLog("Disable Convert Message To Hiragana") - config.ENABLE_CONVERT_MESSAGE_TO_HIRAGANA = False - return {"status":200, "result":config.ENABLE_CONVERT_MESSAGE_TO_HIRAGANA} - -def callbackEnableMainWindowSidebarCompactMode(*args, **kwargs) -> dict: - printLog("Enable MainWindow Sidebar Compact Mode") - config.IS_MAIN_WINDOW_SIDEBAR_COMPACT_MODE = True - return {"status":200, "result":config.IS_MAIN_WINDOW_SIDEBAR_COMPACT_MODE} - -def callbackDisableMainWindowSidebarCompactMode(*args, **kwargs) -> dict: - printLog("Disable MainWindow Sidebar Compact Mode") - config.IS_MAIN_WINDOW_SIDEBAR_COMPACT_MODE = False - return {"status":200, "result":config.IS_MAIN_WINDOW_SIDEBAR_COMPACT_MODE} - -# Config Window -def callbackOpenConfigWindow(*args, **kwargs) -> dict: - printLog("Open Config Window") - if config.ENABLE_TRANSCRIPTION_SEND is True: - stopThreadingTranscriptionSendMessageOnOpenConfigWindow() - if config.ENABLE_TRANSCRIPTION_RECEIVE is True: - stopThreadingTranscriptionReceiveMessageOnOpenConfigWindow() - return {"status":200, "result":True} - -def callbackCloseConfigWindow(data, action, *args, **kwargs) -> dict: - printLog("Close Config Window") - model.stopCheckMicEnergy() - model.stopCheckSpeakerEnergy() - - if config.ENABLE_TRANSCRIPTION_SEND is True: - startThreadingTranscriptionSendMessageOnCloseConfigWindow(action) - if config.ENABLE_TRANSCRIPTION_RECEIVE is True: - sleep(2) - if config.ENABLE_TRANSCRIPTION_RECEIVE is True: - startThreadingTranscriptionReceiveMessageOnCloseConfigWindow(action) - return {"status":200, "result":True} - -# Appearance Tab -def callbackSetTransparency(data, *args, **kwargs) -> dict: - printLog("Set Transparency", data) - config.TRANSPARENCY = int(data) - return {"status":200, "result":config.TRANSPARENCY} - -def callbackSetAppearance(data, *args, **kwargs) -> dict: - printLog("Set Appearance", data) - config.APPEARANCE_THEME = data - return {"status":200, "result":config.APPEARANCE_THEME} - -def callbackSetUiScaling(data, *args, **kwargs) -> dict: - printLog("Set Ui Scaling", data) - config.UI_SCALING = data - return {"status":200, "result":config.UI_SCALING} - -def callbackSetTextboxUiScaling(data, *args, **kwargs) -> dict: - printLog("Set Textbox Ui Scaling", data) - config.TEXTBOX_UI_SCALING = int(data) - return {"status":200, "result":config.TEXTBOX_UI_SCALING} - -def callbackSetMessageBoxRatio(data, *args, **kwargs) -> dict: - printLog("Set Message Box Ratio", data) - config.MESSAGE_BOX_RATIO = int(data) - return {"status":200, "result":config.MESSAGE_BOX_RATIO} - -def callbackSetFontFamily(data, *args, **kwargs) -> dict: - printLog("Set Font Family", data) - config.FONT_FAMILY = data - return {"status":200, "result":config.FONT_FAMILY} - -def callbackSetUiLanguage(data, *args, **kwargs) -> dict: - printLog("Set UI Language", data) - config.UI_LANGUAGE = data - return {"status":200, "result":config.UI_LANGUAGE} - -def callbackEnableRestoreMainWindowGeometry(*args, **kwargs) -> dict: - printLog("Enable Restore Main Window Geometry") - config.ENABLE_RESTORE_MAIN_WINDOW_GEOMETRY = True - return {"status":200, "result":config.ENABLE_RESTORE_MAIN_WINDOW_GEOMETRY} - -def callbackDisableRestoreMainWindowGeometry(*args, **kwargs) -> dict: - printLog("Disable Restore Main Window Geometry") - config.ENABLE_RESTORE_MAIN_WINDOW_GEOMETRY = True - return {"status":200, "result":config.ENABLE_RESTORE_MAIN_WINDOW_GEOMETRY} - -# Translation Tab -def callbackEnableUseTranslationFeature(*args, **kwargs) -> dict: - printLog("Enable Translation Feature") - config.USE_TRANSLATION_FEATURE = True - - if model.checkCTranslatorCTranslate2ModelWeight(): - config.IS_RESET_BUTTON_DISPLAYED_FOR_TRANSLATION = False - def callback(): - model.changeTranslatorCTranslate2Model() - th_callback = Thread(target=callback) - th_callback.daemon = True - th_callback.start() - else: - config.IS_RESET_BUTTON_DISPLAYED_FOR_TRANSLATION = True - - return {"status":200, - "result":{ - "feature":config.USE_TRANSLATION_FEATURE, - "reset":config.IS_RESET_BUTTON_DISPLAYED_FOR_TRANSLATION, - }, - } - -def callbackDisableUseTranslationFeature(*args, **kwargs) -> dict: - printLog("Disable Translation Feature") - config.USE_TRANSLATION_FEATURE = False - config.IS_RESET_BUTTON_DISPLAYED_FOR_TRANSLATION = False - return {"status":200, - "result":{ - "feature":config.USE_TRANSLATION_FEATURE, - "reset":config.IS_RESET_BUTTON_DISPLAYED_FOR_TRANSLATION, - }, - } - -def callbackSetCtranslate2WeightType(data, *args, **kwargs) -> dict: - printLog("Set CTranslate2 Weight Type", data) - config.CTRANSLATE2_WEIGHT_TYPE = str(data) - if model.checkCTranslatorCTranslate2ModelWeight(): - config.IS_RESET_BUTTON_DISPLAYED_FOR_TRANSLATION = False - def callback(): - model.changeTranslatorCTranslate2Model() - th_callback = Thread(target=callback) - th_callback.daemon = True - th_callback.start() - else: - config.IS_RESET_BUTTON_DISPLAYED_FOR_TRANSLATION = True - return {"status":200, - "result":{ - "feature":config.CTRANSLATE2_WEIGHT_TYPE, - "reset":config.IS_RESET_BUTTON_DISPLAYED_FOR_TRANSLATION, - }, - } - -class DownloadCTranslate2ProgressBar: - def __init__(self, action): - self.action = action - - def set(self, progress) -> None: - printLog("CTranslate2 Weight Download Progress", progress) - self.action("download", { - "status":200, - "result":{ - "progress":progress - } - }) - def startThreadingDownloadCtranslate2Weight(callback:Callable[[float], None]) -> None: th_download = Thread(target=model.downloadCTranslate2ModelWeight, args=(callback,)) th_download.daemon = True th_download.start() -def callbackDownloadCtranslate2Weight(data, action, *args, **kwargs) -> dict: - printLog("Download CTranslate2 Weight") - download = DownloadCTranslate2ProgressBar(action) - startThreadingDownloadCtranslate2Weight(download.set) - return {"status":200} - -def callbackSetDeeplAuthKey(data, *args, **kwargs) -> dict: - printLog("Set DeepL Auth Key", data) - status = 400 - if len(data) == 36 or len(data) == 39: - result = model.authenticationTranslatorDeepLAuthKey(auth_key=data) - if result is True: - key = data - status = 200 - else: - key = None - auth_keys = config.AUTH_KEYS - auth_keys["DeepL_API"] = key - config.AUTH_KEYS = auth_keys - updateTranslationEngineAndEngineList() - return {"status":status, "result":config.AUTH_KEYS["DeepL_API"]} - -def callbackClearDeeplAuthKey(*args, **kwargs) -> dict: - printLog("Clear DeepL Auth Key") - auth_keys = config.AUTH_KEYS - auth_keys["DeepL_API"] = None - config.AUTH_KEYS = auth_keys - updateTranslationEngineAndEngineList() - return {"status":200, "result":config.AUTH_KEYS["DeepL_API"]} - -# Transcription Tab -# Transcription (Mic) -class UpdateSelectedMicDevice: - def __init__(self, action): - self.action = action - - def set(self, host, device) -> None: - config.CHOICE_MIC_HOST = host - config.CHOICE_MIC_DEVICE = device - printLog("Update Host/Mic Device", f"{host}/{device}") - self.action("mic", { - "status":200, - "result":{"host":host, "device":device} - }) - -class UpdateSelectedSpeakerDevice: - def __init__(self, action): - self.action = action - - def set(self, device) -> None: - config.CHOICE_SPEAKER_DEVICE = device - printLog("Update Speaker Device", device) - self.action("speaker", { - "status":200, - "result":device - }) - -def callbackEnableMicAutomaticSelection(data, action, *args, **kwargs) -> dict: - printLog("Enable Mic Automatic Selection") - update_device = UpdateSelectedMicDevice(action) - device_manager.setCallbackDefaultInputDevice(update_device.set) - config.ENABLE_MIC_AUTOMATIC_SELECTION = True - return {"status":200, "result":config.ENABLE_MIC_AUTOMATIC_SELECTION} - -def callbackDisableMicAutomaticSelection(*args, **kwargs) -> dict: - printLog("Disable Mic Automatic Selection") - device_manager.clearCallbackDefaultInputDevice() - config.ENABLE_MIC_AUTOMATIC_SELECTION = False - return {"status":200, "result":config.ENABLE_MIC_AUTOMATIC_SELECTION} - -def callbackEnableSpeakerAutomaticSelection(data, action, *args, **kwargs) -> dict: - printLog("Enable Speaker Automatic Selection") - update_device = UpdateSelectedSpeakerDevice(action) - device_manager.setCallbackDefaultOutputDevice(update_device.set) - config.ENABLE_SPEAKER_AUTOMATIC_SELECTION = True - return {"status":200, "result":config.ENABLE_SPEAKER_AUTOMATIC_SELECTION} - -def callbackDisableSpeakerAutomaticSelection(*args, **kwargs) -> dict: - printLog("Disable Speaker Automatic Selection") - device_manager.clearCallbackDefaultInputDevice() - config.ENABLE_SPEAKER_AUTOMATIC_SELECTION = False - return {"status":200, "result":config.ENABLE_SPEAKER_AUTOMATIC_SELECTION} - -def callbackSetMicHost(data, *args, **kwargs) -> dict: - printLog("Set Mic Host", data) - config.CHOICE_MIC_HOST = data - config.CHOICE_MIC_DEVICE = model.getInputDefaultDevice() - if config.ENABLE_CHECK_ENERGY_SEND is True: - model.stopCheckMicEnergy() - model.startCheckMicEnergy() - return {"status":200, - "result":{ - "host":config.CHOICE_MIC_HOST, - "device":config.CHOICE_MIC_DEVICE, - }, - } - -def callbackSetMicDevice(data, *args, **kwargs) -> dict: - printLog("Set Mic Device", data) - config.CHOICE_MIC_DEVICE = data - if config.ENABLE_CHECK_ENERGY_SEND is True: - model.stopCheckMicEnergy() - model.startCheckMicEnergy() - return {"status":200, "result": config.CHOICE_MIC_DEVICE} - -def callbackSetMicEnergyThreshold(data, *args, **kwargs) -> dict: - printLog("Set Mic Energy Threshold", data) - status = 400 - data = int(data) - if 0 <= data <= config.MAX_MIC_ENERGY_THRESHOLD: - config.INPUT_MIC_ENERGY_THRESHOLD = data - status = 200 - return {"status": status, "result": config.INPUT_MIC_ENERGY_THRESHOLD} - -def callbackEnableMicDynamicEnergyThreshold(*args, **kwargs) -> dict: - printLog("Enable Mic Dynamic Energy Threshold") - config.INPUT_MIC_DYNAMIC_ENERGY_THRESHOLD = True - return {"status":200, "result":config.INPUT_MIC_DYNAMIC_ENERGY_THRESHOLD} - -def callbackDisableMicDynamicEnergyThreshold(*args, **kwargs) -> dict: - printLog("Disable Mic Dynamic Energy Threshold") - config.INPUT_MIC_DYNAMIC_ENERGY_THRESHOLD = False - return {"status":200, "result":config.INPUT_MIC_DYNAMIC_ENERGY_THRESHOLD} - -class ProgressBarMicEnergy: - def __init__(self, action): - self.action = action - - def set(self, energy) -> None: - if energy is False: - self.action("error_device", {"status":400,"result": {"message":"No mic device detected."}}) - else: - self.action("mic", {"status":200, "result":energy}) - -def callbackEnableCheckMicThreshold(data, action, *args, **kwargs) -> dict: - printLog("Enable Check Mic Threshold") - progressbar_mic_energy = ProgressBarMicEnergy(action) - model.startCheckMicEnergy( - progressbar_mic_energy.set, - ) - config.ENABLE_CHECK_ENERGY_SEND = True - return {"status":200, "result":config.ENABLE_CHECK_ENERGY_SEND} - -def callbackDisableCheckMicThreshold(*args, **kwargs) -> dict: - printLog("Disable Check Mic Threshold") - model.stopCheckMicEnergy() - config.ENABLE_CHECK_ENERGY_SEND = False - return {"status":200, "result":config.ENABLE_CHECK_ENERGY_SEND} - -def callbackSetMicRecordTimeout(data, *args, **kwargs) -> dict: - printLog("Set Mic Record Timeout", data) - try: - data = int(data) - if 0 <= data <= config.INPUT_MIC_PHRASE_TIMEOUT: - config.INPUT_MIC_RECORD_TIMEOUT = data - else: - raise ValueError() - except Exception: - response = {"status":400, "result":{"message":"Error Mic Record Timeout"}} - else: - response = {"status":200, "result":config.INPUT_MIC_RECORD_TIMEOUT} - return response - -def callbackSetMicPhraseTimeout(data, *args, **kwargs) -> dict: - printLog("Set Mic Phrase Timeout", data) - try: - data = int(data) - if data >= config.INPUT_MIC_RECORD_TIMEOUT: - config.INPUT_MIC_PHRASE_TIMEOUT = data - else: - raise ValueError() - except Exception: - response = {"status":400, "result":{"message":"Error Mic Phrase Timeout"}} - else: - response = {"status":200, "result":config.INPUT_MIC_PHRASE_TIMEOUT} - return response - -def callbackSetMicMaxPhrases(data, *args, **kwargs) -> dict: - printLog("Set Mic Max Phrases", data) - try: - data = int(data) - if 0 <= data: - config.INPUT_MIC_MAX_PHRASES = data - else: - raise ValueError() - except Exception: - response = {"status":400, "result":{"message":"Error Mic Max Phrases"}} - else: - response = {"status":200, "result":config.INPUT_MIC_MAX_PHRASES} - return response - -def callbackSetMicWordFilter(data, *args, **kwargs) -> dict: - printLog("Set Mic Word Filter", data) - data = str(data) - data = [w.strip() for w in data.split(",") if len(w.strip()) > 0] - # Copy the list - new_input_mic_word_filter_list = config.INPUT_MIC_WORD_FILTER - new_added_value = [] - for value in data: - if value in new_input_mic_word_filter_list: - # If the value is already in the list, do nothing. - pass - else: - new_input_mic_word_filter_list.append(value) - new_added_value.append(value) - config.INPUT_MIC_WORD_FILTER = new_input_mic_word_filter_list - - model.resetKeywordProcessor() - model.addKeywords() - return {"status":200, "result":config.INPUT_MIC_WORD_FILTER} - -def callbackDeleteMicWordFilter(data, *args, **kwargs) -> dict: - printLog("Delete Mic Word Filter", data) - try: - new_input_mic_word_filter_list = config.INPUT_MIC_WORD_FILTER - new_input_mic_word_filter_list.remove(str(data)) - config.INPUT_MIC_WORD_FILTER = new_input_mic_word_filter_list - model.resetKeywordProcessor() - model.addKeywords() - except Exception: - printLog("Delete Mic Word Filter", "There was no the target word in config.INPUT_MIC_WORD_FILTER") - return {"status":200, "result":config.INPUT_MIC_WORD_FILTER} - -# Transcription (Speaker) -def callbackSetSpeakerDevice(data, *args, **kwargs) -> dict: - printLog("Set Speaker Device", data) - config.CHOICE_SPEAKER_DEVICE = data - if config.ENABLE_CHECK_ENERGY_RECEIVE is True: - model.stopCheckSpeakerEnergy() - model.startCheckSpeakerEnergy() - return {"status":200, "result":config.CHOICE_SPEAKER_DEVICE} - -def callbackSetSpeakerEnergyThreshold(data, *args, **kwargs) -> dict: - printLog("Set Speaker Energy Threshold", data) - try: - data = int(data) - if 0 <= data <= config.MAX_SPEAKER_ENERGY_THRESHOLD: - config.INPUT_SPEAKER_ENERGY_THRESHOLD = data - else: - raise ValueError() - except Exception: - response = {"status":400, "result":{"message":"Error Set Speaker Energy Threshold"}} - else: - response = {"status":200, "result":config.INPUT_SPEAKER_ENERGY_THRESHOLD} - return response - -def callbackEnableSpeakerDynamicEnergyThreshold(*args, **kwargs) -> dict: - printLog("Enable Speaker Dynamic Energy Threshold") - config.INPUT_SPEAKER_DYNAMIC_ENERGY_THRESHOLD = True - return {"status":200, "result":config.INPUT_SPEAKER_DYNAMIC_ENERGY_THRESHOLD} - -def callbackDisableSpeakerDynamicEnergyThreshold(*args, **kwargs) -> dict: - printLog("Disable Speaker Dynamic Energy Threshold") - config.INPUT_SPEAKER_DYNAMIC_ENERGY_THRESHOLD = False - return {"status":200, "result":config.INPUT_SPEAKER_DYNAMIC_ENERGY_THRESHOLD} - -class ProgressBarSpeakerEnergy: - def __init__(self, action): - self.action = action - - def set(self, energy) -> None: - if energy is False: - self.action("error_device", {"status":400,"result": {"message":"No mic device detected."}}) - else: - self.action("speaker", {"status":200, "result":energy}) - -def callbackEnableCheckSpeakerThreshold(data, action, *args, **kwargs) -> dict: - printLog("Enable Check Speaker Threshold") - progressbar_speaker_energy = ProgressBarSpeakerEnergy(action) - model.startCheckSpeakerEnergy( - progressbar_speaker_energy.set, - ) - config.ENABLE_CHECK_ENERGY_RECEIVE = True - return {"status":200, "result":config.ENABLE_CHECK_ENERGY_RECEIVE} - -def callbackDisableCheckSpeakerThreshold(*args, **kwargs) -> dict: - printLog("Disable Check Speaker Threshold") - model.stopCheckSpeakerEnergy() - config.ENABLE_CHECK_ENERGY_RECEIVE = False - return {"status":200, "result":config.ENABLE_CHECK_ENERGY_RECEIVE} - -def callbackSetSpeakerRecordTimeout(data, *args, **kwargs) -> dict: - printLog("Set Speaker Record Timeout", data) - try: - data = int(data) - if 0 <= data <= config.INPUT_SPEAKER_PHRASE_TIMEOUT: - config.INPUT_SPEAKER_RECORD_TIMEOUT = data - else: - raise ValueError() - except Exception: - response = {"status":400, "result":{"message":"Error Speaker Record Timeout"}} - else: - response = {"status":200, "result":config.INPUT_SPEAKER_RECORD_TIMEOUT} - return response - -def callbackSetSpeakerPhraseTimeout(data, *args, **kwargs) -> dict: - printLog("Set Speaker Phrase Timeout", data) - try: - data = int(data) - if 0 <= data and data >= config.INPUT_SPEAKER_RECORD_TIMEOUT: - config.INPUT_SPEAKER_PHRASE_TIMEOUT = data - else: - raise ValueError() - except Exception: - response = {"status":400, "result":{"message":"Error Speaker Phrase Timeout"}} - else: - response = {"status":200, "result":config.INPUT_SPEAKER_PHRASE_TIMEOUT} - return response - -def callbackSetSpeakerMaxPhrases(data, *args, **kwargs) -> dict: - printLog("Set Speaker Max Phrases", data) - try: - data = int(data) - if 0 <= data: - config.INPUT_SPEAKER_MAX_PHRASES = data - else: - raise ValueError() - except Exception: - response = {"status":400, "result":{"message":"Error Speaker Max Phrases"}} - else: - response = {"status":200, "result":config.INPUT_SPEAKER_MAX_PHRASES} - return response - -# Transcription (Internal AI Model) -def callbackEnableUseWhisperFeature(*args, **kwargs) -> dict: - printLog("Enable Whisper Feature") - config.USE_WHISPER_FEATURE = True - if model.checkTranscriptionWhisperModelWeight() is True: - config.IS_RESET_BUTTON_DISPLAYED_FOR_WHISPER = False - config.SELECTED_TRANSCRIPTION_ENGINE = "Whisper" - else: - config.IS_RESET_BUTTON_DISPLAYED_FOR_WHISPER = True - config.SELECTED_TRANSCRIPTION_ENGINE = "Google" - return {"status":200, - "result":{ - "feature":config.USE_WHISPER_FEATURE, - "transcription_engine":config.SELECTED_TRANSCRIPTION_ENGINE, - "reset":config.IS_RESET_BUTTON_DISPLAYED_FOR_WHISPER, - }, - } - -def callbackDisableUseWhisperFeature(*args, **kwargs) -> dict: - printLog("Disable Whisper Feature") - config.USE_WHISPER_FEATURE = False - config.IS_RESET_BUTTON_DISPLAYED_FOR_WHISPER = False - config.SELECTED_TRANSCRIPTION_ENGINE = "Google" - return {"status":200, - "result":{ - "feature":config.USE_WHISPER_FEATURE, - "transcription_engine":config.SELECTED_TRANSCRIPTION_ENGINE, - "reset":config.IS_RESET_BUTTON_DISPLAYED_FOR_WHISPER, - }, - } - -def callbackSetWhisperWeightType(data, *args, **kwargs) -> dict: - printLog("Set Whisper Weight Type", data) - config.WHISPER_WEIGHT_TYPE = str(data) - if model.checkTranscriptionWhisperModelWeight() is True: - config.IS_RESET_BUTTON_DISPLAYED_FOR_WHISPER = False - config.SELECTED_TRANSCRIPTION_ENGINE = "Whisper" - else: - config.IS_RESET_BUTTON_DISPLAYED_FOR_WHISPER = True - config.SELECTED_TRANSCRIPTION_ENGINE = "Google" - return {"status":200, - "result":{ - "weight_type":config.WHISPER_WEIGHT_TYPE, - "transcription_engine":config.SELECTED_TRANSCRIPTION_ENGINE, - "reset":config.IS_RESET_BUTTON_DISPLAYED_FOR_WHISPER, - } - } - -class DownloadWhisperProgressBar: - def __init__(self, action): - self.action = action - - def set(self, progress) -> None: - printLog("Whisper Weight Download Progress", progress) - self.action("download", { - "status":200, - "result":{ - "progress":progress - } - }) - def startThreadingDownloadWhisperWeight(callback:Callable[[float], None]) -> None: th_download = Thread(target=model.downloadWhisperModelWeight, args=(callback,)) th_download.daemon = True th_download.start() -def callbackDownloadWhisperWeight(data, action, *args, **kwargs) -> dict: - printLog("Download Whisper Weight") - download = DownloadWhisperProgressBar(action) - startThreadingDownloadWhisperWeight(download.set) - return {"status":200} - -# VR Tab -def callbackSetOverlaySettingsOpacity(data, *args, **kwargs) -> dict: - printLog("Set Overlay Settings Opacity", data) - pre_settings = config.OVERLAY_SETTINGS - pre_settings["opacity"] = data - config.OVERLAY_SETTINGS = pre_settings - model.updateOverlayImageOpacity() - return {"status":200, "result":config.OVERLAY_SETTINGS["opacity"]} - -def callbackSetOverlaySettingsUiScaling(data, *args, **kwargs) -> dict: - printLog("Set Overlay Settings Ui Scaling", data) - pre_settings = config.OVERLAY_SETTINGS - pre_settings["ui_scaling"] = data - config.OVERLAY_SETTINGS = pre_settings - model.updateOverlayImageUiScaling() - return {"status":200, "result":config.OVERLAY_SETTINGS["ui_scaling"]} - -def callbackEnableOverlaySmallLog(*args, **kwargs) -> dict: - printLog("Enable Overlay Small Log") - config.ENABLE_OVERLAY_SMALL_LOG = True - - if config.ENABLE_OVERLAY_SMALL_LOG is True and config.ENABLE_TRANSCRIPTION_RECEIVE is True: - if model.overlay.initialized is False and model.overlay.checkSteamvrRunning() is True: - model.startOverlay() - return {"status":200, "result":config.ENABLE_OVERLAY_SMALL_LOG} - -def callbackDisableOverlaySmallLog(*args, **kwargs) -> dict: - printLog("Disable Overlay Small Log") - config.ENABLE_OVERLAY_SMALL_LOG = False - if config.ENABLE_OVERLAY_SMALL_LOG is False: - model.clearOverlayImage() - model.shutdownOverlay() - return {"status":200, "result":config.ENABLE_OVERLAY_SMALL_LOG} - -def callbackSetOverlaySmallLogSettingsXPos(data, *args, **kwargs) -> dict: - printLog("Set Overlay Small Log Settings X Pos", data) - pre_settings = config.OVERLAY_SMALL_LOG_SETTINGS - pre_settings["x_pos"] = data - config.OVERLAY_SMALL_LOG_SETTINGS = pre_settings - model.updateOverlayPosition() - return {"status":200, "result":config.OVERLAY_SMALL_LOG_SETTINGS["x_pos"]} - -def callbackSetOverlaySmallLogSettingsYPos(data, *args, **kwargs) -> dict: - printLog("Set Overlay Small Log Settings Y Pos", data) - pre_settings = config.OVERLAY_SMALL_LOG_SETTINGS - pre_settings["y_pos"] = data - config.OVERLAY_SMALL_LOG_SETTINGS = pre_settings - model.updateOverlayPosition() - return {"status":200, "result":config.OVERLAY_SMALL_LOG_SETTINGS["y_pos"]} - -def callbackSetOverlaySmallLogSettingsZPos(data, *args, **kwargs) -> dict: - printLog("Set Overlay Small Log Settings Z Pos", data) - pre_settings = config.OVERLAY_SMALL_LOG_SETTINGS - pre_settings["z_pos"] = data - config.OVERLAY_SMALL_LOG_SETTINGS = pre_settings - model.updateOverlayPosition() - return {"status":200, "result":config.OVERLAY_SMALL_LOG_SETTINGS["z_pos"]} - -def callbackSetOverlaySmallLogSettingsXRotation(data, *args, **kwargs) -> dict: - printLog("Set Overlay Small Log Settings X Rotation", data) - pre_settings = config.OVERLAY_SMALL_LOG_SETTINGS - pre_settings["x_rotation"] = data - config.OVERLAY_SMALL_LOG_SETTINGS = pre_settings - model.updateOverlayPosition() - return {"status":200, "result":config.OVERLAY_SMALL_LOG_SETTINGS["x_rotation"]} - -def callbackSetOverlaySmallLogSettingsYRotation(data, *args, **kwargs) -> dict: - printLog("Set Overlay Small Log Settings Y Rotation", data) - pre_settings = config.OVERLAY_SMALL_LOG_SETTINGS - pre_settings["y_rotation"] = data - config.OVERLAY_SMALL_LOG_SETTINGS = pre_settings - model.updateOverlayPosition() - return {"status":200, "result":config.OVERLAY_SMALL_LOG_SETTINGS["y_rotation"]} - -def callbackSetOverlaySmallLogSettingsZRotation(data, *args, **kwargs) -> dict: - printLog("Set Overlay Small Log Settings Z Rotation", data) - pre_settings = config.OVERLAY_SMALL_LOG_SETTINGS - pre_settings["z_rotation"] = data - config.OVERLAY_SMALL_LOG_SETTINGS = pre_settings - model.updateOverlayPosition() - return {"status":200, "result":config.OVERLAY_SMALL_LOG_SETTINGS["z_rotation"]} - -# Others Tab -def callbackEnableAutoClearMessageBox(*args, **kwargs) -> dict: - printLog("Enable Auto Clear Message Box") - config.ENABLE_AUTO_CLEAR_MESSAGE_BOX = True - return {"status":200, "result":config.ENABLE_AUTO_CLEAR_MESSAGE_BOX} - -def callbackDisableAutoClearMessageBox(*args, **kwargs) -> dict: - printLog("Disable Auto Clear Message Box") - config.ENABLE_AUTO_CLEAR_MESSAGE_BOX = False - return {"status":200, "result":config.ENABLE_AUTO_CLEAR_MESSAGE_BOX} - -def callbackEnableSendOnlyTranslatedMessages(*args, **kwargs) -> dict: - printLog("Enable Send Only Translated Messages") - config.ENABLE_SEND_ONLY_TRANSLATED_MESSAGES = True - return {"status":200, "result":config.ENABLE_SEND_ONLY_TRANSLATED_MESSAGES} - -def callbackDisableSendOnlyTranslatedMessages(*args, **kwargs) -> dict: - printLog("Disable Send Only Translated Messages") - config.ENABLE_SEND_ONLY_TRANSLATED_MESSAGES = False - return {"status":200, "result":config.ENABLE_SEND_ONLY_TRANSLATED_MESSAGES} - -def callbackSetSendMessageButtonType(data, *args, **kwargs) -> dict: - printLog("Set Send Message Button Type", data) - config.SEND_MESSAGE_BUTTON_TYPE = data - return {"status":200, "result":config.SEND_MESSAGE_BUTTON_TYPE} - -def callbackEnableAutoExportMessageLogs(*args, **kwargs) -> dict: - printLog("Enable Auto Export Message Logs") - config.ENABLE_LOGGER = True - model.startLogger() - return {"status":200, "result":config.ENABLE_LOGGER} - -def callbackDisableAutoExportMessageLogs(*args, **kwargs) -> dict: - printLog("Disable Auto Export Message Logs") - config.ENABLE_LOGGER = False - model.stopLogger() - return {"status":200, "result":config.ENABLE_LOGGER} - -def callbackEnableVrcMicMuteSync(*args, **kwargs) -> dict: - printLog("Enable VRC Mic Mute Sync") - config.ENABLE_VRC_MIC_MUTE_SYNC = True - model.startCheckMuteSelfStatus() - model.changeMicTranscriptStatus() - return {"status":200, "result":config.ENABLE_VRC_MIC_MUTE_SYNC} - -def callbackDisableVrcMicMuteSync(*args, **kwargs) -> dict: - printLog("Disable VRC Mic Mute Sync") - config.ENABLE_VRC_MIC_MUTE_SYNC = False - model.stopCheckMuteSelfStatus() - model.changeMicTranscriptStatus() - return {"status":200, "result":config.ENABLE_VRC_MIC_MUTE_SYNC} - -def callbackEnableSendMessageToVrc(*args, **kwargs) -> dict: - printLog("Enable Send Message To VRC") - config.ENABLE_SEND_MESSAGE_TO_VRC = True - return {"status":200, "result":config.ENABLE_SEND_MESSAGE_TO_VRC} - -def callbackDisableSendMessageToVrc(*args, **kwargs) -> dict: - printLog("Disable Send Message To VRC") - config.ENABLE_SEND_MESSAGE_TO_VRC = False - return {"status":200, "result":config.ENABLE_SEND_MESSAGE_TO_VRC} - -# Others (Message Formats(Send) -def callbackSetSendMessageFormat(data, *args, **kwargs) -> dict: - printLog("Set Send Message Format", data) - if isUniqueStrings(["[message]"], data) is True: - config.SEND_MESSAGE_FORMAT = data - return {"status":200, "result":config.SEND_MESSAGE_FORMAT} - -def callbackSetSendMessageFormatWithT(data, *args, **kwargs) -> dict: - printLog("Set Send Message Format With Translation", data) - if len(data) > 0: - if isUniqueStrings(["[message]", "[translation]"], data) is True: - config.SEND_MESSAGE_FORMAT_WITH_T = data - return {"status":200, "result":config.SEND_MESSAGE_FORMAT_WITH_T} - -# Others (Message Formats(Received) -def callbackSetReceivedMessageFormat(data, *args, **kwargs) -> dict: - printLog("Set Received Message Format", data) - if isUniqueStrings(["[message]"], data) is True: - config.RECEIVED_MESSAGE_FORMAT = data - return {"status":200, "result":config.RECEIVED_MESSAGE_FORMAT} - -def callbackSetReceivedMessageFormatWithT(data, *args, **kwargs) -> dict: - printLog("Set Received Message Format With Translation", data) - if len(data) > 0: - if isUniqueStrings(["[message]", "[translation]"], data) is True: - config.RECEIVED_MESSAGE_FORMAT_WITH_T = data - return {"status":200, "result":config.RECEIVED_MESSAGE_FORMAT_WITH_T} - -# ---------------------Speaker2Chatbox--------------------- -def callbackEnableSendReceivedMessageToVrc(*args, **kwargs) -> dict: - printLog("Enable Send Received Message To VRC") - config.ENABLE_SEND_RECEIVED_MESSAGE_TO_VRC = True - return {"status":200, "result":config.ENABLE_SEND_RECEIVED_MESSAGE_TO_VRC} - -def callbackDisableSendReceivedMessageToVrc(*args, **kwargs) -> dict: - printLog("Disable Send Received Message To VRC") - config.ENABLE_SEND_RECEIVED_MESSAGE_TO_VRC = False - return {"status":200, "result":config.ENABLE_SEND_RECEIVED_MESSAGE_TO_VRC} -# ---------------------Speaker2Chatbox--------------------- - -def callbackEnableLogger(*args, **kwargs) -> dict: - printLog("Enable Logger") - config.ENABLE_LOGGER = True - model.startLogger() - return {"status":200, "result":config.ENABLE_LOGGER} - -def callbackDisableLogger(*args, **kwargs) -> dict: - printLog("Disable Logger") - config.ENABLE_LOGGER = False - model.stopLogger() - return {"status":200, "result":config.ENABLE_LOGGER} - -# Advanced Settings Tab -def callbackSetOscIpAddress(data, *args, **kwargs) -> dict: - printLog("Set OSC IP Address", data) - config.OSC_IP_ADDRESS = str(data) - return {"status":200, "result":config.OSC_IP_ADDRESS} - -def callbackSetOscPort(data, *args, **kwargs) -> dict: - printLog("Set OSC Port", data) - config.OSC_PORT = int(data) - return {"status":200, "result":config.OSC_PORT} - -def getListLanguageAndCountry(*args, **kwargs) -> dict: - return {"status":200, "result": model.getListLanguageAndCountry()} - -def getListInputHost(*args, **kwargs) -> dict: - return {"status":200, "result": model.getListInputHost()} - -def getListInputDevice(*args, **kwargs) -> dict: - return {"status":200, "result": model.getListInputDevice()} - -def getListOutputDevice(*args, **kwargs) -> dict: - return {"status":200, "result": model.getListOutputDevice()} - def init(actions:dict, *args, **kwargs) -> None: printLog("Start Initialization") @@ -1396,11 +1437,11 @@ def init(actions:dict, *args, **kwargs) -> None: # init Auto device selection printLog("Init Auto Device Selection") - if config.ENABLE_MIC_AUTOMATIC_SELECTION is True: + if config.ENABLE_MIC_AUTO_SELECTION is True: update_mic_device = UpdateSelectedMicDevice(actions["update_selected_mic_device"]) device_manager.setCallbackDefaultInputDevice(update_mic_device.set) - if config.ENABLE_SPEAKER_AUTOMATIC_SELECTION is True: + if config.ENABLE_SPEAKER_AUTO_SELECTION is True: update_speaker_device = UpdateSelectedSpeakerDevice(actions["update_selected_speaker_device"]) device_manager.setCallbackDefaultOutputDevice(update_speaker_device.set) diff --git a/src-python/webui_mainloop.py b/src-python/webui_mainloop.py index 491c4e80..e5504546 100644 --- a/src-python/webui_mainloop.py +++ b/src-python/webui_mainloop.py @@ -1,251 +1,309 @@ import sys import json import time -from config import config from threading import Thread from queue import Queue import webui_controller as controller from utils import printLog, printResponse, encodeBase64 -config_mapping = { - "/config/version": {"status": True, "variable":"VERSION"}, - "/config/transparency_range": {"status": True, "variable":"TRANSPARENCY_RANGE"}, - "/config/appearance_theme_list": {"status": True, "variable":"APPEARANCE_THEME_LIST"}, - "/config/ui_scaling_list": {"status": True, "variable":"UI_SCALING_LIST"}, - "/config/textbox_ui_scaling_range": {"status": True, "variable":"TEXTBOX_UI_SCALING_RANGE"}, - "/config/message_box_ratio_range": {"status": True, "variable":"MESSAGE_BOX_RATIO_RANGE"}, - "/config/selectable_ctranslate2_weight_type_dict": {"status": True, "variable":"SELECTABLE_CTRANSLATE2_WEIGHT_TYPE_DICT"}, - "/config/selectable_whisper_weight_type_dict": {"status": True, "variable":"SELECTABLE_WHISPER_WEIGHT_TYPE_DICT"}, - "/config/max_mic_energy_threshold": {"status": True, "variable":"MAX_MIC_ENERGY_THRESHOLD"}, - "/config/max_speaker_energy_threshold": {"status": True, "variable":"MAX_SPEAKER_ENERGY_THRESHOLD"}, - # "/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"}, -} +mapping = { + "/get/version": {"status": True, "variable":controller.getVersion}, + "/get/transparency_range": {"status": True, "variable":controller.getTransparencyRange}, + "/get/appearance_theme_list": {"status": True, "variable":controller.getAppearanceThemesList}, + "/get/ui_scaling_list": {"status": True, "variable":controller.getUiScalingList}, + "/get/textbox_ui_scaling_range": {"status": True, "variable":controller.getTextboxUiScalingRange}, + "/get/message_box_ratio_range": {"status": True, "variable":controller.getMessageBoxRatioRange}, + "/get/selectable_ctranslate2_weight_type_dict": {"status": True, "variable":controller.getSelectableCtranslate2WeightTypeDict}, + "/get/selectable_whisper_weight_type_dict": {"status": True, "variable":controller.getSelectableWhisperModelTypeDict}, + "/get/max_mic_energy_threshold": {"status": True, "variable":controller.getMaxMicEnergyThreshold}, + "/get/max_speaker_energy_threshold": {"status": True, "variable":controller.getMaxSpeakerEnergyThreshold}, -controller_mapping = { - "/controller/list_language_and_country": {"status": True, "variable":controller.getListLanguageAndCountry}, - "/controller/list_mic_host": {"status": True, "variable":controller.getListInputHost}, - "/controller/list_mic_device": {"status": True, "variable":controller.getListInputDevice}, - "/controller/list_speaker_device": {"status": True, "variable":controller.getListOutputDevice}, - # "/controller/callback_update_software": {"status": True, "variable":controller.callbackUpdateSoftware}, - # "/controller/callback_restart_software": {"status": True, "variable":controller.callbackRestartSoftware}, - "/controller/callback_filepath_logs": {"status": True, "variable":controller.callbackFilepathLogs}, - "/controller/callback_filepath_config_file": {"status": True, "variable":controller.callbackFilepathConfigFile}, - # "/controller/callback_enable_easter_egg": {"status": True, "variable":controller.callbackEnableEasterEgg}, - "/controller/callback_open_config_window": {"status": True, "variable":controller.callbackOpenConfigWindow}, - "/controller/callback_close_config_window": {"status": True, "variable":controller.callbackCloseConfigWindow}, - "/controller/callback_enable_multi_language_translation": {"status": True, "variable":controller.callbackEnableMultiLanguageTranslation}, - "/controller/callback_disable_multi_language_translation": {"status": True, "variable":controller.callbackDisableMultiLanguageTranslation}, - "/controller/callback_enable_convert_message_to_romaji": {"status": True, "variable":controller.callbackEnableConvertMessageToRomaji}, - "/controller/callback_disable_convert_message_to_romaji": {"status": True, "variable":controller.callbackDisableConvertMessageToRomaji}, - "/controller/callback_enable_convert_message_to_hiragana": {"status": True, "variable":controller.callbackEnableConvertMessageToHiragana}, - "/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}, - "/controller/callback_disable_main_window_sidebar_compact_mode": {"status": True, "variable":controller.callbackDisableMainWindowSidebarCompactMode}, - "/controller/callback_enable_translation": {"status": False, "variable":controller.callbackEnableTranslation}, - "/controller/callback_disable_translation": {"status": False, "variable":controller.callbackDisableTranslation}, - "/controller/callback_enable_transcription_send": {"status": False, "variable":controller.callbackEnableTranscriptionSend}, - "/controller/callback_disable_transcription_send": {"status": False, "variable":controller.callbackDisableTranscriptionSend}, - "/controller/callback_enable_transcription_receive": {"status": False, "variable":controller.callbackEnableTranscriptionReceive}, - "/controller/callback_disable_transcription_receive": {"status": False, "variable":controller.callbackDisableTranscriptionReceive}, - "/controller/callback_messagebox_send": {"status": False, "variable":controller.callbackMessageBoxSend}, - "/controller/callback_messagebox_typing": {"status": False, "variable":controller.callbackMessageBoxTyping}, - "/controller/callback_messagebox_typing_stop": {"status": False, "variable":controller.callbackMessageBoxTypingStop}, - "/controller/callback_enable_foreground": {"status": True, "variable":controller.callbackEnableForeground}, - "/controller/callback_disable_foreground": {"status": True, "variable":controller.callbackDisableForeground}, - "/controller/set_your_language_and_country": {"status": True, "variable":controller.setYourLanguageAndCountry}, - "/controller/set_target_language_and_country": {"status": True, "variable":controller.setTargetLanguageAndCountry}, - "/controller/swap_your_language_and_target_language": {"status": True, "variable":controller.swapYourLanguageAndTargetLanguage}, - "/controller/callback_selected_language_preset_tab": {"status": True, "variable":controller.callbackSelectedLanguagePresetTab}, - "/controller/list_translation_engines": {"status": True, "variable":controller.getTranslationEngines}, - "/controller/callback_set_translation_engines": {"status": True, "variable":controller.callbackSetSelectedTranslationEngines}, - "/controller/callback_set_transparency": {"status": True, "variable":controller.callbackSetTransparency}, - "/controller/callback_set_appearance": {"status": True, "variable":controller.callbackSetAppearance}, - "/controller/callback_set_ui_scaling": {"status": True, "variable":controller.callbackSetUiScaling}, - "/controller/callback_set_textbox_ui_scaling": {"status": True, "variable":controller.callbackSetTextboxUiScaling}, - "/controller/callback_set_message_box_ratio": {"status": True, "variable":controller.callbackSetMessageBoxRatio}, - "/controller/callback_set_font_family": {"status": True, "variable":controller.callbackSetFontFamily}, - "/controller/callback_set_ui_language": {"status": True, "variable":controller.callbackSetUiLanguage}, - "/controller/callback_enable_restore_main_window_geometry": {"status": True, "variable":controller.callbackEnableRestoreMainWindowGeometry}, - "/controller/callback_disable_restore_main_window_geometry": {"status": True, "variable":controller.callbackDisableRestoreMainWindowGeometry}, - "/controller/callback_enable_use_translation_feature": {"status": True, "variable":controller.callbackEnableUseTranslationFeature}, - "/controller/callback_disable_use_translation_feature": {"status": True, "variable":controller.callbackDisableUseTranslationFeature}, - "/controller/callback_set_ctranslate2_weight_type": {"status": True, "variable":controller.callbackSetCtranslate2WeightType}, - "/controller/callback_download_ctranslate2_weight": {"status": True, "variable":controller.callbackDownloadCtranslate2Weight}, - "/controller/callback_set_deepl_auth_key": {"status": True, "variable":controller.callbackSetDeeplAuthKey}, - "/controller/callback_clear_deepl_auth_key": {"status": True, "variable":controller.callbackClearDeeplAuthKey}, - "/controller/callback_enable_mic_automatic_selection": {"status": False, "variable":controller.callbackEnableMicAutomaticSelection}, - "/controller/callback_disable_mic_automatic_selection": {"status": False, "variable":controller.callbackDisableMicAutomaticSelection}, - "/controller/callback_set_mic_host": {"status": True, "variable":controller.callbackSetMicHost}, - "/controller/callback_set_mic_device": {"status": True, "variable":controller.callbackSetMicDevice}, - "/controller/callback_set_mic_energy_threshold": {"status": True, "variable":controller.callbackSetMicEnergyThreshold}, - "/controller/callback_enable_mic_dynamic_energy_threshold": {"status": True, "variable":controller.callbackEnableMicDynamicEnergyThreshold}, - "/controller/callback_disable_mic_dynamic_energy_threshold": {"status": True, "variable":controller.callbackDisableMicDynamicEnergyThreshold}, - "/controller/callback_enable_check_mic_threshold": {"status": True, "variable":controller.callbackEnableCheckMicThreshold}, - "/controller/callback_disable_check_mic_threshold": {"status": True, "variable":controller.callbackDisableCheckMicThreshold}, - "/controller/callback_set_mic_record_timeout": {"status": True, "variable":controller.callbackSetMicRecordTimeout}, - "/controller/callback_set_mic_phrase_timeout": {"status": True, "variable":controller.callbackSetMicPhraseTimeout}, - "/controller/callback_set_mic_max_phrases": {"status": True, "variable":controller.callbackSetMicMaxPhrases}, - "/controller/callback_set_mic_word_filter": {"status": False, "variable":controller.callbackSetMicWordFilter}, - "/controller/callback_delete_mic_word_filter": {"status": False, "variable":controller.callbackDeleteMicWordFilter}, - "/controller/callback_enable_speaker_automatic_selection": {"status": False, "variable":controller.callbackEnableSpeakerAutomaticSelection}, - "/controller/callback_disable_speaker_automatic_selection": {"status": False, "variable":controller.callbackDisableSpeakerAutomaticSelection}, - "/controller/callback_set_speaker_device": {"status": True, "variable":controller.callbackSetSpeakerDevice}, - "/controller/callback_set_speaker_energy_threshold": {"status": True, "variable":controller.callbackSetSpeakerEnergyThreshold}, - "/controller/callback_enable_speaker_dynamic_energy_threshold": {"status": True, "variable":controller.callbackEnableSpeakerDynamicEnergyThreshold}, - "/controller/callback_disable_speaker_dynamic_energy_threshold": {"status": True, "variable":controller.callbackDisableSpeakerDynamicEnergyThreshold}, - "/controller/callback_enable_check_speaker_threshold": {"status": True, "variable":controller.callbackEnableCheckSpeakerThreshold}, - "/controller/callback_disable_check_speaker_threshold": {"status": True, "variable":controller.callbackDisableCheckSpeakerThreshold}, - "/controller/callback_set_speaker_record_timeout": {"status": True, "variable":controller.callbackSetSpeakerRecordTimeout}, - "/controller/callback_set_speaker_phrase_timeout": {"status": True, "variable":controller.callbackSetSpeakerPhraseTimeout}, - "/controller/callback_set_speaker_max_phrases": {"status": True, "variable":controller.callbackSetSpeakerMaxPhrases}, - "/controller/callback_enable_use_whisper_feature": {"status": True, "variable":controller.callbackEnableUseWhisperFeature}, - "/controller/callback_disable_use_whisper_feature": {"status": True, "variable":controller.callbackDisableUseWhisperFeature}, - "/controller/callback_set_whisper_weight_type": {"status": True, "variable":controller.callbackSetWhisperWeightType}, - "/controller/callback_download_whisper_weight": {"status": True, "variable":controller.callbackDownloadWhisperWeight}, - "/controller/callback_set_overlay_settings_opacity": {"status": True, "variable":controller.callbackSetOverlaySettingsOpacity}, - "/controller/callback_set_overlay_settings_ui_scaling": {"status": True, "variable":controller.callbackSetOverlaySettingsUiScaling}, - "/controller/callback_enable_overlay_small_log": {"status": True, "variable":controller.callbackEnableOverlaySmallLog}, - "/controller/callback_disable_overlay_small_log": {"status": True, "variable":controller.callbackDisableOverlaySmallLog}, - "/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}, - "/controller/callback_set_overlay_small_log_settings_z_pos": {"status": True, "variable":controller.callbackSetOverlaySmallLogSettingsZPos}, - "/controller/callback_set_overlay_small_log_settings_x_rotation": {"status": True, "variable":controller.callbackSetOverlaySmallLogSettingsXRotation}, - "/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}, - "/controller/callback_enable_auto_clear_chatbox": {"status": True, "variable":controller.callbackEnableAutoClearMessageBox}, - "/controller/callback_disable_auto_clear_chatbox": {"status": True, "variable":controller.callbackDisableAutoClearMessageBox}, - "/controller/callback_enable_send_only_translated_messages": {"status": True, "variable":controller.callbackEnableSendOnlyTranslatedMessages}, - "/controller/callback_disable_send_only_translated_messages": {"status": True, "variable":controller.callbackDisableSendOnlyTranslatedMessages}, - "/controller/callback_set_send_message_button_type": {"status": True, "variable":controller.callbackSetSendMessageButtonType}, - "/controller/callback_enable_auto_export_message_logs": {"status": True, "variable":controller.callbackEnableAutoExportMessageLogs}, - "/controller/callback_disable_auto_export_message_logs": {"status": True, "variable":controller.callbackDisableAutoExportMessageLogs}, - "/controller/callback_enable_vrc_mic_mute_sync": {"status": False, "variable":controller.callbackEnableVrcMicMuteSync}, - "/controller/callback_disable_vrc_mic_mute_sync": {"status": False, "variable":controller.callbackDisableVrcMicMuteSync}, - "/controller/callback_enable_send_message_to_vrc": {"status": True, "variable":controller.callbackEnableSendMessageToVrc}, - "/controller/callback_disable_send_message_to_vrc": {"status": True, "variable":controller.callbackDisableSendMessageToVrc}, - "/controller/callback_set_send_message_format": {"status": True, "variable":controller.callbackSetSendMessageFormat}, - "/controller/callback_set_send_message_format_with_t": {"status": True, "variable":controller.callbackSetSendMessageFormatWithT}, - "/controller/callback_set_received_message_format": {"status": True, "variable":controller.callbackSetReceivedMessageFormat}, - "/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}, - "/controller/callback_disable_send_received_message_to_vrc": {"status": True, "variable":controller.callbackDisableSendReceivedMessageToVrc}, - "/controller/callback_enable_logger": {"status": False, "variable":controller.callbackEnableLogger}, - "/controller/callback_disable_logger": {"status": False, "variable":controller.callbackDisableLogger}, - "/controller/callback_set_osc_ip_address": {"status": True, "variable":controller.callbackSetOscIpAddress}, - "/controller/callback_set_osc_port": {"status": True, "variable":controller.callbackSetOscPort}, + "/set/enable_translation": {"status": False, "variable":controller.setEnableTranslation}, + "/set/disable_translation": {"status": False, "variable":controller.setDisableTranslation}, + + "/set/enable_foreground": {"status": True, "variable":controller.setEnableForeground}, + "/set/disable_foreground": {"status": True, "variable":controller.setDisableForeground}, + + "/set/enable_config_window": {"status": True, "variable":controller.setEnableConfigWindow}, + "/set/disable_config_window": {"status": True, "variable":controller.setDisableConfigWindow}, + + "/get/selected_tab_no": {"status": True, "variable":controller.getSelectedTabNo}, + "/set/selected_tab_no": {"status": True, "variable":controller.setSelectedTabNo}, + + "/get/list_translation_engines": {"status": True, "variable":controller.getTranslationEngines}, + "/get/list_languages": {"status": True, "variable":controller.getListLanguageAndCountry}, + "/get/list_mic_host": {"status": True, "variable":controller.getListInputHost}, + "/get/list_mic_device": {"status": True, "variable":controller.getListInputDevice}, + "/get/list_speaker_device": {"status": True, "variable":controller.getListOutputDevice}, + + "/get/selected_translator_engines": {"status": False, "variable":controller.getSelectedTranslatorEngines}, + "/set/selected_translator_engines": {"status": True, "variable":controller.setSelectedTranslatorEngines}, + + "/get/selected_your_languages": {"status": True, "variable":controller.getSelectedYourLanguages}, + "/set/selected_your_languages": {"status": True, "variable":controller.setSelectedYourLanguages}, + + "/get/selected_target_languages": {"status": True, "variable":controller.getSelectedTargetLanguages}, + "/set/selected_target_languages": {"status": True, "variable":controller.setSelectedTargetLanguages}, + + "/get/selected_transcription_engine": {"status": False, "variable":controller.getSelectedTranscriptionEngine}, + + "/get/enable_multi_language_translation": {"status": True, "variable":controller.getEnableMultiLanguageTranslation}, + "/set/enable_multi_language_translation": {"status": True, "variable":controller.setEnableMultiLanguageTranslation}, + "/set/disable_multi_language_translation": {"status": True, "variable":controller.setDisableMultiLanguageTranslation}, + + "/get/enable_convert_message_to_romaji": {"status": True, "variable":controller.getEnableConvertMessageToRomaji}, + "/set/enable_convert_message_to_romaji": {"status": True, "variable":controller.setEnableConvertMessageToRomaji}, + "/set/disable_convert_message_to_romaji": {"status": True, "variable":controller.setDisableConvertMessageToRomaji}, + + "/get/enable_convert_message_to_hiragana": {"status": True, "variable":controller.getEnableConvertMessageToHiragana}, + "/set/enable_convert_message_to_hiragana": {"status": True, "variable":controller.setEnableConvertMessageToHiragana}, + "/set/disable_convert_message_to_hiragana": {"status": True, "variable":controller.setDisableConvertMessageToHiragana}, + + "/get/enable_main_window_sidebar_compact_mode": {"status": True, "variable":controller.getEnableMainWindowSidebarCompactMode}, + "/set/enable_main_window_sidebar_compact_mode": {"status": True, "variable":controller.setEnableMainWindowSidebarCompactMode}, + "/set/disable_main_window_sidebar_compact_mode": {"status": True, "variable":controller.setDisableMainWindowSidebarCompactMode}, + + "/get/transparency": {"status": True, "variable":controller.getTransparency}, + "/set/transparency": {"status": True, "variable":controller.setTransparency}, + + "/get/appearance_theme": {"status": True, "variable":controller.getAppearanceTheme}, + "/set/appearance_theme": {"status": True, "variable":controller.setAppearanceTheme}, + + "/get/ui_scaling": {"status": True, "variable":controller.getUiScaling}, + "/set/ui_scaling": {"status": True, "variable":controller.setUiScaling}, + + "/get/textbox_ui_scaling": {"status": True, "variable":controller.getTextboxUiScaling}, + "/set/textbox_ui_scaling": {"status": True, "variable":controller.setTextboxUiScaling}, + + "/get/message_box_ratio": {"status": True, "variable":controller.getMessageBoxRatio}, + "/set/message_box_ratio": {"status": True, "variable":controller.setMessageBoxRatio}, + + "/get/font_family": {"status": True, "variable":controller.getFontFamily}, + "/set/font_family": {"status": True, "variable":controller.setFontFamily}, + + "/get/ui_language": {"status": True, "variable":controller.getUiLanguage}, + "/set/ui_language": {"status": True, "variable":controller.setUiLanguage}, + + "/get/enable_restore_main_window_geometry": {"status": True, "variable":controller.getEnableRestoreMainWindowGeometry}, + "/set/enable_restore_main_window_geometry": {"status": True, "variable":controller.setEnableRestoreMainWindowGeometry}, + "/set/disable_restore_main_window_geometry": {"status": True, "variable":controller.setDisableRestoreMainWindowGeometry}, + + "/get/main_window_geometry": {"status": True, "variable":controller.getMainWindowGeometry}, + "/set/main_window_geometry": {"status": True, "variable":controller.setMainWindowGeometry}, + + "/get/enable_mic_auto_selection": {"status": True, "variable":controller.getEnableMicAutoSelection}, + "/set/enable_mic_auto_selection": {"status": True, "variable":controller.setEnableMicAutoSelection}, + "/set/disable_mic_auto_selection": {"status": True, "variable":controller.setDisableMicAutoSelection}, + + "/get/choice_mic_host": {"status": True, "variable":controller.getChoiceMicHost}, + "/set/choice_mic_host": {"status": True, "variable":controller.setChoiceMicHost}, + + "/get/choice_mic_device": {"status": True, "variable":controller.getChoiceMicDevice}, + "/set/choice_mic_device": {"status": True, "variable":controller.setChoiceMicDevice}, + + "/get/input_mic_energy_threshold": {"status": True, "variable":controller.getInputMicEnergyThreshold}, + "/set/input_mic_energy_threshold": {"status": True, "variable":controller.setInputMicEnergyThreshold}, + + "/get/input_mic_dynamic_energy_threshold": {"status": True, "variable":controller.getInputMicDynamicEnergyThreshold}, + "/set/enable_input_mic_dynamic_energy_threshold": {"status": True, "variable":controller.setEnableInputMicDynamicEnergyThreshold}, + "/set/disable_input_mic_dynamic_energy_threshold": {"status": True, "variable":controller.setDisableInputMicDynamicEnergyThreshold}, + + "/get/input_mic_record_timeout": {"status": True, "variable":controller.getInputMicRecordTimeout}, + "/set/input_mic_record_timeout": {"status": True, "variable":controller.setInputMicRecordTimeout}, + + "/get/input_mic_phrase_timeout": {"status": True, "variable":controller.getInputMicPhraseTimeout}, + "/set/input_mic_phrase_timeout": {"status": True, "variable":controller.setInputMicPhraseTimeout}, + + "/get/input_mic_max_phrases": {"status": True, "variable":controller.getInputMicMaxPhrases}, + "/set/input_mic_max_phrases": {"status": True, "variable":controller.setInputMicMaxPhrases}, + + "/get/input_mic_word_filter": {"status": True, "variable":controller.getInputMicWordFilter}, + "/set/input_mic_word_filter": {"status": True, "variable":controller.setInputMicWordFilter}, + "/del/input_mic_word_filter": {"status": True, "variable":controller.delInputMicWordFilter}, + + "/get/input_mic_avg_logprob": {"status": True, "variable":controller.getInputMicAvgLogprob}, + "/set/input_mic_avg_logprob": {"status": True, "variable":controller.setInputMicAvgLogprob}, + + "/get/input_mic_no_speech_prob": {"status": True, "variable":controller.getInputMicNoSpeechProb}, + "/set/input_mic_no_speech_prob": {"status": True, "variable":controller.setInputMicNoSpeechProb}, + + "/set/enable_speaker_auto_selection": {"status": True, "variable":controller.setEnableSpeakerAutoSelection}, + "/set/disable_speaker_auto_selection": {"status": True, "variable":controller.setDisableSpeakerAutoSelection}, + + "/get/choice_speaker_device": {"status": True, "variable":controller.getChoiceSpeakerDevice}, + "/set/choice_speaker_device": {"status": True, "variable":controller.setChoiceSpeakerDevice}, + + "/get/input_speaker_energy_threshold": {"status": True, "variable":controller.getInputSpeakerEnergyThreshold}, + "/set/input_speaker_energy_threshold": {"status": True, "variable":controller.setInputSpeakerEnergyThreshold}, + + "/get/input_speaker_dynamic_energy_threshold": {"status": True, "variable":controller.getInputSpeakerDynamicEnergyThreshold}, + "/set/enable_input_speaker_dynamic_energy_threshold": {"status": True, "variable":controller.setEnableInputSpeakerDynamicEnergyThreshold}, + "/set/disable_input_speaker_dynamic_energy_threshold": {"status": True, "variable":controller.setDisableInputSpeakerDynamicEnergyThreshold}, + + "/get/input_speaker_record_timeout": {"status": True, "variable":controller.getInputSpeakerRecordTimeout}, + "/set/input_speaker_record_timeout": {"status": True, "variable":controller.setInputSpeakerRecordTimeout}, + + "/get/input_speaker_phrase_timeout": {"status": True, "variable":controller.getInputSpeakerPhraseTimeout}, + "/set/input_speaker_phrase_timeout": {"status": True, "variable":controller.setInputSpeakerPhraseTimeout}, + + "/get/input_speaker_max_phrases": {"status": True, "variable":controller.getInputSpeakerMaxPhrases}, + "/set/input_speaker_max_phrases": {"status": True, "variable":controller.setInputSpeakerMaxPhrases}, + + "/get/input_speaker_avg_logprob": {"status": True, "variable":controller.getInputSpeakerAvgLogprob}, + "/set/input_speaker_avg_logprob": {"status": True, "variable":controller.setInputSpeakerAvgLogprob}, + + "/get/input_speaker_no_speech_prob": {"status": True, "variable":controller.getInputSpeakerNoSpeechProb}, + "/set/input_speaker_no_speech_prob": {"status": True, "variable":controller.setInputSpeakerNoSpeechProb}, + + "/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/enable_auto_clear_message_box": {"status": True, "variable":controller.getEnableAutoClearMessageBox}, + "/set/enable_auto_clear_message_box": {"status": True, "variable":controller.setEnableAutoClearMessageBox}, + "/set/disable_auto_clear_message_box": {"status": True, "variable":controller.setDisableAutoClearMessageBox}, + + "/get/enable_send_only_translated_messages": {"status": True, "variable":controller.getEnableSendOnlyTranslatedMessages}, + "/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/enable_overlay_small_log": {"status": True, "variable":controller.getEnableOverlaySmallLog}, + "/set/enable_overlay_small_log": {"status": True, "variable":controller.setEnableOverlaySmallLog}, + "/set/disable_overlay_small_log": {"status": True, "variable":controller.setDisableOverlaySmallLog}, + + "/get/enable_send_message_to_vrc": {"status": True, "variable":controller.getEnableSendMessageToVrc}, + "/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/enable_speaker2chatbox_pass": {"status": True, "variable":controller.getEnableSpeaker2ChatboxPass}, + "/set/enable_speaker2chatbox_pass": {"status": True, "variable":controller.setEnableSpeaker2ChatboxPass}, + "/set/disable_speaker2chatbox_pass": {"status": True, "variable":controller.setDisableSpeaker2ChatboxPass}, + + "/get/enable_send_received_message_to_vrc": {"status": True, "variable":controller.getEnableSendReceivedMessageToVrc}, + "/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/enable_logger": {"status": True, "variable":controller.getEnableLogger}, + "/set/enable_logger": {"status": True, "variable":controller.setEnableLogger}, + "/set/disable_logger": {"status": True, "variable":controller.setDisableLogger}, + + "/get/enable_vrc_mic_mute_sync": {"status": True, "variable":controller.getEnableVrcMicMuteSync}, + "/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_messagebox": {"status": False, "variable":controller.sendMessageBox}, + "/run/typing_messagebox": {"status": False, "variable":controller.typingMessageBox}, + "/run/stop_typing_messagebox": {"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 = { - "/controller/callback_update_software": { + "/run/update_software": { "download":"/action/download_software", "update":"/action/update_software" }, - "/controller/callback_close_config_window": { + "/set/disable_config_window": { "mic":"/action/transcription_send_mic_message", "speaker":"/action/transcription_receive_speaker_message", "error_device":"/action/error_device", "error_translation_engine":"/action/error_translation_engine", "word_filter":"/action/word_filter", }, - "/controller/callback_enable_transcription_send": { + "/set/enable_transcription_send": { "mic":"/action/transcription_send_mic_message", "error_device":"/action/error_device", "error_translation_engine":"/action/error_translation_engine", "word_filter":"/action/word_filter", }, - "/controller/callback_enable_transcription_receive": { + "/set/enable_transcription_receive": { "speaker":"/action/transcription_receive_speaker_message", "error_device":"/action/error_device", "error_translation_engine":"/action/error_translation_engine", }, - "/controller/callback_enable_check_mic_threshold": { + "/set/enable_check_mic_threshold": { "mic":"/action/check_mic_threshold_energy", "error_device":"/action/error_device", }, - "/controller/callback_enable_check_speaker_threshold": { + "/set/enable_check_speaker_threshold": { "speaker":"/action/check_speaker_threshold_energy", "error_device":"/action/error_device", }, - "/controller/callback_messagebox_send": { + "/run/send_messagebox": { "error_translation_engine":"/action/error_translation_engine" }, - "/controller/callback_download_ctranslate2_weight": { + "/run/download_ctranslate2_weight": { "download":"/action/download_ctranslate2_weight" }, - "/controller/callback_download_whisper_weight": { + "/run/download_whisper_weight": { "download":"/action/download_whisper_weight" }, - "/controller/callback_enable_mic_automatic_selection": { - "mic":"/controller/callback_set_mic_host", + "/set/enable_mic_auto_selection": { + "mic":"/set/choice_mic_host", }, - "/controller/callback_enable_speaker_automatic_selection": { - "speaker":"/controller/callback_set_speaker_device", + "/set/enable_speaker_auto_selection": { + "speaker":"/set/choice_speaker_device", } } @@ -263,8 +321,7 @@ class Action: class Main: def __init__(self) -> None: - self.queue_config = Queue() - self.queue_controller = Queue() + self.queue = Queue() def receiver(self) -> None: while True: @@ -276,35 +333,15 @@ class Main: data = received_data.get("data", None) data = encodeBase64(data) if data is not None else None printLog(endpoint, {"receive_data":data}) - - match endpoint.split("/")[1]: - case "config": - self.queue_config.put(endpoint) - case "controller": - self.queue_controller.put((endpoint, data)) - case _: - pass + self.queue.put((endpoint, data)) def startReceiver(self) -> None: th_receiver = Thread(target=self.receiver) th_receiver.daemon = True th_receiver.start() - def handleConfigRequest(self, endpoint): - handler = config_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) + def handleRequest(self, endpoint, data=None): + handler = mapping.get(endpoint) if handler is None: response = "Invalid endpoint" status = 404 @@ -325,12 +362,12 @@ class Main: status = 500 return result, status - def configHandler(self) -> None: + def handler(self) -> None: while True: - if not self.queue_config.empty(): - endpoint = self.queue_config.get() + if not self.queue.empty(): try: - result, status = self.handleConfigRequest(endpoint) + endpoint, data = self.queue.get() + result, status = self.handleRequest(endpoint, data) except Exception as e: import traceback with open('error.log', 'a') as f: @@ -339,41 +376,16 @@ class Main: status = 500 if status == 423: - self.queue_config.put(endpoint) + self.queue.put((endpoint, data)) else: printLog(endpoint, {"send_data":result}) printResponse(status, endpoint, result) time.sleep(0.1) - def startConfigHandler(self) -> None: - th_config = Thread(target=self.configHandler) - th_config.daemon = True - th_config.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 startHandler(self) -> None: + th_handler = Thread(target=self.handler) + th_handler.daemon = True + th_handler.start() def loop(self) -> None: while True: @@ -382,21 +394,18 @@ class Main: if __name__ == "__main__": main = Main() main.startReceiver() - main.startConfigHandler() - main.startControllerHandler() + main.startHandler() controller.init({ - "download_ctranslate2": Action(action_mapping["/controller/callback_download_ctranslate2_weight"]).transmit, - "download_whisper": Action(action_mapping["/controller/callback_download_whisper_weight"]).transmit, - "update_selected_mic_device": Action(action_mapping["/controller/callback_enable_mic_automatic_selection"]).transmit, - "update_selected_speaker_device": Action(action_mapping["/controller/callback_enable_speaker_automatic_selection"]).transmit, + "download_ctranslate2": Action(action_mapping["/run/download_ctranslate2_weight"]).transmit, + "download_whisper": Action(action_mapping["/run/download_whisper_weight"]).transmit, + "update_selected_mic_device": Action(action_mapping["/set/enable_mic_auto_selection"]).transmit, + "update_selected_speaker_device": Action(action_mapping["/set/enable_speaker_auto_selection"]).transmit, }) # mappingのすべてのstatusをTrueにする - for key in config_mapping.keys(): - config_mapping[key]["status"] = True - for key in controller_mapping.keys(): - controller_mapping[key]["status"] = True + for key in mapping.keys(): + mapping[key]["status"] = True process = "main" match process: @@ -406,32 +415,27 @@ if __name__ == "__main__": case "test": for _ in range(100): time.sleep(0.5) - endpoint = "/controller/list_mic_host" - result, status = main.handleControllerRequest(endpoint) + endpoint = "/get/list_mic_host" + result, status = main.handleRequest(endpoint) printResponse(status, endpoint, result) case "test_all": import time - for endpoint, value in config_mapping.items(): - result, status = main.handleConfigRequest(endpoint) - printResponse(status, endpoint, result) - time.sleep(0.1) - - for endpoint, value in controller_mapping.items(): + for endpoint, value in mapping.items(): printLog("endpoint", endpoint) match endpoint: - case "/controller/callback_messagebox_send": - # handleControllerRequest("/controller/callback_enable_translation") - # handleControllerRequest("/controller/callback_enable_convert_message_to_romaji") + case "/run/send_messagebox": + # handleRequest("/set/enable_translation") + # handleRequest("/set/enable_convert_message_to_romaji") data = {"id":"123456", "message":"テスト"} - case "/controller/callback_set_translation_engines": + case "/set/selected_translator_engines": data = { "1":"CTranslate2", "2":"CTranslate2", "3":"CTranslate2", } - case "/controller/set_your_language_and_country": + case "/set/selected_your_languages": data = { "1":{ "primary":{ @@ -452,7 +456,7 @@ if __name__ == "__main__": }, }, } - case "/controller/set_target_language_and_country": + case "/set/selected_target_languages": data ={ "1":{ "primary": { @@ -497,85 +501,95 @@ if __name__ == "__main__": }, }, } - case "/controller/callback_set_transparency": + case "/set/transparency": data = 0.5 - case "/controller/callback_set_appearance": + case "/set/appearance": data = "Dark" - case "/controller/callback_set_ui_scaling": + case "/set/ui_scaling": data = 1.5 - case "/controller/callback_set_textbox_ui_scaling": + case "/set/textbox_ui_scaling": data = 1.5 - case "/controller/callback_set_message_box_ratio": + case "/set/message_box_ratio": data = 0.5 - case "/controller/callback_set_font_family": + case "/set/font_family": data = "Yu Gothic UI" - case "/controller/callback_set_ui_language": + case "/set/ui_language": data = "ja" - case "/controller/callback_set_ctranslate2_weight_type": + case "/set/ctranslate2_weight_type": data = "Small" - case "/controller/callback_set_deepl_auth_key": + case "/set/deepl_auth_key": data = "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee:fx" - case "/controller/callback_set_mic_host": + case "/set/choice_mic_host": data = "MME" - case "/controller/callback_set_mic_device": + case "/set/choice_mic_device": data = "マイク (Realtek High Definition Audio)" - case "/controller/callback_set_mic_energy_threshold": + case "/set/input_mic_energy_threshold": data = 0.5 - case "/controller/callback_set_mic_record_timeout": + case "/set/input_mic_record_timeout": + data = 1 + case "/set/input_mic_phrase_timeout": data = 5 - case "/controller/callback_set_mic_phrase_timeout": + case "/set/input_set_mic_max_phrases": data = 5 - case "/controller/callback_set_mic_max_phrases": - data = 5 - case "/controller/callback_set_mic_word_filter": + case "/set/input_mic_word_filter": data = "test0, test1, test2" - case "/controller/callback_delete_mic_word_filter": + case "/del/input_mic_word_filter": data = "test1" - case "/controller/callback_set_speaker_device": + case "/set/choice_speaker_device": data = "スピーカー (Realtek High Definition Audio)" - case "/controller/callback_set_speaker_energy_threshold": + case "/set/input_speaker_energy_threshold": data = 0.5 - case "/controller/callback_set_speaker_record_timeout": + case "/set/input_speaker_record_timeout": data = 5 - case "/controller/callback_set_speaker_phrase_timeout": + case "/set/input_speaker_phrase_timeout": data = 5 - case "/controller/callback_set_speaker_max_phrases": + case "/set/input_speaker_max_phrases": data = 5 - case "/controller/callback_set_whisper_weight_type": + case "/set/whisper_weight_type": data = "base" - case "/controller/callback_set_overlay_settings_opacity": - data = 0.5 - case "/controller/callback_set_overlay_settings_ui_scaling": - data = 1.5 - case "/controller/callback_set_overlay_small_log_settings_x_pos": - data = 0 - case "/controller/callback_set_overlay_small_log_settings_y_pos": - data = 0 - case "/controller/callback_set_overlay_small_log_settings_z_pos": - data = 0 - case "/controller/callback_set_overlay_small_log_settings_x_rotation": - data = 0 - case "/controller/callback_set_overlay_small_log_settings_y_rotation": - data = 0 - case "/controller/callback_set_overlay_small_log_settings_z_rotation": - data = 0 - case "/controller/callback_set_send_message_button_type": + case "/set/overlay_settings": + data = { + "opacity": 0.5, + "ui_scaling": 1.5, + } + case "/set/overlay_small_log_settings": + data = { + "x_pos": 0, + "y_pos": 0, + "z_pos": 0, + "x_rotation": 0, + "y_rotation": 0, + "z_rotation": 0, + "display_duration": 5, + "fadeout_duration": 0.5, + } + case "/set/send_message_button_type": data = "show" - case "/controller/callback_set_send_message_format": + case "/set/send_message_format": data = "[message]" - case "/controller/callback_set_send_message_format_with_t": + case "/set/send_message_format_with_t": data = "[message]([translation])" - case "/controller/callback_set_received_message_format": + case "/set/received_message_format": data = "[message]" - case "/controller/callback_set_received_message_format_with_t": + case "/set/received_message_format_with_t": data = "[message]([translation])" - case "/controller/callback_set_osc_ip_address": + case "/set/osc_ip_address": data = "127.0.0.1" - case "/controller/callback_set_osc_port": + case "/set/osc_port": data = 8000 + case "/set/input_speaker_no_speech_prob": + data = 0.5 + case "/set/input_speaker_avg_logprob": + data = 0.5 + case "/set/input_mic_no_speech_prob": + data = 0.5 + case "/set/input_mic_avg_logprob": + data = 0.5 + case "/set/input_mic_max_phrases": + data = 5 case _: data = None - result, status = main.handleControllerRequest(endpoint, data) + result, status = main.handleRequest(endpoint, data) printResponse(status, endpoint, result) time.sleep(0.5) \ No newline at end of file From ca6514b090bc1ffd741c07bb8016c063c710f0ff Mon Sep 17 00:00:00 2001 From: misyaguziya Date: Fri, 20 Sep 2024 05:14:51 +0900 Subject: [PATCH 2/3] =?UTF-8?q?=F0=9F=91=8D=EF=B8=8F[Update]=20UI:=20backe?= =?UTF-8?q?nd=E3=81=AEendpoint=E3=81=AB=E5=90=88=E3=82=8F=E3=81=9B?= =?UTF-8?q?=E3=81=A6=E4=BF=AE=E6=AD=A3?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src-python/config.py | 476 +++++++++--------- src-python/model.py | 82 +-- src-python/webui_controller.py | 467 +++++++++-------- src-python/webui_mainloop.py | 174 +++---- .../configs/useEnableAutoClearMessageBox.js | 6 +- .../logics/configs/useEnableAutoMicSelect.js | 6 +- .../configs/useEnableAutoSpeakerSelect.js | 6 +- src-ui/logics/configs/useMicDeviceList.js | 2 +- src-ui/logics/configs/useMicHostList.js | 2 +- src-ui/logics/configs/useMicThreshold.js | 10 +- src-ui/logics/configs/useSelectedMicDevice.js | 4 +- src-ui/logics/configs/useSelectedMicHost.js | 4 +- .../configs/useSelectedSpeakerDevice.js | 4 +- .../configs/useSendMessageButtonType.js | 4 +- src-ui/logics/configs/useSoftwareVersion.js | 2 +- src-ui/logics/configs/useSpeakerDeviceList.js | 2 +- src-ui/logics/configs/useSpeakerThreshold.js | 10 +- src-ui/logics/configs/useUiLanguage.js | 4 +- src-ui/logics/useLanguageSettings.js | 14 +- src-ui/logics/useMainFunction.js | 12 +- src-ui/logics/useMessage.js | 2 +- src-ui/logics/useReceiveRoutes.js | 102 ++-- src-ui/logics/useSelectableLanguageList.js | 2 +- src-ui/logics/useVolume.js | 8 +- 24 files changed, 700 insertions(+), 705 deletions(-) diff --git a/src-python/config.py b/src-python/config.py index 1f823e01..047ec968 100644 --- a/src-python/config.py +++ b/src-python/config.py @@ -39,8 +39,8 @@ class Config: return self._VERSION @property - def ENABLE_SPEAKER2CHATBOX_PASS_CONFIRMATION(self): - return self._ENABLE_SPEAKER2CHATBOX_PASS_CONFIRMATION + def SPEAKER2CHATBOX_PASS_CONFIRMATION(self): + return self._SPEAKER2CHATBOX_PASS_CONFIRMATION @property def PATH_LOCAL(self): @@ -293,47 +293,47 @@ class Config: # saveJson(self.PATH_CONFIG, inspect.currentframe().f_code.co_name, value) @property - @json_serializable('ENABLE_MULTI_LANGUAGE_TRANSLATION') - def ENABLE_MULTI_LANGUAGE_TRANSLATION(self): - return self._ENABLE_MULTI_LANGUAGE_TRANSLATION + @json_serializable('MULTI_LANGUAGE_TRANSLATION') + def MULTI_LANGUAGE_TRANSLATION(self): + return self._MULTI_LANGUAGE_TRANSLATION - @ENABLE_MULTI_LANGUAGE_TRANSLATION.setter - def ENABLE_MULTI_LANGUAGE_TRANSLATION(self, value): + @MULTI_LANGUAGE_TRANSLATION.setter + def MULTI_LANGUAGE_TRANSLATION(self, value): 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) @property - @json_serializable('ENABLE_CONVERT_MESSAGE_TO_ROMAJI') - def ENABLE_CONVERT_MESSAGE_TO_ROMAJI(self): - return self._ENABLE_CONVERT_MESSAGE_TO_ROMAJI + @json_serializable('CONVERT_MESSAGE_TO_ROMAJI') + def CONVERT_MESSAGE_TO_ROMAJI(self): + return self._CONVERT_MESSAGE_TO_ROMAJI - @ENABLE_CONVERT_MESSAGE_TO_ROMAJI.setter - def ENABLE_CONVERT_MESSAGE_TO_ROMAJI(self, value): + @CONVERT_MESSAGE_TO_ROMAJI.setter + def CONVERT_MESSAGE_TO_ROMAJI(self, value): 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) @property - @json_serializable('ENABLE_CONVERT_MESSAGE_TO_HIRAGANA') - def ENABLE_CONVERT_MESSAGE_TO_HIRAGANA(self): - return self._ENABLE_CONVERT_MESSAGE_TO_HIRAGANA + @json_serializable('CONVERT_MESSAGE_TO_HIRAGANA') + def CONVERT_MESSAGE_TO_HIRAGANA(self): + return self._CONVERT_MESSAGE_TO_HIRAGANA - @ENABLE_CONVERT_MESSAGE_TO_HIRAGANA.setter - def ENABLE_CONVERT_MESSAGE_TO_HIRAGANA(self, value): + @CONVERT_MESSAGE_TO_HIRAGANA.setter + def CONVERT_MESSAGE_TO_HIRAGANA(self, value): 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) @property - @json_serializable('ENABLE_MAIN_WINDOW_SIDEBAR_COMPACT_MODE') - def ENABLE_MAIN_WINDOW_SIDEBAR_COMPACT_MODE(self): - return self._ENABLE_MAIN_WINDOW_SIDEBAR_COMPACT_MODE + @json_serializable('MAIN_WINDOW_SIDEBAR_COMPACT_MODE') + def MAIN_WINDOW_SIDEBAR_COMPACT_MODE(self): + return self._MAIN_WINDOW_SIDEBAR_COMPACT_MODE - @ENABLE_MAIN_WINDOW_SIDEBAR_COMPACT_MODE.setter - def ENABLE_MAIN_WINDOW_SIDEBAR_COMPACT_MODE(self, value): + @MAIN_WINDOW_SIDEBAR_COMPACT_MODE.setter + def MAIN_WINDOW_SIDEBAR_COMPACT_MODE(self, value): if isinstance(value, bool): - self._ENABLE_MAIN_WINDOW_SIDEBAR_COMPACT_MODE = value + self._MAIN_WINDOW_SIDEBAR_COMPACT_MODE = value saveJson(self.PATH_CONFIG, inspect.currentframe().f_code.co_name, value) ## Config Window @@ -418,14 +418,14 @@ class Config: saveJson(self.PATH_CONFIG, inspect.currentframe().f_code.co_name, value) @property - @json_serializable('ENABLE_RESTORE_MAIN_WINDOW_GEOMETRY') - def ENABLE_RESTORE_MAIN_WINDOW_GEOMETRY(self): - return self._ENABLE_RESTORE_MAIN_WINDOW_GEOMETRY + @json_serializable('RESTORE_MAIN_WINDOW_GEOMETRY') + def RESTORE_MAIN_WINDOW_GEOMETRY(self): + return self._RESTORE_MAIN_WINDOW_GEOMETRY - @ENABLE_RESTORE_MAIN_WINDOW_GEOMETRY.setter - def ENABLE_RESTORE_MAIN_WINDOW_GEOMETRY(self, value): + @RESTORE_MAIN_WINDOW_GEOMETRY.setter + def RESTORE_MAIN_WINDOW_GEOMETRY(self, value): 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) @property @@ -442,223 +442,223 @@ class Config: saveJson(self.PATH_CONFIG, inspect.currentframe().f_code.co_name, self.MAIN_WINDOW_GEOMETRY) @property - @json_serializable('ENABLE_MIC_AUTO_SELECTION') - def ENABLE_MIC_AUTO_SELECTION(self): - return self._ENABLE_MIC_AUTO_SELECTION + @json_serializable('AUTO_MIC_SELECT') + def AUTO_MIC_SELECT(self): + return self._AUTO_MIC_SELECT - @ENABLE_MIC_AUTO_SELECTION.setter - def ENABLE_MIC_AUTO_SELECTION(self, value): + @AUTO_MIC_SELECT.setter + def AUTO_MIC_SELECT(self, value): if isinstance(value, bool): - self._ENABLE_MIC_AUTO_SELECTION = value + self._AUTO_MIC_SELECT = value saveJson(self.PATH_CONFIG, inspect.currentframe().f_code.co_name, value) @property - @json_serializable('CHOICE_MIC_HOST') - def CHOICE_MIC_HOST(self): - return self._CHOICE_MIC_HOST + @json_serializable('SELECTED_MIC_HOST') + def SELECTED_MIC_HOST(self): + return self._SELECTED_MIC_HOST - @CHOICE_MIC_HOST.setter - def CHOICE_MIC_HOST(self, value): + @SELECTED_MIC_HOST.setter + def SELECTED_MIC_HOST(self, value): 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) @property - @json_serializable('CHOICE_MIC_DEVICE') - def CHOICE_MIC_DEVICE(self): - return self._CHOICE_MIC_DEVICE + @json_serializable('SELECTED_MIC_DEVICE') + def SELECTED_MIC_DEVICE(self): + return self._SELECTED_MIC_DEVICE - @CHOICE_MIC_DEVICE.setter - def CHOICE_MIC_DEVICE(self, value): - if value in [device["name"] for device in device_manager.getInputDevices()[self.CHOICE_MIC_HOST]]: - self._CHOICE_MIC_DEVICE = value + @SELECTED_MIC_DEVICE.setter + def SELECTED_MIC_DEVICE(self, value): + if value in [device["name"] for device in device_manager.getInputDevices()[self.SELECTED_MIC_HOST]]: + self._SELECTED_MIC_DEVICE = value saveJson(self.PATH_CONFIG, inspect.currentframe().f_code.co_name, value) @property - @json_serializable('INPUT_MIC_ENERGY_THRESHOLD') - def INPUT_MIC_ENERGY_THRESHOLD(self): - return self._INPUT_MIC_ENERGY_THRESHOLD + @json_serializable('MIC_ENERGY_THRESHOLD') + def MIC_ENERGY_THRESHOLD(self): + return self._MIC_ENERGY_THRESHOLD - @INPUT_MIC_ENERGY_THRESHOLD.setter - def INPUT_MIC_ENERGY_THRESHOLD(self, value): + @MIC_ENERGY_THRESHOLD.setter + def MIC_ENERGY_THRESHOLD(self, value): 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) @property - @json_serializable('INPUT_MIC_DYNAMIC_ENERGY_THRESHOLD') - def INPUT_MIC_DYNAMIC_ENERGY_THRESHOLD(self): - return self._INPUT_MIC_DYNAMIC_ENERGY_THRESHOLD + @json_serializable('MIC_DYNAMIC_ENERGY_THRESHOLD') + def MIC_DYNAMIC_ENERGY_THRESHOLD(self): + return self._MIC_DYNAMIC_ENERGY_THRESHOLD - @INPUT_MIC_DYNAMIC_ENERGY_THRESHOLD.setter - def INPUT_MIC_DYNAMIC_ENERGY_THRESHOLD(self, value): + @MIC_DYNAMIC_ENERGY_THRESHOLD.setter + def MIC_DYNAMIC_ENERGY_THRESHOLD(self, value): 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) @property - @json_serializable('INPUT_MIC_RECORD_TIMEOUT') - def INPUT_MIC_RECORD_TIMEOUT(self): - return self._INPUT_MIC_RECORD_TIMEOUT + @json_serializable('MIC_RECORD_TIMEOUT') + def MIC_RECORD_TIMEOUT(self): + return self._MIC_RECORD_TIMEOUT - @INPUT_MIC_RECORD_TIMEOUT.setter - def INPUT_MIC_RECORD_TIMEOUT(self, value): + @MIC_RECORD_TIMEOUT.setter + def MIC_RECORD_TIMEOUT(self, value): 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) @property - @json_serializable('INPUT_MIC_PHRASE_TIMEOUT') - def INPUT_MIC_PHRASE_TIMEOUT(self): - return self._INPUT_MIC_PHRASE_TIMEOUT + @json_serializable('MIC_PHRASE_TIMEOUT') + def MIC_PHRASE_TIMEOUT(self): + return self._MIC_PHRASE_TIMEOUT - @INPUT_MIC_PHRASE_TIMEOUT.setter - def INPUT_MIC_PHRASE_TIMEOUT(self, value): + @MIC_PHRASE_TIMEOUT.setter + def MIC_PHRASE_TIMEOUT(self, value): 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) @property - @json_serializable('INPUT_MIC_MAX_PHRASES') - def INPUT_MIC_MAX_PHRASES(self): - return self._INPUT_MIC_MAX_PHRASES + @json_serializable('MIC_MAX_PHRASES') + def MIC_MAX_PHRASES(self): + return self._MIC_MAX_PHRASES - @INPUT_MIC_MAX_PHRASES.setter - def INPUT_MIC_MAX_PHRASES(self, value): + @MIC_MAX_PHRASES.setter + def MIC_MAX_PHRASES(self, value): 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) @property - @json_serializable('INPUT_MIC_WORD_FILTER') - def INPUT_MIC_WORD_FILTER(self): - return self._INPUT_MIC_WORD_FILTER + @json_serializable('MIC_WORD_FILTER') + def MIC_WORD_FILTER(self): + return self._MIC_WORD_FILTER - @INPUT_MIC_WORD_FILTER.setter - def INPUT_MIC_WORD_FILTER(self, value): + @MIC_WORD_FILTER.setter + def MIC_WORD_FILTER(self, value): 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) @property - @json_serializable('INPUT_MIC_AVG_LOGPROB') - def INPUT_MIC_AVG_LOGPROB(self): - return self._INPUT_MIC_AVG_LOGPROB + @json_serializable('MIC_AVG_LOGPROB') + def MIC_AVG_LOGPROB(self): + return self._MIC_AVG_LOGPROB - @INPUT_MIC_AVG_LOGPROB.setter - def INPUT_MIC_AVG_LOGPROB(self, value): + @MIC_AVG_LOGPROB.setter + def MIC_AVG_LOGPROB(self, value): 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) @property - @json_serializable('INPUT_MIC_NO_SPEECH_PROB') - def INPUT_MIC_NO_SPEECH_PROB(self): - return self._INPUT_MIC_NO_SPEECH_PROB + @json_serializable('MIC_NO_SPEECH_PROB') + def MIC_NO_SPEECH_PROB(self): + return self._MIC_NO_SPEECH_PROB - @INPUT_MIC_NO_SPEECH_PROB.setter - def INPUT_MIC_NO_SPEECH_PROB(self, value): + @MIC_NO_SPEECH_PROB.setter + def MIC_NO_SPEECH_PROB(self, value): 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) @property - @json_serializable('ENABLE_SPEAKER_AUTO_SELECTION') - def ENABLE_SPEAKER_AUTO_SELECTION(self): - return self._ENABLE_SPEAKER_AUTO_SELECTION + @json_serializable('AUTO_SPEAKER_SELECT') + def AUTO_SPEAKER_SELECT(self): + return self._AUTO_SPEAKER_SELECT - @ENABLE_SPEAKER_AUTO_SELECTION.setter - def ENABLE_SPEAKER_AUTO_SELECTION(self, value): + @AUTO_SPEAKER_SELECT.setter + def AUTO_SPEAKER_SELECT(self, value): if isinstance(value, bool): - self._ENABLE_SPEAKER_AUTO_SELECTION = value + self._AUTO_SPEAKER_SELECT = value saveJson(self.PATH_CONFIG, inspect.currentframe().f_code.co_name, value) @property - @json_serializable('CHOICE_SPEAKER_DEVICE') - def CHOICE_SPEAKER_DEVICE(self): - return self._CHOICE_SPEAKER_DEVICE + @json_serializable('SELECTED_SPEAKER_DEVICE') + def SELECTED_SPEAKER_DEVICE(self): + return self._SELECTED_SPEAKER_DEVICE - @CHOICE_SPEAKER_DEVICE.setter - def CHOICE_SPEAKER_DEVICE(self, value): + @SELECTED_SPEAKER_DEVICE.setter + def SELECTED_SPEAKER_DEVICE(self, value): 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) @property - @json_serializable('INPUT_SPEAKER_ENERGY_THRESHOLD') - def INPUT_SPEAKER_ENERGY_THRESHOLD(self): - return self._INPUT_SPEAKER_ENERGY_THRESHOLD + @json_serializable('SPEAKER_ENERGY_THRESHOLD') + def SPEAKER_ENERGY_THRESHOLD(self): + return self._SPEAKER_ENERGY_THRESHOLD - @INPUT_SPEAKER_ENERGY_THRESHOLD.setter - def INPUT_SPEAKER_ENERGY_THRESHOLD(self, value): + @SPEAKER_ENERGY_THRESHOLD.setter + def SPEAKER_ENERGY_THRESHOLD(self, value): 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) @property - @json_serializable('INPUT_SPEAKER_DYNAMIC_ENERGY_THRESHOLD') - def INPUT_SPEAKER_DYNAMIC_ENERGY_THRESHOLD(self): - return self._INPUT_SPEAKER_DYNAMIC_ENERGY_THRESHOLD + @json_serializable('SPEAKER_DYNAMIC_ENERGY_THRESHOLD') + def SPEAKER_DYNAMIC_ENERGY_THRESHOLD(self): + return self._SPEAKER_DYNAMIC_ENERGY_THRESHOLD - @INPUT_SPEAKER_DYNAMIC_ENERGY_THRESHOLD.setter - def INPUT_SPEAKER_DYNAMIC_ENERGY_THRESHOLD(self, value): + @SPEAKER_DYNAMIC_ENERGY_THRESHOLD.setter + def SPEAKER_DYNAMIC_ENERGY_THRESHOLD(self, value): 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) @property - @json_serializable('INPUT_SPEAKER_RECORD_TIMEOUT') - def INPUT_SPEAKER_RECORD_TIMEOUT(self): - return self._INPUT_SPEAKER_RECORD_TIMEOUT + @json_serializable('SPEAKER_RECORD_TIMEOUT') + def SPEAKER_RECORD_TIMEOUT(self): + return self._SPEAKER_RECORD_TIMEOUT - @INPUT_SPEAKER_RECORD_TIMEOUT.setter - def INPUT_SPEAKER_RECORD_TIMEOUT(self, value): + @SPEAKER_RECORD_TIMEOUT.setter + def SPEAKER_RECORD_TIMEOUT(self, value): 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) @property - @json_serializable('INPUT_SPEAKER_PHRASE_TIMEOUT') - def INPUT_SPEAKER_PHRASE_TIMEOUT(self): - return self._INPUT_SPEAKER_PHRASE_TIMEOUT + @json_serializable('SPEAKER_PHRASE_TIMEOUT') + def SPEAKER_PHRASE_TIMEOUT(self): + return self._SPEAKER_PHRASE_TIMEOUT - @INPUT_SPEAKER_PHRASE_TIMEOUT.setter - def INPUT_SPEAKER_PHRASE_TIMEOUT(self, value): + @SPEAKER_PHRASE_TIMEOUT.setter + def SPEAKER_PHRASE_TIMEOUT(self, value): 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) @property - @json_serializable('INPUT_SPEAKER_MAX_PHRASES') - def INPUT_SPEAKER_MAX_PHRASES(self): - return self._INPUT_SPEAKER_MAX_PHRASES + @json_serializable('SPEAKER_MAX_PHRASES') + def SPEAKER_MAX_PHRASES(self): + return self._SPEAKER_MAX_PHRASES - @INPUT_SPEAKER_MAX_PHRASES.setter - def INPUT_SPEAKER_MAX_PHRASES(self, value): + @SPEAKER_MAX_PHRASES.setter + def SPEAKER_MAX_PHRASES(self, value): 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) @property - @json_serializable('INPUT_SPEAKER_AVG_LOGPROB') - def INPUT_SPEAKER_AVG_LOGPROB(self): - return self._INPUT_SPEAKER_AVG_LOGPROB + @json_serializable('SPEAKER_AVG_LOGPROB') + def SPEAKER_AVG_LOGPROB(self): + return self._SPEAKER_AVG_LOGPROB - @INPUT_SPEAKER_AVG_LOGPROB.setter - def INPUT_SPEAKER_AVG_LOGPROB(self, value): + @SPEAKER_AVG_LOGPROB.setter + def SPEAKER_AVG_LOGPROB(self, value): 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) @property - @json_serializable('INPUT_SPEAKER_NO_SPEECH_PROB') - def INPUT_SPEAKER_NO_SPEECH_PROB(self): - return self._INPUT_SPEAKER_NO_SPEECH_PROB + @json_serializable('SPEAKER_NO_SPEECH_PROB') + def SPEAKER_NO_SPEECH_PROB(self): + return self._SPEAKER_NO_SPEECH_PROB - @INPUT_SPEAKER_NO_SPEECH_PROB.setter - def INPUT_SPEAKER_NO_SPEECH_PROB(self, value): + @SPEAKER_NO_SPEECH_PROB.setter + def SPEAKER_NO_SPEECH_PROB(self, value): 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) @property @@ -753,25 +753,25 @@ class Config: saveJson(self.PATH_CONFIG, inspect.currentframe().f_code.co_name, value) @property - @json_serializable('ENABLE_AUTO_CLEAR_MESSAGE_BOX') - def ENABLE_AUTO_CLEAR_MESSAGE_BOX(self): - return self._ENABLE_AUTO_CLEAR_MESSAGE_BOX + @json_serializable('AUTO_CLEAR_MESSAGE_BOX') + def AUTO_CLEAR_MESSAGE_BOX(self): + return self._AUTO_CLEAR_MESSAGE_BOX - @ENABLE_AUTO_CLEAR_MESSAGE_BOX.setter - def ENABLE_AUTO_CLEAR_MESSAGE_BOX(self, value): + @AUTO_CLEAR_MESSAGE_BOX.setter + def AUTO_CLEAR_MESSAGE_BOX(self, value): 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) @property - @json_serializable('ENABLE_SEND_ONLY_TRANSLATED_MESSAGES') - def ENABLE_SEND_ONLY_TRANSLATED_MESSAGES(self): - return self._ENABLE_SEND_ONLY_TRANSLATED_MESSAGES + @json_serializable('SEND_ONLY_TRANSLATED_MESSAGES') + def SEND_ONLY_TRANSLATED_MESSAGES(self): + return self._SEND_ONLY_TRANSLATED_MESSAGES - @ENABLE_SEND_ONLY_TRANSLATED_MESSAGES.setter - def ENABLE_SEND_ONLY_TRANSLATED_MESSAGES(self, value): + @SEND_ONLY_TRANSLATED_MESSAGES.setter + def SEND_ONLY_TRANSLATED_MESSAGES(self, value): 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) @property @@ -799,14 +799,14 @@ class Config: saveJson(self.PATH_CONFIG, inspect.currentframe().f_code.co_name, self.OVERLAY_SETTINGS) @property - @json_serializable('ENABLE_OVERLAY_SMALL_LOG') - def ENABLE_OVERLAY_SMALL_LOG(self): - return self._ENABLE_OVERLAY_SMALL_LOG + @json_serializable('OVERLAY_SMALL_LOG') + def OVERLAY_SMALL_LOG(self): + return self._OVERLAY_SMALL_LOG - @ENABLE_OVERLAY_SMALL_LOG.setter - def ENABLE_OVERLAY_SMALL_LOG(self, value): + @OVERLAY_SMALL_LOG.setter + def OVERLAY_SMALL_LOG(self, value): 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) @property @@ -839,14 +839,14 @@ class Config: # saveJson(self.PATH_CONFIG, inspect.currentframe().f_code.co_name, value) @property - @json_serializable('ENABLE_SEND_MESSAGE_TO_VRC') - def ENABLE_SEND_MESSAGE_TO_VRC(self): - return self._ENABLE_SEND_MESSAGE_TO_VRC + @json_serializable('SEND_MESSAGE_TO_VRC') + def SEND_MESSAGE_TO_VRC(self): + return self._SEND_MESSAGE_TO_VRC - @ENABLE_SEND_MESSAGE_TO_VRC.setter - def ENABLE_SEND_MESSAGE_TO_VRC(self, value): + @SEND_MESSAGE_TO_VRC.setter + def SEND_MESSAGE_TO_VRC(self, value): 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) @property @@ -903,60 +903,60 @@ class Config: # Speaker2Chatbox------------------ @property - @json_serializable('ENABLE_SPEAKER2CHATBOX_PASS') - def ENABLE_SPEAKER2CHATBOX_PASS(self): - return self._ENABLE_SPEAKER2CHATBOX_PASS + @json_serializable('SPEAKER2CHATBOX_PASS') + def SPEAKER2CHATBOX_PASS(self): + return self._SPEAKER2CHATBOX_PASS - @ENABLE_SPEAKER2CHATBOX_PASS.setter - def ENABLE_SPEAKER2CHATBOX_PASS(self, value): + @SPEAKER2CHATBOX_PASS.setter + def SPEAKER2CHATBOX_PASS(self, value): if isinstance(value, str): - self._ENABLE_SPEAKER2CHATBOX_PASS = value + self._SPEAKER2CHATBOX_PASS = value saveJson(self.PATH_CONFIG, inspect.currentframe().f_code.co_name, value) @property - @json_serializable('ENABLE_SEND_RECEIVED_MESSAGE_TO_VRC') - def ENABLE_SEND_RECEIVED_MESSAGE_TO_VRC(self): - return self._ENABLE_SEND_RECEIVED_MESSAGE_TO_VRC + @json_serializable('SEND_RECEIVED_MESSAGE_TO_VRC') + def SEND_RECEIVED_MESSAGE_TO_VRC(self): + return self._SEND_RECEIVED_MESSAGE_TO_VRC - @ENABLE_SEND_RECEIVED_MESSAGE_TO_VRC.setter - def ENABLE_SEND_RECEIVED_MESSAGE_TO_VRC(self, value): + @SEND_RECEIVED_MESSAGE_TO_VRC.setter + def SEND_RECEIVED_MESSAGE_TO_VRC(self, value): if isinstance(value, bool): if self._ENABLE_SPEAKER2CHATBOX is True: - self._ENABLE_SEND_RECEIVED_MESSAGE_TO_VRC = value + self._SEND_RECEIVED_MESSAGE_TO_VRC = value 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) # Speaker2Chatbox------------------ @property - @json_serializable('ENABLE_LOGGER') - def ENABLE_LOGGER(self): - return self._ENABLE_LOGGER + @json_serializable('LOGGER') + def LOGGER(self): + return self._LOGGER - @ENABLE_LOGGER.setter - def ENABLE_LOGGER(self, value): + @LOGGER.setter + def LOGGER(self, value): if isinstance(value, bool): - self._ENABLE_LOGGER = value + self._LOGGER = value saveJson(self.PATH_CONFIG, inspect.currentframe().f_code.co_name, value) @property - @json_serializable('ENABLE_VRC_MIC_MUTE_SYNC') - def ENABLE_VRC_MIC_MUTE_SYNC(self): - return self._ENABLE_VRC_MIC_MUTE_SYNC + @json_serializable('VRC_MIC_MUTE_SYNC') + def VRC_MIC_MUTE_SYNC(self): + return self._VRC_MIC_MUTE_SYNC - @ENABLE_VRC_MIC_MUTE_SYNC.setter - def ENABLE_VRC_MIC_MUTE_SYNC(self, value): + @VRC_MIC_MUTE_SYNC.setter + def VRC_MIC_MUTE_SYNC(self, value): 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) def init_config(self): # Read Only self._VERSION = "2.2.5" self._ENABLE_SPEAKER2CHATBOX = False # Speaker2Chatbox - self._ENABLE_SPEAKER2CHATBOX_PASS_CONFIRMATION = "VRCT=0YEN" + self._SPEAKER2CHATBOX_PASS_CONFIRMATION = "VRCT=0YEN" if getattr(sys, 'frozen', False): self._PATH_LOCAL = os_path.dirname(sys.executable) else: @@ -1080,10 +1080,10 @@ class Config: }, } self._SELECTED_TRANSCRIPTION_ENGINE = "Google" - self._ENABLE_MULTI_LANGUAGE_TRANSLATION = False - self._ENABLE_CONVERT_MESSAGE_TO_ROMAJI = False - self._ENABLE_CONVERT_MESSAGE_TO_HIRAGANA = False - self._ENABLE_MAIN_WINDOW_SIDEBAR_COMPACT_MODE = False + self._MULTI_LANGUAGE_TRANSLATION = False + self._CONVERT_MESSAGE_TO_ROMAJI = False + self._CONVERT_MESSAGE_TO_HIRAGANA = False + self._MAIN_WINDOW_SIDEBAR_COMPACT_MODE = False ## Config Window self._TRANSPARENCY = 100 @@ -1093,33 +1093,33 @@ class Config: self._MESSAGE_BOX_RATIO = 10 self._FONT_FAMILY = "Yu Gothic UI" self._UI_LANGUAGE = "en" - self._ENABLE_RESTORE_MAIN_WINDOW_GEOMETRY = True + self._RESTORE_MAIN_WINDOW_GEOMETRY = True self._MAIN_WINDOW_GEOMETRY = { "x_pos": "0", "y_pos": "0", "width": "870", "height": "654", } - self._ENABLE_MIC_AUTO_SELECTION = True - self._CHOICE_MIC_HOST = device_manager.getDefaultInputDevice()["host"]["name"] - self._CHOICE_MIC_DEVICE = device_manager.getDefaultInputDevice()["device"]["name"] - self._INPUT_MIC_ENERGY_THRESHOLD = 300 - self._INPUT_MIC_DYNAMIC_ENERGY_THRESHOLD = False - self._INPUT_MIC_RECORD_TIMEOUT = 3 - self._INPUT_MIC_PHRASE_TIMEOUT = 3 - self._INPUT_MIC_MAX_PHRASES = 10 - self._INPUT_MIC_WORD_FILTER = [] - self._INPUT_MIC_AVG_LOGPROB=-0.8 - self._INPUT_MIC_NO_SPEECH_PROB=0.6 - self._ENABLE_SPEAKER_AUTO_SELECTION = True - self._CHOICE_SPEAKER_DEVICE = device_manager.getDefaultOutputDevice()["device"]["name"] - self._INPUT_SPEAKER_ENERGY_THRESHOLD = 300 - self._INPUT_SPEAKER_DYNAMIC_ENERGY_THRESHOLD = False - self._INPUT_SPEAKER_RECORD_TIMEOUT = 3 - self._INPUT_SPEAKER_PHRASE_TIMEOUT = 3 - self._INPUT_SPEAKER_MAX_PHRASES = 10 - self._INPUT_SPEAKER_AVG_LOGPROB=-0.8 - self._INPUT_SPEAKER_NO_SPEECH_PROB=0.6 + self._AUTO_MIC_SELECT = True + self._SELECTED_MIC_HOST = device_manager.getDefaultInputDevice()["host"]["name"] + self._SELECTED_MIC_DEVICE = device_manager.getDefaultInputDevice()["device"]["name"] + self._MIC_ENERGY_THRESHOLD = 300 + self._MIC_DYNAMIC_ENERGY_THRESHOLD = False + self._MIC_RECORD_TIMEOUT = 3 + self._MIC_PHRASE_TIMEOUT = 3 + self._MIC_MAX_PHRASES = 10 + self._MIC_WORD_FILTER = [] + self._MIC_AVG_LOGPROB=-0.8 + self._MIC_NO_SPEECH_PROB=0.6 + self._AUTO_SPEAKER_SELECT = True + self._SELECTED_SPEAKER_DEVICE = device_manager.getDefaultOutputDevice()["device"]["name"] + self._SPEAKER_ENERGY_THRESHOLD = 300 + self._SPEAKER_DYNAMIC_ENERGY_THRESHOLD = False + self._SPEAKER_RECORD_TIMEOUT = 3 + self._SPEAKER_PHRASE_TIMEOUT = 3 + self._SPEAKER_MAX_PHRASES = 10 + self._SPEAKER_AVG_LOGPROB=-0.8 + self._SPEAKER_NO_SPEECH_PROB=0.6 self._OSC_IP_ADDRESS = "127.0.0.1" self._OSC_PORT = 9000 self._AUTH_KEYS = { @@ -1134,14 +1134,14 @@ class Config: self._SEND_MESSAGE_FORMAT_WITH_T = "[message]([translation])" self._RECEIVED_MESSAGE_FORMAT = "[message]" self._RECEIVED_MESSAGE_FORMAT_WITH_T = "[message]([translation])" - self._ENABLE_AUTO_CLEAR_MESSAGE_BOX = True - self._ENABLE_SEND_ONLY_TRANSLATED_MESSAGES = False + self._AUTO_CLEAR_MESSAGE_BOX = True + self._SEND_ONLY_TRANSLATED_MESSAGES = False self._SEND_MESSAGE_BUTTON_TYPE = "show" self._OVERLAY_SETTINGS = { "opacity": 1.0, "ui_scaling": 1.0, } - self._ENABLE_OVERLAY_SMALL_LOG = False + self._OVERLAY_SMALL_LOG = False self._OVERLAY_SMALL_LOG_SETTINGS = { "x_pos": 0.0, "y_pos": 0.0, @@ -1153,11 +1153,11 @@ class Config: "fadeout_duration": 2, } self._OVERLAY_UI_TYPE = "default" - self._ENABLE_SEND_MESSAGE_TO_VRC = True - self._ENABLE_SEND_RECEIVED_MESSAGE_TO_VRC = False # Speaker2Chatbox - self._ENABLE_SPEAKER2CHATBOX_PASS = "000000000" - self._ENABLE_LOGGER = False - self._ENABLE_VRC_MIC_MUTE_SYNC = False + self._SEND_MESSAGE_TO_VRC = True + self._SEND_RECEIVED_MESSAGE_TO_VRC = False # Speaker2Chatbox + self._SPEAKER2CHATBOX_PASS = "000000000" + self._LOGGER = False + self._VRC_MIC_MUTE_SYNC = False def load_config(self): if os_path.isfile(self.PATH_CONFIG) is not False: @@ -1170,8 +1170,8 @@ class Config: old_message_format = config[key] setattr(self, key, config[key]) - if key == "ENABLE_SPEAKER2CHATBOX_PASS": - if self.ENABLE_SPEAKER2CHATBOX_PASS_CONFIRMATION == config[key]: + if key == "SPEAKER2CHATBOX_PASS": + if self.SPEAKER2CHATBOX_PASS_CONFIRMATION == config[key]: self.ENABLE_SPEAKER2CHATBOX = True if old_message_format is not None: diff --git a/src-python/model.py b/src-python/model.py index 116a3a99..f652b170 100644 --- a/src-python/model.py +++ b/src-python/model.py @@ -220,7 +220,7 @@ class Model: translations = [] success_flags = [] 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_country = target_languages[key]["country"] if target_language is not None or target_country is not None: @@ -252,7 +252,7 @@ class Model: return [translation], success_flag def addKeywords(self): - for f in config.INPUT_MIC_WORD_FILTER: + for f in config.MIC_WORD_FILTER: self.keyword_processor.add_keyword(f) def checkKeywords(self, message): @@ -412,11 +412,11 @@ class Model: return result 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 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 def getListOutputDevice(self): @@ -424,33 +424,33 @@ class Model: return result def startMicTranscript(self, fnc): - if config.ENABLE_MIC_AUTO_SELECTION is True: + if config.AUTO_MIC_SELECT is True: default_device = device_manager.getDefaultInputDevice() mic_host_name = default_device["host"]["name"] mic_device_name = default_device["device"]["name"] else: - mic_host_name = config.CHOICE_MIC_HOST - mic_device_name = config.CHOICE_MIC_DEVICE + mic_host_name = config.SELECTED_MIC_HOST + mic_device_name = config.SELECTED_MIC_DEVICE 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 self.mic_audio_queue = Queue() # self.mic_energy_queue = Queue() - mic_device = choice_mic_device[0] - record_timeout = config.INPUT_MIC_RECORD_TIMEOUT - phrase_timeout = config.INPUT_MIC_PHRASE_TIMEOUT + mic_device = selected_mic_device[0] + record_timeout = config.MIC_RECORD_TIMEOUT + phrase_timeout = config.MIC_PHRASE_TIMEOUT if record_timeout > phrase_timeout: record_timeout = phrase_timeout self.mic_audio_recorder = SelectedMicEnergyAndAudioRecorder( device=mic_device, - energy_threshold=config.INPUT_MIC_ENERGY_THRESHOLD, - dynamic_energy_threshold=config.INPUT_MIC_DYNAMIC_ENERGY_THRESHOLD, + energy_threshold=config.MIC_ENERGY_THRESHOLD, + dynamic_energy_threshold=config.MIC_DYNAMIC_ENERGY_THRESHOLD, record_timeout=record_timeout, ) # self.mic_audio_recorder.recordIntoQueue(self.mic_audio_queue, mic_energy_queue) @@ -459,7 +459,7 @@ class Model: speaker=False, source=self.mic_audio_recorder.source, phrase_timeout=phrase_timeout, - max_phrases=config.INPUT_MIC_MAX_PHRASES, + max_phrases=config.MIC_MAX_PHRASES, transcription_engine=config.SELECTED_TRANSCRIPTION_ENGINE, root=config.PATH_LOCAL, whisper_weight_type=config.WHISPER_WEIGHT_TYPE, @@ -470,8 +470,8 @@ class Model: self.mic_audio_queue, config.SELECTED_YOUR_LANGUAGES[config.SELECTED_TAB_NO]["primary"]["language"], config.SELECTED_YOUR_LANGUAGES[config.SELECTED_TAB_NO]["primary"]["country"], - config.INPUT_MIC_AVG_LOGPROB, - config.INPUT_MIC_NO_SPEECH_PROB + config.MIC_AVG_LOGPROB, + config.MIC_NO_SPEECH_PROB ) if res: message = self.mic_transcriber.getTranscript() @@ -531,7 +531,7 @@ class Model: self.mic_audio_recorder.pause() 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: self.pauseMicTranscript() elif self.mic_mute_status is False: @@ -558,18 +558,18 @@ class Model: if isinstance(fnc, Callable): self.check_mic_energy_fnc = fnc - if config.ENABLE_MIC_AUTO_SELECTION is True: + if config.AUTO_MIC_SELECT is True: default_device = device_manager.getDefaultInputDevice() mic_host_name = default_device["host"]["name"] mic_device_name = default_device["device"]["name"] else: - mic_host_name = config.CHOICE_MIC_HOST - mic_device_name = config.CHOICE_MIC_DEVICE + mic_host_name = config.SELECTED_MIC_HOST + mic_device_name = config.SELECTED_MIC_DEVICE 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 def sendMicEnergy(): @@ -582,7 +582,7 @@ class Model: sleep(0.01) 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.recordIntoQueue(mic_energy_queue) self.mic_energy_plot_progressbar = threadFnc(sendMicEnergy) @@ -600,30 +600,30 @@ class Model: self.mic_energy_recorder = None def startSpeakerTranscript(self, fnc): - if config.ENABLE_SPEAKER_AUTO_SELECTION is True: + if config.AUTO_SPEAKER_SELECT is True: default_device = device_manager.getDefaultOutputDevice() speaker_device_name = default_device["device"]["name"] else: - speaker_device_name = config.CHOICE_SPEAKER_DEVICE + speaker_device_name = config.SELECTED_SPEAKER_DEVICE 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 speaker_audio_queue = Queue() # speaker_energy_queue = Queue() - speaker_device = choice_speaker_device[0] - record_timeout = config.INPUT_SPEAKER_RECORD_TIMEOUT - phrase_timeout = config.INPUT_SPEAKER_PHRASE_TIMEOUT + speaker_device = selected_speaker_device[0] + record_timeout = config.SPEAKER_RECORD_TIMEOUT + phrase_timeout = config.SPEAKER_PHRASE_TIMEOUT if record_timeout > phrase_timeout: record_timeout = phrase_timeout self.speaker_audio_recorder = SelectedSpeakerEnergyAndAudioRecorder( device=speaker_device, - energy_threshold=config.INPUT_SPEAKER_ENERGY_THRESHOLD, - dynamic_energy_threshold=config.INPUT_SPEAKER_DYNAMIC_ENERGY_THRESHOLD, + energy_threshold=config.SPEAKER_ENERGY_THRESHOLD, + dynamic_energy_threshold=config.SPEAKER_DYNAMIC_ENERGY_THRESHOLD, record_timeout=record_timeout, ) # self.speaker_audio_recorder.recordIntoQueue(speaker_audio_queue, speaker_energy_queue) @@ -632,7 +632,7 @@ class Model: speaker=True, source=self.speaker_audio_recorder.source, phrase_timeout=phrase_timeout, - max_phrases=config.INPUT_SPEAKER_MAX_PHRASES, + max_phrases=config.SPEAKER_MAX_PHRASES, transcription_engine=config.SELECTED_TRANSCRIPTION_ENGINE, root=config.PATH_LOCAL, whisper_weight_type=config.WHISPER_WEIGHT_TYPE, @@ -643,8 +643,8 @@ class Model: speaker_audio_queue, config.SELECTED_TARGET_LANGUAGES[config.SELECTED_TAB_NO]["primary"]["language"], config.SELECTED_TARGET_LANGUAGES[config.SELECTED_TAB_NO]["primary"]["country"], - config.INPUT_SPEAKER_AVG_LOGPROB, - config.INPUT_SPEAKER_NO_SPEECH_PROB + config.SPEAKER_AVG_LOGPROB, + config.SPEAKER_NO_SPEECH_PROB ) if res: message = self.speaker_transcriber.getTranscript() @@ -692,16 +692,16 @@ class Model: if isinstance(fnc, Callable): self.check_speaker_energy_fnc = fnc - if config.ENABLE_SPEAKER_AUTO_SELECTION is True: + if config.AUTO_SPEAKER_SELECT is True: default_device = device_manager.getDefaultOutputDevice() speaker_device_name = default_device["device"]["name"] else: - speaker_device_name = config.CHOICE_SPEAKER_DEVICE + speaker_device_name = config.SELECTED_SPEAKER_DEVICE 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 def sendSpeakerEnergy(): @@ -714,7 +714,7 @@ class Model: sleep(0.01) 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.recordIntoQueue(speaker_energy_queue) self.speaker_energy_plot_progressbar = threadFnc(sendSpeakerEnergy) diff --git a/src-python/webui_controller.py b/src-python/webui_controller.py index 33943c5e..734cd796 100644 --- a/src-python/webui_controller.py +++ b/src-python/webui_controller.py @@ -40,8 +40,8 @@ class UpdateSelectedMicDevice: self.action = action def set(self, host, device) -> None: - config.CHOICE_MIC_HOST = host - config.CHOICE_MIC_DEVICE = device + config.SELECTED_MIC_HOST = host + config.SELECTED_MIC_DEVICE = device printLog("Update Host/Mic Device", f"{host}/{device}") self.action("mic", { "status":200, @@ -53,7 +53,7 @@ class UpdateSelectedSpeakerDevice: self.action = action def set(self, device) -> None: - config.CHOICE_SPEAKER_DEVICE = device + config.SELECTED_SPEAKER_DEVICE = device printLog("Update Speaker Device", device) self.action("speaker", { "status":200, @@ -132,13 +132,13 @@ class MicMessage: } }) - if config.ENABLE_CONVERT_MESSAGE_TO_ROMAJI is True or config.ENABLE_CONVERT_MESSAGE_TO_HIRAGANA is True: + if config.CONVERT_MESSAGE_TO_ROMAJI is True or config.CONVERT_MESSAGE_TO_HIRAGANA is True: if config.SELECTED_TARGET_LANGUAGES[config.SELECTED_TAB_NO]["primary"]["language"] == "Japanese": transliteration = model.convertMessageToTransliteration(translation[0]) if config.ENABLE_TRANSCRIPTION_SEND is True: - if config.ENABLE_SEND_MESSAGE_TO_VRC is True: - if config.ENABLE_SEND_ONLY_TRANSLATED_MESSAGES is True: + if config.SEND_MESSAGE_TO_VRC is True: + if config.SEND_ONLY_TRANSLATED_MESSAGES is True: if config.ENABLE_TRANSLATION is False: osc_message = messageFormatter("SEND", "", [message]) else: @@ -155,12 +155,12 @@ class MicMessage: "transliteration":transliteration } }) - if config.ENABLE_LOGGER is True: + if config.LOGGER is True: if len(translation) > 0: translation = " (" + "/".join(translation) + ")" model.logger.info(f"[SENT] {message}{translation}") - # if config.ENABLE_OVERLAY_SMALL_LOG is True: + # if config.OVERLAY_SMALL_LOG is True: # overlay_image = model.createOverlayImageShort(message, translation) # model.updateOverlay(overlay_image) # overlay_image = model.createOverlayImageLong("send", message, translation) @@ -196,12 +196,12 @@ class SpeakerMessage: } }) - if config.ENABLE_CONVERT_MESSAGE_TO_ROMAJI is True or config.ENABLE_CONVERT_MESSAGE_TO_HIRAGANA is True: + if config.CONVERT_MESSAGE_TO_ROMAJI is True or config.CONVERT_MESSAGE_TO_HIRAGANA is True: if config.SELECTED_TARGET_LANGUAGES[config.SELECTED_TAB_NO]["primary"]["language"] == "Japanese": transliteration = model.convertMessageToTransliteration(message) if config.ENABLE_TRANSCRIPTION_RECEIVE is True: - if config.ENABLE_OVERLAY_SMALL_LOG is True: + if config.OVERLAY_SMALL_LOG is True: if model.overlay.initialized is True: overlay_image = model.createOverlayImageShort(message, translation) model.updateOverlay(overlay_image) @@ -211,7 +211,7 @@ class SpeakerMessage: # ------------Speaker2Chatbox------------ if config.ENABLE_SPEAKER2CHATBOX is True: # send OSC message - if config.ENABLE_SEND_RECEIVED_MESSAGE_TO_VRC is True: + if config.SEND_RECEIVED_MESSAGE_TO_VRC is True: osc_message = messageFormatter("RECEIVED", translation, [message]) model.oscSendMessage(osc_message) # ------------Speaker2Chatbox------------ @@ -225,7 +225,7 @@ class SpeakerMessage: "transliteration":transliteration, } }) - if config.ENABLE_LOGGER is True: + if config.LOGGER is True: if len(translation) > 0: translation = " (" + "/".join(translation) + ")" model.logger.info(f"[RECEIVED] {message}{translation}") @@ -263,13 +263,13 @@ class ChatMessage: } }) - if config.ENABLE_CONVERT_MESSAGE_TO_ROMAJI is True or config.ENABLE_CONVERT_MESSAGE_TO_HIRAGANA is True: + if config.CONVERT_MESSAGE_TO_ROMAJI is True or config.CONVERT_MESSAGE_TO_HIRAGANA is True: if config.SELECTED_TARGET_LANGUAGES[config.SELECTED_TAB_NO]["primary"]["language"] == "Japanese": transliteration = model.convertMessageToTransliteration(translation[0]) # send OSC message - if config.ENABLE_SEND_MESSAGE_TO_VRC is True: - if config.ENABLE_SEND_ONLY_TRANSLATED_MESSAGES is True: + if config.SEND_MESSAGE_TO_VRC is True: + if config.SEND_ONLY_TRANSLATED_MESSAGES is True: if config.ENABLE_TRANSLATION is False: osc_message = messageFormatter("SEND", "", [message]) else: @@ -278,14 +278,14 @@ class ChatMessage: osc_message = messageFormatter("SEND", translation, [message]) model.oscSendMessage(osc_message) - # if config.ENABLE_OVERLAY_SMALL_LOG is True: + # if config.OVERLAY_SMALL_LOG is True: # overlay_image = model.createOverlayImageShort(message, translation) # model.updateOverlay(overlay_image) # overlay_image = model.createOverlayImageLong("send", message, translation) # model.updateOverlay(overlay_image) # update textbox message log (Sent) - if config.ENABLE_LOGGER is True: + if config.LOGGER is True: if len(translation) > 0: translation_text = " (" + "/".join(translation) + ")" model.logger.info(f"[SENT] {message}{translation_text}") @@ -394,7 +394,7 @@ def getTranslationEngines(*args, **kwargs) -> dict: engines = model.findTranslationEngines( config.SELECTED_YOUR_LANGUAGES[config.SELECTED_TAB_NO], config.SELECTED_TARGET_LANGUAGES[config.SELECTED_TAB_NO], - config.ENABLE_MULTI_LANGUAGE_TRANSLATION, + config.MULTI_LANGUAGE_TRANSLATION, ) return {"status":200, "result":engines} @@ -437,49 +437,49 @@ def setSelectedTargetLanguages(select:dict, *args, **kwargs) -> dict: def getSelectedTranscriptionEngine(*args, **kwargs) -> dict: return {"status":200, "result":config.SELECTED_TRANSCRIPTION_ENGINE} -def getEnableMultiLanguageTranslation(*args, **kwargs) -> dict: - return {"status":200, "result":config.ENABLE_MULTI_LANGUAGE_TRANSLATION} +def getMultiLanguageTranslation(*args, **kwargs) -> dict: + return {"status":200, "result":config.MULTI_LANGUAGE_TRANSLATION} def setEnableMultiLanguageTranslation(*args, **kwargs) -> dict: - config.ENABLE_MULTI_LANGUAGE_TRANSLATION = True - return {"status":200, "result":config.ENABLE_MULTI_LANGUAGE_TRANSLATION} + config.MULTI_LANGUAGE_TRANSLATION = True + return {"status":200, "result":config.MULTI_LANGUAGE_TRANSLATION} def setDisableMultiLanguageTranslation(*args, **kwargs) -> dict: - config.ENABLE_MULTI_LANGUAGE_TRANSLATION = False - return {"status":200, "result":config.ENABLE_MULTI_LANGUAGE_TRANSLATION} + config.MULTI_LANGUAGE_TRANSLATION = False + return {"status":200, "result":config.MULTI_LANGUAGE_TRANSLATION} -def getEnableConvertMessageToRomaji(*args, **kwargs) -> dict: - return {"status":200, "result":config.ENABLE_CONVERT_MESSAGE_TO_ROMAJI} +def getConvertMessageToRomaji(*args, **kwargs) -> dict: + return {"status":200, "result":config.CONVERT_MESSAGE_TO_ROMAJI} def setEnableConvertMessageToRomaji(*args, **kwargs) -> dict: - config.ENABLE_CONVERT_MESSAGE_TO_ROMAJI = True - return {"status":200, "result":config.ENABLE_CONVERT_MESSAGE_TO_ROMAJI} + config.CONVERT_MESSAGE_TO_ROMAJI = True + return {"status":200, "result":config.CONVERT_MESSAGE_TO_ROMAJI} def setDisableConvertMessageToRomaji(*args, **kwargs) -> dict: - config.ENABLE_CONVERT_MESSAGE_TO_ROMAJI = False - return {"status":200, "result":config.ENABLE_CONVERT_MESSAGE_TO_ROMAJI} + config.CONVERT_MESSAGE_TO_ROMAJI = False + return {"status":200, "result":config.CONVERT_MESSAGE_TO_ROMAJI} -def getEnableConvertMessageToHiragana(*args, **kwargs) -> dict: - return {"status":200, "result":config.ENABLE_CONVERT_MESSAGE_TO_HIRAGANA} +def getConvertMessageToHiragana(*args, **kwargs) -> dict: + return {"status":200, "result":config.CONVERT_MESSAGE_TO_HIRAGANA} def setEnableConvertMessageToHiragana(*args, **kwargs) -> dict: - config.ENABLE_CONVERT_MESSAGE_TO_HIRAGANA = True - return {"status":200, "result":config.ENABLE_CONVERT_MESSAGE_TO_HIRAGANA} + config.CONVERT_MESSAGE_TO_HIRAGANA = True + return {"status":200, "result":config.CONVERT_MESSAGE_TO_HIRAGANA} def setDisableConvertMessageToHiragana(*args, **kwargs) -> dict: - config.ENABLE_CONVERT_MESSAGE_TO_HIRAGANA = False - return {"status":200, "result":config.ENABLE_CONVERT_MESSAGE_TO_HIRAGANA} + config.CONVERT_MESSAGE_TO_HIRAGANA = False + return {"status":200, "result":config.CONVERT_MESSAGE_TO_HIRAGANA} -def getEnableMainWindowSidebarCompactMode(*args, **kwargs) -> dict: - return {"status":200, "result":config.ENABLE_MAIN_WINDOW_SIDEBAR_COMPACT_MODE} +def getMainWindowSidebarCompactMode(*args, **kwargs) -> dict: + return {"status":200, "result":config.MAIN_WINDOW_SIDEBAR_COMPACT_MODE} def setEnableMainWindowSidebarCompactMode(*args, **kwargs) -> dict: - config.ENABLE_MAIN_WINDOW_SIDEBAR_COMPACT_MODE = True - return {"status":200, "result":config.ENABLE_MAIN_WINDOW_SIDEBAR_COMPACT_MODE} + config.MAIN_WINDOW_SIDEBAR_COMPACT_MODE = True + return {"status":200, "result":config.MAIN_WINDOW_SIDEBAR_COMPACT_MODE} def setDisableMainWindowSidebarCompactMode(*args, **kwargs) -> dict: - config.ENABLE_MAIN_WINDOW_SIDEBAR_COMPACT_MODE = False - return {"status":200, "result":config.ENABLE_MAIN_WINDOW_SIDEBAR_COMPACT_MODE} + config.MAIN_WINDOW_SIDEBAR_COMPACT_MODE = False + return {"status":200, "result":config.MAIN_WINDOW_SIDEBAR_COMPACT_MODE} def getTransparency(*args, **kwargs) -> dict: return {"status":200, "result":config.TRANSPARENCY} @@ -530,16 +530,16 @@ def setUiLanguage(data, *args, **kwargs) -> dict: config.UI_LANGUAGE = data return {"status":200, "result":config.UI_LANGUAGE} -def getEnableRestoreMainWindowGeometry(*args, **kwargs) -> dict: - return {"status":200, "result":config.ENABLE_RESTORE_MAIN_WINDOW_GEOMETRY} +def getRestoreMainWindowGeometry(*args, **kwargs) -> dict: + return {"status":200, "result":config.RESTORE_MAIN_WINDOW_GEOMETRY} def setEnableRestoreMainWindowGeometry(*args, **kwargs) -> dict: - config.ENABLE_RESTORE_MAIN_WINDOW_GEOMETRY = True - return {"status":200, "result":config.ENABLE_RESTORE_MAIN_WINDOW_GEOMETRY} + config.RESTORE_MAIN_WINDOW_GEOMETRY = True + return {"status":200, "result":config.RESTORE_MAIN_WINDOW_GEOMETRY} def setDisableRestoreMainWindowGeometry(*args, **kwargs) -> dict: - config.ENABLE_RESTORE_MAIN_WINDOW_GEOMETRY = False - return {"status":200, "result":config.ENABLE_RESTORE_MAIN_WINDOW_GEOMETRY} + config.RESTORE_MAIN_WINDOW_GEOMETRY = False + return {"status":200, "result":config.RESTORE_MAIN_WINDOW_GEOMETRY} def getMainWindowGeometry(*args, **kwargs) -> dict: return {"status":200, "result":config.MAIN_WINDOW_GEOMETRY} @@ -548,279 +548,278 @@ def setMainWindowGeometry(data, *args, **kwargs) -> dict: config.MAIN_WINDOW_GEOMETRY = data return {"status":200, "result":config.MAIN_WINDOW_GEOMETRY} -def getEnableMicAutoSelection(*args, **kwargs) -> dict: - return {"status":200, "result":config.ENABLE_MIC_AUTO_SELECTION} +def getAutoMicSelect(*args, **kwargs) -> dict: + return {"status":200, "result":config.AUTO_MIC_SELECT} -def setEnableMicAutoSelection(data, action, *args, **kwargs) -> dict: +def setEnableAutoMicSelect(data, action, *args, **kwargs) -> dict: update_device = UpdateSelectedMicDevice(action) device_manager.setCallbackDefaultInputDevice(update_device.set) - config.ENABLE_MIC_AUTO_SELECTION = True - return {"status":200, "result":config.ENABLE_MIC_AUTO_SELECTION} + config.AUTO_MIC_SELECT = True + return {"status":200, "result":config.AUTO_MIC_SELECT} -def setDisableMicAutoSelection(*args, **kwargs) -> dict: +def setDisableAutoMicSelect(*args, **kwargs) -> dict: device_manager.clearCallbackDefaultInputDevice() - config.ENABLE_MIC_AUTO_SELECTION = False - return {"status":200, "result":config.ENABLE_MIC_AUTO_SELECTION} + config.AUTO_MIC_SELECT = False + return {"status":200, "result":config.AUTO_MIC_SELECT} -def getChoiceMicHost(*args, **kwargs) -> dict: - return {"status":200, "result":config.CHOICE_MIC_HOST} +def getSelectedMicHost(*args, **kwargs) -> dict: + return {"status":200, "result":config.SELECTED_MIC_HOST} -def setChoiceMicHost(data, *args, **kwargs) -> dict: - config.CHOICE_MIC_HOST = data - config.CHOICE_MIC_DEVICE = model.getInputDefaultDevice() +def setSelectedMicHost(data, *args, **kwargs) -> dict: + config.SELECTED_MIC_HOST = data + config.SELECTED_MIC_DEVICE = model.getInputDefaultDevice() if config.ENABLE_CHECK_ENERGY_SEND is True: model.stopCheckMicEnergy() model.startCheckMicEnergy() return {"status":200, "result":{ - "host":config.CHOICE_MIC_HOST, - "device":config.CHOICE_MIC_DEVICE, + "host":config.SELECTED_MIC_HOST, + "device":config.SELECTED_MIC_DEVICE, }, } -def getChoiceMicDevice(*args, **kwargs) -> dict: - return {"status":200, "result":config.CHOICE_MIC_DEVICE} +def getSelectedMicDevice(*args, **kwargs) -> dict: + return {"status":200, "result":config.SELECTED_MIC_DEVICE} -def setChoiceMicDevice(data, *args, **kwargs) -> dict: - config.CHOICE_MIC_DEVICE = data +def setSelectedMicDevice(data, *args, **kwargs) -> dict: + config.SELECTED_MIC_DEVICE = data if config.ENABLE_CHECK_ENERGY_SEND is True: model.stopCheckMicEnergy() model.startCheckMicEnergy() - return {"status":200, "result": config.CHOICE_MIC_DEVICE} + return {"status":200, "result": config.SELECTED_MIC_DEVICE} -def getInputMicEnergyThreshold(*args, **kwargs) -> dict: - return {"status":200, "result":config.INPUT_MIC_ENERGY_THRESHOLD} +def getMicEnergyThreshold(*args, **kwargs) -> dict: + return {"status":200, "result":config.MIC_ENERGY_THRESHOLD} -def setInputMicEnergyThreshold(data, *args, **kwargs) -> dict: +def setMicEnergyThreshold(data, *args, **kwargs) -> dict: status = 400 data = int(data) if 0 <= data <= config.MAX_MIC_ENERGY_THRESHOLD: - config.INPUT_MIC_ENERGY_THRESHOLD = data + config.MIC_ENERGY_THRESHOLD = data status = 200 - return {"status": status, "result": config.INPUT_MIC_ENERGY_THRESHOLD} + return {"status": status, "result": config.MIC_ENERGY_THRESHOLD} -def getInputMicDynamicEnergyThreshold(*args, **kwargs) -> dict: - return {"status":200, "result":config.INPUT_MIC_DYNAMIC_ENERGY_THRESHOLD} +def getMicDynamicEnergyThreshold(*args, **kwargs) -> dict: + return {"status":200, "result":config.MIC_DYNAMIC_ENERGY_THRESHOLD} -def setEnableInputMicDynamicEnergyThreshold(*args, **kwargs) -> dict: - config.INPUT_MIC_DYNAMIC_ENERGY_THRESHOLD = True - return {"status":200, "result":config.INPUT_MIC_DYNAMIC_ENERGY_THRESHOLD} +def setEnableMicDynamicEnergyThreshold(*args, **kwargs) -> dict: + config.MIC_DYNAMIC_ENERGY_THRESHOLD = True + return {"status":200, "result":config.MIC_DYNAMIC_ENERGY_THRESHOLD} -def setDisableInputMicDynamicEnergyThreshold(*args, **kwargs) -> dict: - config.INPUT_MIC_DYNAMIC_ENERGY_THRESHOLD = False - return {"status":200, "result":config.INPUT_MIC_DYNAMIC_ENERGY_THRESHOLD} +def setDisableMicDynamicEnergyThreshold(*args, **kwargs) -> dict: + config.MIC_DYNAMIC_ENERGY_THRESHOLD = False + return {"status":200, "result":config.MIC_DYNAMIC_ENERGY_THRESHOLD} -def getInputMicRecordTimeout(*args, **kwargs) -> dict: - return {"status":200, "result":config.INPUT_MIC_RECORD_TIMEOUT} +def getMicRecordTimeout(*args, **kwargs) -> dict: + return {"status":200, "result":config.MIC_RECORD_TIMEOUT} -def setInputMicRecordTimeout(data, *args, **kwargs) -> dict: +def setMicRecordTimeout(data, *args, **kwargs) -> dict: printLog("Set Mic Record Timeout", data) try: data = int(data) - if 0 <= data <= config.INPUT_MIC_PHRASE_TIMEOUT: - config.INPUT_MIC_RECORD_TIMEOUT = data + if 0 <= data <= config.MIC_PHRASE_TIMEOUT: + config.MIC_RECORD_TIMEOUT = data else: raise ValueError() except Exception: response = {"status":400, "result":{"message":"Error Mic Record Timeout"}} else: - response = {"status":200, "result":config.INPUT_MIC_RECORD_TIMEOUT} + response = {"status":200, "result":config.MIC_RECORD_TIMEOUT} return response -def getInputMicPhraseTimeout(*args, **kwargs) -> dict: - return {"status":200, "result":config.INPUT_MIC_PHRASE_TIMEOUT} +def getMicPhraseTimeout(*args, **kwargs) -> dict: + return {"status":200, "result":config.MIC_PHRASE_TIMEOUT} -def setInputMicPhraseTimeout(data, *args, **kwargs) -> dict: - printLog("Set Mic Phrase Timeout", data) +def setMicPhraseTimeout(data, *args, **kwargs) -> dict: try: data = int(data) - if data >= config.INPUT_MIC_RECORD_TIMEOUT: - config.INPUT_MIC_PHRASE_TIMEOUT = data + if data >= config.MIC_RECORD_TIMEOUT: + config.MIC_PHRASE_TIMEOUT = data else: raise ValueError() except Exception: response = {"status":400, "result":{"message":"Error Mic Phrase Timeout"}} else: - response = {"status":200, "result":config.INPUT_MIC_PHRASE_TIMEOUT} + response = {"status":200, "result":config.MIC_PHRASE_TIMEOUT} return response -def getInputMicMaxPhrases(*args, **kwargs) -> dict: - return {"status":200, "result":config.INPUT_MIC_MAX_PHRASES} +def getMicMaxPhrases(*args, **kwargs) -> dict: + return {"status":200, "result":config.MIC_MAX_PHRASES} -def setInputMicMaxPhrases(data, *args, **kwargs) -> dict: +def setMicMaxPhrases(data, *args, **kwargs) -> dict: try: data = int(data) if 0 <= data: - config.INPUT_MIC_MAX_PHRASES = data + config.MIC_MAX_PHRASES = data else: raise ValueError() except Exception: response = {"status":400, "result":{"message":"Error Mic Max Phrases"}} else: - response = {"status":200, "result":config.INPUT_MIC_MAX_PHRASES} + response = {"status":200, "result":config.MIC_MAX_PHRASES} return response -def getInputMicWordFilter(*args, **kwargs) -> dict: - return {"status":200, "result":config.INPUT_MIC_WORD_FILTER} +def getMicWordFilter(*args, **kwargs) -> dict: + return {"status":200, "result":config.MIC_WORD_FILTER} -def setInputMicWordFilter(data, *args, **kwargs) -> dict: +def setMicWordFilter(data, *args, **kwargs) -> dict: data = str(data) data = [w.strip() for w in data.split(",") if len(w.strip()) > 0] # Copy the list - new_input_mic_word_filter_list = config.INPUT_MIC_WORD_FILTER + new_mic_word_filter_list = config.MIC_WORD_FILTER new_added_value = [] for value in data: - if value in new_input_mic_word_filter_list: + if value in new_mic_word_filter_list: # If the value is already in the list, do nothing. pass else: - new_input_mic_word_filter_list.append(value) + new_mic_word_filter_list.append(value) new_added_value.append(value) - config.INPUT_MIC_WORD_FILTER = new_input_mic_word_filter_list + config.MIC_WORD_FILTER = new_mic_word_filter_list model.resetKeywordProcessor() model.addKeywords() - return {"status":200, "result":config.INPUT_MIC_WORD_FILTER} + return {"status":200, "result":config.MIC_WORD_FILTER} -def delInputMicWordFilter(data, *args, **kwargs) -> dict: +def delMicWordFilter(data, *args, **kwargs) -> dict: try: - new_input_mic_word_filter_list = config.INPUT_MIC_WORD_FILTER - new_input_mic_word_filter_list.remove(str(data)) - config.INPUT_MIC_WORD_FILTER = new_input_mic_word_filter_list + new_mic_word_filter_list = config.MIC_WORD_FILTER + new_mic_word_filter_list.remove(str(data)) + config.MIC_WORD_FILTER = new_mic_word_filter_list model.resetKeywordProcessor() model.addKeywords() except Exception: - printLog("Delete Mic Word Filter", "There was no the target word in config.INPUT_MIC_WORD_FILTER") - return {"status":200, "result":config.INPUT_MIC_WORD_FILTER} + printLog("Delete Mic Word Filter", "There was no the target word in config.MIC_WORD_FILTER") + return {"status":200, "result":config.MIC_WORD_FILTER} -def getInputMicAvgLogprob(*args, **kwargs) -> dict: - return {"status":200, "result":config.INPUT_MIC_AVG_LOGPROB} +def getMicAvgLogprob(*args, **kwargs) -> dict: + return {"status":200, "result":config.MIC_AVG_LOGPROB} -def setInputMicAvgLogprob(data, *args, **kwargs) -> dict: - config.INPUT_MIC_AVG_LOGPROB = float(data) - return {"status":200, "result":config.INPUT_MIC_AVG_LOGPROB} +def setMicAvgLogprob(data, *args, **kwargs) -> dict: + config.MIC_AVG_LOGPROB = float(data) + return {"status":200, "result":config.MIC_AVG_LOGPROB} -def getInputMicNoSpeechProb(*args, **kwargs) -> dict: - return {"status":200, "result":config.INPUT_MIC_NO_SPEECH_PROB} +def getMicNoSpeechProb(*args, **kwargs) -> dict: + return {"status":200, "result":config.MIC_NO_SPEECH_PROB} -def setInputMicNoSpeechProb(data, *args, **kwargs) -> dict: - config.INPUT_MIC_NO_SPEECH_PROB = float(data) - return {"status":200, "result":config.INPUT_MIC_NO_SPEECH_PROB} +def setMicNoSpeechProb(data, *args, **kwargs) -> dict: + config.MIC_NO_SPEECH_PROB = float(data) + return {"status":200, "result":config.MIC_NO_SPEECH_PROB} -def getEnableSpeakerAutoSelection(*args, **kwargs) -> dict: - return {"status":200, "result":config.ENABLE_SPEAKER_AUTO_SELECTION} +def getAutoSpeakerSelect(*args, **kwargs) -> dict: + return {"status":200, "result":config.AUTO_SPEAKER_SELECT} -def setEnableSpeakerAutoSelection(data, action, *args, **kwargs) -> dict: +def setEnableAutoSpeakerSelect(data, action, *args, **kwargs) -> dict: update_device = UpdateSelectedSpeakerDevice(action) device_manager.setCallbackDefaultOutputDevice(update_device.set) - config.ENABLE_SPEAKER_AUTO_SELECTION = True - return {"status":200, "result":config.ENABLE_SPEAKER_AUTO_SELECTION} + config.AUTO_SPEAKER_SELECT = True + return {"status":200, "result":config.AUTO_SPEAKER_SELECT} -def setDisableSpeakerAutoSelection(*args, **kwargs) -> dict: +def setDisableAutoSpeakerSelect(*args, **kwargs) -> dict: device_manager.clearCallbackDefaultInputDevice() - config.ENABLE_SPEAKER_AUTO_SELECTION = False - return {"status":200, "result":config.ENABLE_SPEAKER_AUTO_SELECTION} + config.AUTO_SPEAKER_SELECT = False + return {"status":200, "result":config.AUTO_SPEAKER_SELECT} -def getChoiceSpeakerDevice(*args, **kwargs) -> dict: - return {"status":200, "result":config.CHOICE_SPEAKER_DEVICE} +def getSelectedSpeakerDevice(*args, **kwargs) -> dict: + return {"status":200, "result":config.SELECTED_SPEAKER_DEVICE} -def setChoiceSpeakerDevice(data, *args, **kwargs) -> dict: - config.CHOICE_SPEAKER_DEVICE = data +def setSelectedSpeakerDevice(data, *args, **kwargs) -> dict: + config.SELECTED_SPEAKER_DEVICE = data if config.ENABLE_CHECK_ENERGY_RECEIVE is True: model.stopCheckSpeakerEnergy() model.startCheckSpeakerEnergy() - return {"status":200, "result":config.CHOICE_SPEAKER_DEVICE} + return {"status":200, "result":config.SELECTED_SPEAKER_DEVICE} -def getInputSpeakerEnergyThreshold(*args, **kwargs) -> dict: - return {"status":200, "result":config.INPUT_SPEAKER_ENERGY_THRESHOLD} +def getSpeakerEnergyThreshold(*args, **kwargs) -> dict: + return {"status":200, "result":config.SPEAKER_ENERGY_THRESHOLD} -def setInputSpeakerEnergyThreshold(data, *args, **kwargs) -> dict: +def setSpeakerEnergyThreshold(data, *args, **kwargs) -> dict: printLog("Set Speaker Energy Threshold", data) try: data = int(data) if 0 <= data <= config.MAX_SPEAKER_ENERGY_THRESHOLD: - config.INPUT_SPEAKER_ENERGY_THRESHOLD = data + config.SPEAKER_ENERGY_THRESHOLD = data else: raise ValueError() except Exception: response = {"status":400, "result":{"message":"Error Set Speaker Energy Threshold"}} else: - response = {"status":200, "result":config.INPUT_SPEAKER_ENERGY_THRESHOLD} + response = {"status":200, "result":config.SPEAKER_ENERGY_THRESHOLD} return response -def getInputSpeakerDynamicEnergyThreshold(*args, **kwargs) -> dict: - return {"status":200, "result":config.INPUT_SPEAKER_DYNAMIC_ENERGY_THRESHOLD} +def getSpeakerDynamicEnergyThreshold(*args, **kwargs) -> dict: + return {"status":200, "result":config.SPEAKER_DYNAMIC_ENERGY_THRESHOLD} -def setEnableInputSpeakerDynamicEnergyThreshold(*args, **kwargs) -> dict: - config.INPUT_SPEAKER_DYNAMIC_ENERGY_THRESHOLD = True - return {"status":200, "result":config.INPUT_SPEAKER_DYNAMIC_ENERGY_THRESHOLD} +def setEnableSpeakerDynamicEnergyThreshold(*args, **kwargs) -> dict: + config.SPEAKER_DYNAMIC_ENERGY_THRESHOLD = True + return {"status":200, "result":config.SPEAKER_DYNAMIC_ENERGY_THRESHOLD} -def setDisableInputSpeakerDynamicEnergyThreshold(*args, **kwargs) -> dict: - config.INPUT_SPEAKER_DYNAMIC_ENERGY_THRESHOLD = False - return {"status":200, "result":config.INPUT_SPEAKER_DYNAMIC_ENERGY_THRESHOLD} +def setDisableSpeakerDynamicEnergyThreshold(*args, **kwargs) -> dict: + config.SPEAKER_DYNAMIC_ENERGY_THRESHOLD = False + return {"status":200, "result":config.SPEAKER_DYNAMIC_ENERGY_THRESHOLD} -def getInputSpeakerRecordTimeout(*args, **kwargs) -> dict: - return {"status":200, "result":config.INPUT_SPEAKER_RECORD_TIMEOUT} +def getSpeakerRecordTimeout(*args, **kwargs) -> dict: + return {"status":200, "result":config.SPEAKER_RECORD_TIMEOUT} -def setInputSpeakerRecordTimeout(data, *args, **kwargs) -> dict: +def setSpeakerRecordTimeout(data, *args, **kwargs) -> dict: try: data = int(data) - if 0 <= data <= config.INPUT_SPEAKER_PHRASE_TIMEOUT: - config.INPUT_SPEAKER_RECORD_TIMEOUT = data + if 0 <= data <= config.SPEAKER_PHRASE_TIMEOUT: + config.SPEAKER_RECORD_TIMEOUT = data else: raise ValueError() except Exception: response = {"status":400, "result":{"message":"Error Speaker Record Timeout"}} else: - response = {"status":200, "result":config.INPUT_SPEAKER_RECORD_TIMEOUT} + response = {"status":200, "result":config.SPEAKER_RECORD_TIMEOUT} return response -def getInputSpeakerPhraseTimeout(*args, **kwargs) -> dict: - return {"status":200, "result":config.INPUT_SPEAKER_PHRASE_TIMEOUT} +def getSpeakerPhraseTimeout(*args, **kwargs) -> dict: + return {"status":200, "result":config.SPEAKER_PHRASE_TIMEOUT} -def setInputSpeakerPhraseTimeout(data, *args, **kwargs) -> dict: +def setSpeakerPhraseTimeout(data, *args, **kwargs) -> dict: try: data = int(data) - if 0 <= data and data >= config.INPUT_SPEAKER_RECORD_TIMEOUT: - config.INPUT_SPEAKER_PHRASE_TIMEOUT = data + if 0 <= data and data >= config.SPEAKER_RECORD_TIMEOUT: + config.SPEAKER_PHRASE_TIMEOUT = data else: raise ValueError() except Exception: response = {"status":400, "result":{"message":"Error Speaker Phrase Timeout"}} else: - response = {"status":200, "result":config.INPUT_SPEAKER_PHRASE_TIMEOUT} + response = {"status":200, "result":config.SPEAKER_PHRASE_TIMEOUT} return response -def getInputSpeakerMaxPhrases(*args, **kwargs) -> dict: - return {"status":200, "result":config.INPUT_SPEAKER_MAX_PHRASES} +def getSpeakerMaxPhrases(*args, **kwargs) -> dict: + return {"status":200, "result":config.SPEAKER_MAX_PHRASES} -def setInputSpeakerMaxPhrases(data, *args, **kwargs) -> dict: +def setSpeakerMaxPhrases(data, *args, **kwargs) -> dict: printLog("Set Speaker Max Phrases", data) try: data = int(data) if 0 <= data: - config.INPUT_SPEAKER_MAX_PHRASES = data + config.SPEAKER_MAX_PHRASES = data else: raise ValueError() except Exception: response = {"status":400, "result":{"message":"Error Speaker Max Phrases"}} else: - response = {"status":200, "result":config.INPUT_SPEAKER_MAX_PHRASES} + response = {"status":200, "result":config.SPEAKER_MAX_PHRASES} return response -def getInputSpeakerAvgLogprob(*args, **kwargs) -> dict: - return {"status":200, "result":config.INPUT_SPEAKER_AVG_LOGPROB} +def getSpeakerAvgLogprob(*args, **kwargs) -> dict: + return {"status":200, "result":config.SPEAKER_AVG_LOGPROB} -def setInputSpeakerAvgLogprob(data, *args, **kwargs) -> dict: - config.INPUT_SPEAKER_AVG_LOGPROB = float(data) - return {"status":200, "result":config.INPUT_SPEAKER_AVG_LOGPROB} +def setSpeakerAvgLogprob(data, *args, **kwargs) -> dict: + config.SPEAKER_AVG_LOGPROB = float(data) + return {"status":200, "result":config.SPEAKER_AVG_LOGPROB} -def getInputSpeakerNoSpeechProb(*args, **kwargs) -> dict: - return {"status":200, "result":config.INPUT_SPEAKER_NO_SPEECH_PROB} +def getSpeakerNoSpeechProb(*args, **kwargs) -> dict: + return {"status":200, "result":config.SPEAKER_NO_SPEECH_PROB} -def setInputSpeakerNoSpeechProb(data, *args, **kwargs) -> dict: - config.INPUT_SPEAKER_NO_SPEECH_PROB = float(data) - return {"status":200, "result":config.INPUT_SPEAKER_NO_SPEECH_PROB} +def setSpeakerNoSpeechProb(data, *args, **kwargs) -> dict: + config.SPEAKER_NO_SPEECH_PROB = float(data) + return {"status":200, "result":config.SPEAKER_NO_SPEECH_PROB} def getOscIpAddress(*args, **kwargs) -> dict: return {"status":200, "result":config.OSC_IP_ADDRESS} @@ -964,27 +963,27 @@ def setWhisperWeightType(data, *args, **kwargs) -> dict: } } -def getEnableAutoClearMessageBox(*args, **kwargs) -> dict: - return {"status":200, "result":config.ENABLE_AUTO_CLEAR_MESSAGE_BOX} +def getAutoClearMessageBox(*args, **kwargs) -> dict: + return {"status":200, "result":config.AUTO_CLEAR_MESSAGE_BOX} def setEnableAutoClearMessageBox(*args, **kwargs) -> dict: - config.ENABLE_AUTO_CLEAR_MESSAGE_BOX = True - return {"status":200, "result":config.ENABLE_AUTO_CLEAR_MESSAGE_BOX} + config.AUTO_CLEAR_MESSAGE_BOX = True + return {"status":200, "result":config.AUTO_CLEAR_MESSAGE_BOX} def setDisableAutoClearMessageBox(*args, **kwargs) -> dict: - config.ENABLE_AUTO_CLEAR_MESSAGE_BOX = False - return {"status":200, "result":config.ENABLE_AUTO_CLEAR_MESSAGE_BOX} + config.AUTO_CLEAR_MESSAGE_BOX = False + return {"status":200, "result":config.AUTO_CLEAR_MESSAGE_BOX} -def getEnableSendOnlyTranslatedMessages(*args, **kwargs) -> dict: - return {"status":200, "result":config.ENABLE_SEND_ONLY_TRANSLATED_MESSAGES} +def getSendOnlyTranslatedMessages(*args, **kwargs) -> dict: + return {"status":200, "result":config.SEND_ONLY_TRANSLATED_MESSAGES} def setEnableSendOnlyTranslatedMessages(*args, **kwargs) -> dict: - config.ENABLE_SEND_ONLY_TRANSLATED_MESSAGES = True - return {"status":200, "result":config.ENABLE_SEND_ONLY_TRANSLATED_MESSAGES} + config.SEND_ONLY_TRANSLATED_MESSAGES = True + return {"status":200, "result":config.SEND_ONLY_TRANSLATED_MESSAGES} def setDisableSendOnlyTranslatedMessages(*args, **kwargs) -> dict: - config.ENABLE_SEND_ONLY_TRANSLATED_MESSAGES = False - return {"status":200, "result":config.ENABLE_SEND_ONLY_TRANSLATED_MESSAGES} + config.SEND_ONLY_TRANSLATED_MESSAGES = False + return {"status":200, "result":config.SEND_ONLY_TRANSLATED_MESSAGES} def getSendMessageButtonType(*args, **kwargs) -> dict: return {"status":200, "result":config.SEND_MESSAGE_BUTTON_TYPE} @@ -1010,33 +1009,33 @@ def setOverlaySmallLogSettings(data, *args, **kwargs) -> dict: model.updateOverlayPosition() return {"status":200, "result":config.OVERLAY_SMALL_LOG_SETTINGS} -def getEnableOverlaySmallLog(*args, **kwargs) -> dict: - return {"status":200, "result":config.ENABLE_OVERLAY_SMALL_LOG} +def getOverlaySmallLog(*args, **kwargs) -> dict: + return {"status":200, "result":config.OVERLAY_SMALL_LOG} def setEnableOverlaySmallLog(*args, **kwargs) -> dict: - config.ENABLE_OVERLAY_SMALL_LOG = True - if config.ENABLE_OVERLAY_SMALL_LOG is True and config.ENABLE_TRANSCRIPTION_RECEIVE is True: + config.OVERLAY_SMALL_LOG = True + if config.OVERLAY_SMALL_LOG is True and config.ENABLE_TRANSCRIPTION_RECEIVE is True: if model.overlay.initialized is False and model.overlay.checkSteamvrRunning() is True: model.startOverlay() - return {"status":200, "result":config.ENABLE_OVERLAY_SMALL_LOG} + return {"status":200, "result":config.OVERLAY_SMALL_LOG} def setDisableOverlaySmallLog(*args, **kwargs) -> dict: - config.ENABLE_OVERLAY_SMALL_LOG = False - if config.ENABLE_OVERLAY_SMALL_LOG is False: + config.OVERLAY_SMALL_LOG = False + if config.OVERLAY_SMALL_LOG is False: model.clearOverlayImage() model.shutdownOverlay() - return {"status":200, "result":config.ENABLE_OVERLAY_SMALL_LOG} + return {"status":200, "result":config.OVERLAY_SMALL_LOG} -def getEnableSendMessageToVrc(*args, **kwargs) -> dict: - return {"status":200, "result":config.ENABLE_SEND_MESSAGE_TO_VRC} +def getSendMessageToVrc(*args, **kwargs) -> dict: + return {"status":200, "result":config.SEND_MESSAGE_TO_VRC} def setEnableSendMessageToVrc(*args, **kwargs) -> dict: - config.ENABLE_SEND_MESSAGE_TO_VRC = True - return {"status":200, "result":config.ENABLE_SEND_MESSAGE_TO_VRC} + config.SEND_MESSAGE_TO_VRC = True + return {"status":200, "result":config.SEND_MESSAGE_TO_VRC} def setDisableSendMessageToVrc(*args, **kwargs) -> dict: - config.ENABLE_SEND_MESSAGE_TO_VRC = False - return {"status":200, "result":config.ENABLE_SEND_MESSAGE_TO_VRC} + config.SEND_MESSAGE_TO_VRC = False + return {"status":200, "result":config.SEND_MESSAGE_TO_VRC} def getSendMessageFormat(*args, **kwargs) -> dict: return {"status":200, "result":config.SEND_MESSAGE_FORMAT} @@ -1072,55 +1071,51 @@ def setReceivedMessageFormatWithT(data, *args, **kwargs) -> dict: config.RECEIVED_MESSAGE_FORMAT_WITH_T = data return {"status":200, "result":config.RECEIVED_MESSAGE_FORMAT_WITH_T} -def getEnableSpeaker2ChatboxPass(*args, **kwargs) -> dict: - return {"status":200, "result":config.ENABLE_SPEAKER2CHATBOX_PASS} +def getSpeaker2ChatboxPass(*args, **kwargs) -> dict: + return {"status":200, "result":config.SPEAKER2CHATBOX_PASS} -def setEnableSpeaker2ChatboxPass(*args, **kwargs) -> dict: - config.ENABLE_SPEAKER2CHATBOX_PASS = True - return {"status":200, "result":config.ENABLE_SPEAKER2CHATBOX_PASS} +def setSpeaker2ChatboxPass(data, *args, **kwargs) -> dict: + config.SPEAKER2CHATBOX_PASS = data + return {"status":200, "result":config.SPEAKER2CHATBOX_PASS} -def setDisableSpeaker2ChatboxPass(*args, **kwargs) -> dict: - config.ENABLE_SPEAKER2CHATBOX_PASS = False - return {"status":200, "result":config.ENABLE_SPEAKER2CHATBOX_PASS} - -def getEnableSendReceivedMessageToVrc(*args, **kwargs) -> dict: - return {"status":200, "result":config.ENABLE_SEND_RECEIVED_MESSAGE_TO_VRC} +def getSendReceivedMessageToVrc(*args, **kwargs) -> dict: + return {"status":200, "result":config.SEND_RECEIVED_MESSAGE_TO_VRC} def setEnableSendReceivedMessageToVrc(*args, **kwargs) -> dict: - config.ENABLE_SEND_RECEIVED_MESSAGE_TO_VRC = True - return {"status":200, "result":config.ENABLE_SEND_RECEIVED_MESSAGE_TO_VRC} + config.SEND_RECEIVED_MESSAGE_TO_VRC = True + return {"status":200, "result":config.SEND_RECEIVED_MESSAGE_TO_VRC} def setDisableSendReceivedMessageToVrc(*args, **kwargs) -> dict: - config.ENABLE_SEND_RECEIVED_MESSAGE_TO_VRC = False - return {"status":200, "result":config.ENABLE_SEND_RECEIVED_MESSAGE_TO_VRC} + config.SEND_RECEIVED_MESSAGE_TO_VRC = False + return {"status":200, "result":config.SEND_RECEIVED_MESSAGE_TO_VRC} -def getEnableLogger(*args, **kwargs) -> dict: - return {"status":200, "result":config.ENABLE_LOGGER} +def getLogger(*args, **kwargs) -> dict: + return {"status":200, "result":config.LOGGER} def setEnableLogger(*args, **kwargs) -> dict: - config.ENABLE_LOGGER = True + config.LOGGER = True model.startLogger() - return {"status":200, "result":config.ENABLE_LOGGER} + return {"status":200, "result":config.LOGGER} def setDisableLogger(*args, **kwargs) -> dict: model.stopLogger() - config.ENABLE_LOGGER = False - return {"status":200, "result":config.ENABLE_LOGGER} + config.LOGGER = False + return {"status":200, "result":config.LOGGER} -def getEnableVrcMicMuteSync(*args, **kwargs) -> dict: - return {"status":200, "result":config.ENABLE_VRC_MIC_MUTE_SYNC} +def getVrcMicMuteSync(*args, **kwargs) -> dict: + return {"status":200, "result":config.VRC_MIC_MUTE_SYNC} def setEnableVrcMicMuteSync(*args, **kwargs) -> dict: - config.ENABLE_VRC_MIC_MUTE_SYNC = True + config.VRC_MIC_MUTE_SYNC = True model.startCheckMuteSelfStatus() model.changeMicTranscriptStatus() - return {"status":200, "result":config.ENABLE_VRC_MIC_MUTE_SYNC} + return {"status":200, "result":config.VRC_MIC_MUTE_SYNC} def setDisableVrcMicMuteSync(*args, **kwargs) -> dict: - config.ENABLE_VRC_MIC_MUTE_SYNC = False + config.VRC_MIC_MUTE_SYNC = False model.stopCheckMuteSelfStatus() model.changeMicTranscriptStatus() - return {"status":200, "result":config.ENABLE_VRC_MIC_MUTE_SYNC} + return {"status":200, "result":config.VRC_MIC_MUTE_SYNC} def setEnableCheckSpeakerThreshold(data, action, *args, **kwargs) -> dict: progressbar_speaker_energy = ProgressBarSpeakerEnergy(action) @@ -1180,7 +1175,7 @@ def setDisableTranscriptionSend(*args, **kwargs) -> dict: def setEnableTranscriptionReceive(data, action, *args, **kwargs) -> dict: startThreadingTranscriptionReceiveMessage(action) - if config.ENABLE_OVERLAY_SMALL_LOG is True: + if config.OVERLAY_SMALL_LOG is True: if model.overlay.initialized is False and model.overlay.checkSteamvrRunning() is True: model.startOverlay() config.ENABLE_TRANSCRIPTION_RECEIVE = True @@ -1198,12 +1193,12 @@ def sendMessageBox(data, action, *args, **kwargs) -> dict: return response def typingMessageBox(*args, **kwargs) -> dict: - if config.ENABLE_SEND_MESSAGE_TO_VRC is True: + if config.SEND_MESSAGE_TO_VRC is True: model.oscStartSendTyping() return {"status":200, "result":True} def stopTypingMessageBox(*args, **kwargs) -> dict: - if config.ENABLE_SEND_MESSAGE_TO_VRC is True: + if config.SEND_MESSAGE_TO_VRC is True: model.oscStopSendTyping() return {"status":200, "result":True} @@ -1426,22 +1421,22 @@ def init(actions:dict, *args, **kwargs) -> None: # init logger printLog("Init Logger") - if config.ENABLE_LOGGER is True: + if config.LOGGER is True: model.startLogger() # init OSC receive printLog("Init OSC Receive") model.startReceiveOSC() - if config.ENABLE_VRC_MIC_MUTE_SYNC is True: + if config.VRC_MIC_MUTE_SYNC is True: model.startCheckMuteSelfStatus() # init Auto device selection printLog("Init Auto Device Selection") - if config.ENABLE_MIC_AUTO_SELECTION is True: + if config.AUTO_MIC_SELECT is True: update_mic_device = UpdateSelectedMicDevice(actions["update_selected_mic_device"]) device_manager.setCallbackDefaultInputDevice(update_mic_device.set) - if config.ENABLE_SPEAKER_AUTO_SELECTION is True: + if config.AUTO_SPEAKER_SELECT is True: update_speaker_device = UpdateSelectedSpeakerDevice(actions["update_selected_speaker_device"]) device_manager.setCallbackDefaultOutputDevice(update_speaker_device.set) diff --git a/src-python/webui_mainloop.py b/src-python/webui_mainloop.py index e5504546..c12e91b0 100644 --- a/src-python/webui_mainloop.py +++ b/src-python/webui_mainloop.py @@ -47,19 +47,19 @@ mapping = { "/get/selected_transcription_engine": {"status": False, "variable":controller.getSelectedTranscriptionEngine}, - "/get/enable_multi_language_translation": {"status": True, "variable":controller.getEnableMultiLanguageTranslation}, + "/get/multi_language_translation": {"status": True, "variable":controller.getMultiLanguageTranslation}, "/set/enable_multi_language_translation": {"status": True, "variable":controller.setEnableMultiLanguageTranslation}, "/set/disable_multi_language_translation": {"status": True, "variable":controller.setDisableMultiLanguageTranslation}, - "/get/enable_convert_message_to_romaji": {"status": True, "variable":controller.getEnableConvertMessageToRomaji}, + "/get/convert_message_to_romaji": {"status": True, "variable":controller.getConvertMessageToRomaji}, "/set/enable_convert_message_to_romaji": {"status": True, "variable":controller.setEnableConvertMessageToRomaji}, "/set/disable_convert_message_to_romaji": {"status": True, "variable":controller.setDisableConvertMessageToRomaji}, - "/get/enable_convert_message_to_hiragana": {"status": True, "variable":controller.getEnableConvertMessageToHiragana}, + "/get/convert_message_to_hiragana": {"status": True, "variable":controller.getConvertMessageToHiragana}, "/set/enable_convert_message_to_hiragana": {"status": True, "variable":controller.setEnableConvertMessageToHiragana}, "/set/disable_convert_message_to_hiragana": {"status": True, "variable":controller.setDisableConvertMessageToHiragana}, - "/get/enable_main_window_sidebar_compact_mode": {"status": True, "variable":controller.getEnableMainWindowSidebarCompactMode}, + "/get/main_window_sidebar_compact_mode": {"status": True, "variable":controller.getMainWindowSidebarCompactMode}, "/set/enable_main_window_sidebar_compact_mode": {"status": True, "variable":controller.setEnableMainWindowSidebarCompactMode}, "/set/disable_main_window_sidebar_compact_mode": {"status": True, "variable":controller.setDisableMainWindowSidebarCompactMode}, @@ -84,76 +84,77 @@ mapping = { "/get/ui_language": {"status": True, "variable":controller.getUiLanguage}, "/set/ui_language": {"status": True, "variable":controller.setUiLanguage}, - "/get/enable_restore_main_window_geometry": {"status": True, "variable":controller.getEnableRestoreMainWindowGeometry}, + "/get/restore_main_window_geometry": {"status": True, "variable":controller.getRestoreMainWindowGeometry}, "/set/enable_restore_main_window_geometry": {"status": True, "variable":controller.setEnableRestoreMainWindowGeometry}, "/set/disable_restore_main_window_geometry": {"status": True, "variable":controller.setDisableRestoreMainWindowGeometry}, "/get/main_window_geometry": {"status": True, "variable":controller.getMainWindowGeometry}, "/set/main_window_geometry": {"status": True, "variable":controller.setMainWindowGeometry}, - "/get/enable_mic_auto_selection": {"status": True, "variable":controller.getEnableMicAutoSelection}, - "/set/enable_mic_auto_selection": {"status": True, "variable":controller.setEnableMicAutoSelection}, - "/set/disable_mic_auto_selection": {"status": True, "variable":controller.setDisableMicAutoSelection}, + "/get/auto_mic_select": {"status": True, "variable":controller.getAutoMicSelect}, + "/set/enable_auto_mic_select": {"status": True, "variable":controller.setEnableAutoMicSelect}, + "/set/disable_auto_mic_select": {"status": True, "variable":controller.setDisableAutoMicSelect}, - "/get/choice_mic_host": {"status": True, "variable":controller.getChoiceMicHost}, - "/set/choice_mic_host": {"status": True, "variable":controller.setChoiceMicHost}, + "/get/selected_mic_host": {"status": True, "variable":controller.getSelectedMicHost}, + "/set/selected_mic_host": {"status": True, "variable":controller.setSelectedMicHost}, - "/get/choice_mic_device": {"status": True, "variable":controller.getChoiceMicDevice}, - "/set/choice_mic_device": {"status": True, "variable":controller.setChoiceMicDevice}, + "/get/selected_mic_device": {"status": True, "variable":controller.getSelectedMicDevice}, + "/set/selected_mic_device": {"status": True, "variable":controller.setSelectedMicDevice}, - "/get/input_mic_energy_threshold": {"status": True, "variable":controller.getInputMicEnergyThreshold}, - "/set/input_mic_energy_threshold": {"status": True, "variable":controller.setInputMicEnergyThreshold}, + "/get/mic_energy_threshold": {"status": True, "variable":controller.getMicEnergyThreshold}, + "/set/mic_energy_threshold": {"status": True, "variable":controller.setMicEnergyThreshold}, - "/get/input_mic_dynamic_energy_threshold": {"status": True, "variable":controller.getInputMicDynamicEnergyThreshold}, - "/set/enable_input_mic_dynamic_energy_threshold": {"status": True, "variable":controller.setEnableInputMicDynamicEnergyThreshold}, - "/set/disable_input_mic_dynamic_energy_threshold": {"status": True, "variable":controller.setDisableInputMicDynamicEnergyThreshold}, + "/get/mic_dynamic_energy_threshold": {"status": True, "variable":controller.getMicDynamicEnergyThreshold}, + "/set/enable_mic_dynamic_energy_threshold": {"status": True, "variable":controller.setEnableMicDynamicEnergyThreshold}, + "/set/disable_mic_dynamic_energy_threshold": {"status": True, "variable":controller.setDisableMicDynamicEnergyThreshold}, - "/get/input_mic_record_timeout": {"status": True, "variable":controller.getInputMicRecordTimeout}, - "/set/input_mic_record_timeout": {"status": True, "variable":controller.setInputMicRecordTimeout}, + "/get/mic_record_timeout": {"status": True, "variable":controller.getMicRecordTimeout}, + "/set/mic_record_timeout": {"status": True, "variable":controller.setMicRecordTimeout}, - "/get/input_mic_phrase_timeout": {"status": True, "variable":controller.getInputMicPhraseTimeout}, - "/set/input_mic_phrase_timeout": {"status": True, "variable":controller.setInputMicPhraseTimeout}, + "/get/mic_phrase_timeout": {"status": True, "variable":controller.getMicPhraseTimeout}, + "/set/mic_phrase_timeout": {"status": True, "variable":controller.setMicPhraseTimeout}, - "/get/input_mic_max_phrases": {"status": True, "variable":controller.getInputMicMaxPhrases}, - "/set/input_mic_max_phrases": {"status": True, "variable":controller.setInputMicMaxPhrases}, + "/get/mic_max_phrases": {"status": True, "variable":controller.getMicMaxPhrases}, + "/set/mic_max_phrases": {"status": True, "variable":controller.setMicMaxPhrases}, - "/get/input_mic_word_filter": {"status": True, "variable":controller.getInputMicWordFilter}, - "/set/input_mic_word_filter": {"status": True, "variable":controller.setInputMicWordFilter}, - "/del/input_mic_word_filter": {"status": True, "variable":controller.delInputMicWordFilter}, + "/get/mic_word_filter": {"status": True, "variable":controller.getMicWordFilter}, + "/set/mic_word_filter": {"status": True, "variable":controller.setMicWordFilter}, + "/del/mic_word_filter": {"status": True, "variable":controller.delMicWordFilter}, - "/get/input_mic_avg_logprob": {"status": True, "variable":controller.getInputMicAvgLogprob}, - "/set/input_mic_avg_logprob": {"status": True, "variable":controller.setInputMicAvgLogprob}, + "/get/mic_avg_logprob": {"status": True, "variable":controller.getMicAvgLogprob}, + "/set/mic_avg_logprob": {"status": True, "variable":controller.setMicAvgLogprob}, - "/get/input_mic_no_speech_prob": {"status": True, "variable":controller.getInputMicNoSpeechProb}, - "/set/input_mic_no_speech_prob": {"status": True, "variable":controller.setInputMicNoSpeechProb}, + "/get/mic_no_speech_prob": {"status": True, "variable":controller.getMicNoSpeechProb}, + "/set/mic_no_speech_prob": {"status": True, "variable":controller.setMicNoSpeechProb}, - "/set/enable_speaker_auto_selection": {"status": True, "variable":controller.setEnableSpeakerAutoSelection}, - "/set/disable_speaker_auto_selection": {"status": True, "variable":controller.setDisableSpeakerAutoSelection}, + "/get/auto_speaker_select": {"status": True, "variable":controller.getAutoSpeakerSelect}, + "/set/enable_auto_speaker_select": {"status": True, "variable":controller.setEnableAutoSpeakerSelect}, + "/set/disable_auto_speaker_select": {"status": True, "variable":controller.setDisableAutoSpeakerSelect}, - "/get/choice_speaker_device": {"status": True, "variable":controller.getChoiceSpeakerDevice}, - "/set/choice_speaker_device": {"status": True, "variable":controller.setChoiceSpeakerDevice}, + "/get/selected_speaker_device": {"status": True, "variable":controller.getSelectedSpeakerDevice}, + "/set/selected_speaker_device": {"status": True, "variable":controller.setSelectedSpeakerDevice}, - "/get/input_speaker_energy_threshold": {"status": True, "variable":controller.getInputSpeakerEnergyThreshold}, - "/set/input_speaker_energy_threshold": {"status": True, "variable":controller.setInputSpeakerEnergyThreshold}, + "/get/speaker_energy_threshold": {"status": True, "variable":controller.getSpeakerEnergyThreshold}, + "/set/speaker_energy_threshold": {"status": True, "variable":controller.setSpeakerEnergyThreshold}, - "/get/input_speaker_dynamic_energy_threshold": {"status": True, "variable":controller.getInputSpeakerDynamicEnergyThreshold}, - "/set/enable_input_speaker_dynamic_energy_threshold": {"status": True, "variable":controller.setEnableInputSpeakerDynamicEnergyThreshold}, - "/set/disable_input_speaker_dynamic_energy_threshold": {"status": True, "variable":controller.setDisableInputSpeakerDynamicEnergyThreshold}, + "/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/input_speaker_record_timeout": {"status": True, "variable":controller.getInputSpeakerRecordTimeout}, - "/set/input_speaker_record_timeout": {"status": True, "variable":controller.setInputSpeakerRecordTimeout}, + "/get/speaker_record_timeout": {"status": True, "variable":controller.getSpeakerRecordTimeout}, + "/set/speaker_record_timeout": {"status": True, "variable":controller.setSpeakerRecordTimeout}, - "/get/input_speaker_phrase_timeout": {"status": True, "variable":controller.getInputSpeakerPhraseTimeout}, - "/set/input_speaker_phrase_timeout": {"status": True, "variable":controller.setInputSpeakerPhraseTimeout}, + "/get/speaker_phrase_timeout": {"status": True, "variable":controller.getSpeakerPhraseTimeout}, + "/set/speaker_phrase_timeout": {"status": True, "variable":controller.setSpeakerPhraseTimeout}, - "/get/input_speaker_max_phrases": {"status": True, "variable":controller.getInputSpeakerMaxPhrases}, - "/set/input_speaker_max_phrases": {"status": True, "variable":controller.setInputSpeakerMaxPhrases}, + "/get/speaker_max_phrases": {"status": True, "variable":controller.getSpeakerMaxPhrases}, + "/set/speaker_max_phrases": {"status": True, "variable":controller.setSpeakerMaxPhrases}, - "/get/input_speaker_avg_logprob": {"status": True, "variable":controller.getInputSpeakerAvgLogprob}, - "/set/input_speaker_avg_logprob": {"status": True, "variable":controller.setInputSpeakerAvgLogprob}, + "/get/speaker_avg_logprob": {"status": True, "variable":controller.getSpeakerAvgLogprob}, + "/set/speaker_avg_logprob": {"status": True, "variable":controller.setSpeakerAvgLogprob}, - "/get/input_speaker_no_speech_prob": {"status": True, "variable":controller.getInputSpeakerNoSpeechProb}, - "/set/input_speaker_no_speech_prob": {"status": True, "variable":controller.setInputSpeakerNoSpeechProb}, + "/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}, @@ -179,11 +180,11 @@ mapping = { "/get/whisper_weight_type": {"status": True, "variable":controller.getWhisperWeightType}, "/set/whisper_weight_type": {"status": True, "variable":controller.setWhisperWeightType}, - "/get/enable_auto_clear_message_box": {"status": True, "variable":controller.getEnableAutoClearMessageBox}, + "/get/auto_clear_message_box": {"status": True, "variable":controller.getAutoClearMessageBox}, "/set/enable_auto_clear_message_box": {"status": True, "variable":controller.setEnableAutoClearMessageBox}, "/set/disable_auto_clear_message_box": {"status": True, "variable":controller.setDisableAutoClearMessageBox}, - "/get/enable_send_only_translated_messages": {"status": True, "variable":controller.getEnableSendOnlyTranslatedMessages}, + "/get/send_only_translated_messages": {"status": True, "variable":controller.getSendOnlyTranslatedMessages}, "/set/enable_send_only_translated_messages": {"status": True, "variable":controller.setEnableSendOnlyTranslatedMessages}, "/set/disable_send_only_translated_messages": {"status": True, "variable":controller.setDisableSendOnlyTranslatedMessages}, @@ -196,11 +197,11 @@ mapping = { "/get/overlay_small_log_settings": {"status": True, "variable":controller.getOverlaySmallLogSettings}, "/set/overlay_small_log_settings": {"status": True, "variable":controller.setOverlaySmallLogSettings}, - "/get/enable_overlay_small_log": {"status": True, "variable":controller.getEnableOverlaySmallLog}, + "/get/overlay_small_log": {"status": True, "variable":controller.getOverlaySmallLog}, "/set/enable_overlay_small_log": {"status": True, "variable":controller.setEnableOverlaySmallLog}, "/set/disable_overlay_small_log": {"status": True, "variable":controller.setDisableOverlaySmallLog}, - "/get/enable_send_message_to_vrc": {"status": True, "variable":controller.getEnableSendMessageToVrc}, + "/get/send_message_to_vrc": {"status": True, "variable":controller.getSendMessageToVrc}, "/set/enable_send_message_to_vrc": {"status": True, "variable":controller.setEnableSendMessageToVrc}, "/set/disable_send_message_to_vrc": {"status": True, "variable":controller.setDisableSendMessageToVrc}, @@ -216,19 +217,18 @@ mapping = { "/get/received_message_format_with_t": {"status": True, "variable":controller.getReceivedMessageFormatWithT}, "/set/received_message_format_with_t": {"status": True, "variable":controller.setReceivedMessageFormatWithT}, - "/get/enable_speaker2chatbox_pass": {"status": True, "variable":controller.getEnableSpeaker2ChatboxPass}, - "/set/enable_speaker2chatbox_pass": {"status": True, "variable":controller.setEnableSpeaker2ChatboxPass}, - "/set/disable_speaker2chatbox_pass": {"status": True, "variable":controller.setDisableSpeaker2ChatboxPass}, + "/get/speaker2chatbox_pass": {"status": True, "variable":controller.getSpeaker2ChatboxPass}, + "/set/speaker2chatbox_pass": {"status": True, "variable":controller.setSpeaker2ChatboxPass}, - "/get/enable_send_received_message_to_vrc": {"status": True, "variable":controller.getEnableSendReceivedMessageToVrc}, + "/get/send_received_message_to_vrc": {"status": True, "variable":controller.getSendReceivedMessageToVrc}, "/set/enable_send_received_message_to_vrc": {"status": True, "variable":controller.setEnableSendReceivedMessageToVrc}, "/set/disable_send_received_message_to_vrc": {"status": True, "variable":controller.setDisableSendReceivedMessageToVrc}, - "/get/enable_logger": {"status": True, "variable":controller.getEnableLogger}, + "/get/logger": {"status": True, "variable":controller.getLogger}, "/set/enable_logger": {"status": True, "variable":controller.setEnableLogger}, "/set/disable_logger": {"status": True, "variable":controller.setDisableLogger}, - "/get/enable_vrc_mic_mute_sync": {"status": True, "variable":controller.getEnableVrcMicMuteSync}, + "/get/vrc_mic_mute_sync": {"status": True, "variable":controller.getVrcMicMuteSync}, "/set/enable_vrc_mic_mute_sync": {"status": True, "variable":controller.setEnableVrcMicMuteSync}, "/set/disable_vrc_mic_mute_sync": {"status": True, "variable":controller.setDisableVrcMicMuteSync}, @@ -250,9 +250,9 @@ mapping = { "/set/enable_transcription_receive": {"status": False, "variable":controller.setEnableTranscriptionReceive}, "/set/disable_transcription_receive": {"status": False, "variable":controller.setDisableTranscriptionReceive}, - "/run/send_messagebox": {"status": False, "variable":controller.sendMessageBox}, - "/run/typing_messagebox": {"status": False, "variable":controller.typingMessageBox}, - "/run/stop_typing_messagebox": {"status": False, "variable":controller.stopTypingMessageBox}, + "/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}, @@ -290,7 +290,7 @@ action_mapping = { "speaker":"/action/check_speaker_threshold_energy", "error_device":"/action/error_device", }, - "/run/send_messagebox": { + "/run/send_message_box": { "error_translation_engine":"/action/error_translation_engine" }, "/run/download_ctranslate2_weight": { @@ -299,11 +299,11 @@ action_mapping = { "/run/download_whisper_weight": { "download":"/action/download_whisper_weight" }, - "/set/enable_mic_auto_selection": { - "mic":"/set/choice_mic_host", + "/set/enable_auto_mic_select": { + "mic":"/set/selected_mic_host", }, - "/set/enable_speaker_auto_selection": { - "speaker":"/set/choice_speaker_device", + "/set/enable_auto_speaker_select": { + "speaker":"/set/selected_speaker_device", } } @@ -399,8 +399,8 @@ if __name__ == "__main__": controller.init({ "download_ctranslate2": Action(action_mapping["/run/download_ctranslate2_weight"]).transmit, "download_whisper": Action(action_mapping["/run/download_whisper_weight"]).transmit, - "update_selected_mic_device": Action(action_mapping["/set/enable_mic_auto_selection"]).transmit, - "update_selected_speaker_device": Action(action_mapping["/set/enable_speaker_auto_selection"]).transmit, + "update_selected_mic_device": Action(action_mapping["/set/enable_auto_mic_select"]).transmit, + "update_selected_speaker_device": Action(action_mapping["/set/enable_auto_speaker_select"]).transmit, }) # mappingのすべてのstatusをTrueにする @@ -425,7 +425,7 @@ if __name__ == "__main__": printLog("endpoint", endpoint) match endpoint: - case "/run/send_messagebox": + case "/run/send_message_box": # handleRequest("/set/enable_translation") # handleRequest("/set/enable_convert_message_to_romaji") data = {"id":"123456", "message":"テスト"} @@ -519,31 +519,31 @@ if __name__ == "__main__": data = "Small" case "/set/deepl_auth_key": data = "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee:fx" - case "/set/choice_mic_host": + case "/set/selected_mic_host": data = "MME" - case "/set/choice_mic_device": + case "/set/selected_mic_device": data = "マイク (Realtek High Definition Audio)" - case "/set/input_mic_energy_threshold": + case "/set/mic_energy_threshold": data = 0.5 - case "/set/input_mic_record_timeout": + case "/set/mic_record_timeout": data = 1 - case "/set/input_mic_phrase_timeout": + case "/set/mic_phrase_timeout": data = 5 case "/set/input_set_mic_max_phrases": data = 5 - case "/set/input_mic_word_filter": + case "/set/mic_word_filter": data = "test0, test1, test2" - case "/del/input_mic_word_filter": + case "/del/mic_word_filter": data = "test1" - case "/set/choice_speaker_device": + case "/set/selected_speaker_device": data = "スピーカー (Realtek High Definition Audio)" - case "/set/input_speaker_energy_threshold": + case "/set/speaker_energy_threshold": data = 0.5 - case "/set/input_speaker_record_timeout": + case "/set/speaker_record_timeout": data = 5 - case "/set/input_speaker_phrase_timeout": + case "/set/speaker_phrase_timeout": data = 5 - case "/set/input_speaker_max_phrases": + case "/set/speaker_max_phrases": data = 5 case "/set/whisper_weight_type": data = "base" @@ -577,15 +577,15 @@ if __name__ == "__main__": data = "127.0.0.1" case "/set/osc_port": data = 8000 - case "/set/input_speaker_no_speech_prob": + case "/set/speaker_no_speech_prob": data = 0.5 - case "/set/input_speaker_avg_logprob": + case "/set/speaker_avg_logprob": data = 0.5 - case "/set/input_mic_no_speech_prob": + case "/set/mic_no_speech_prob": data = 0.5 - case "/set/input_mic_avg_logprob": + case "/set/mic_avg_logprob": data = 0.5 - case "/set/input_mic_max_phrases": + case "/set/mic_max_phrases": data = 5 case _: data = None diff --git a/src-ui/logics/configs/useEnableAutoClearMessageBox.js b/src-ui/logics/configs/useEnableAutoClearMessageBox.js index 44a45a8c..c489ce99 100644 --- a/src-ui/logics/configs/useEnableAutoClearMessageBox.js +++ b/src-ui/logics/configs/useEnableAutoClearMessageBox.js @@ -7,15 +7,15 @@ export const useEnableAutoClearMessageBox = () => { const getEnableAutoClearMessageBox = () => { updateEnableAutoClearMessageBox(() => new Promise(() => {})); - asyncStdoutToPython("/config/enable_auto_clear_message_box"); + asyncStdoutToPython("/get/auto_clear_message_box"); }; const toggleEnableAutoClearMessageBox = () => { updateEnableAutoClearMessageBox(() => new Promise(() => {})); if (currentEnableAutoClearMessageBox.data) { - asyncStdoutToPython("/controller/callback_disable_auto_clear_chatbox"); + asyncStdoutToPython("/set/disable_auto_clear_message_box"); } else { - asyncStdoutToPython("/controller/callback_enable_auto_clear_chatbox"); + asyncStdoutToPython("/set/enable_auto_clear_message_box"); } }; diff --git a/src-ui/logics/configs/useEnableAutoMicSelect.js b/src-ui/logics/configs/useEnableAutoMicSelect.js index 5dc5d8b1..811adf8c 100644 --- a/src-ui/logics/configs/useEnableAutoMicSelect.js +++ b/src-ui/logics/configs/useEnableAutoMicSelect.js @@ -7,15 +7,15 @@ export const useEnableAutoMicSelect = () => { const getEnableAutoMicSelect = () => { updateEnableAutoMicSelect(() => new Promise(() => {})); - asyncStdoutToPython("/config/enable_mic_automatic_selection"); + asyncStdoutToPython("/get/auto_mic_select"); }; const toggleEnableAutoMicSelect = () => { updateEnableAutoMicSelect(() => new Promise(() => {})); if (currentEnableAutoMicSelect.data) { - asyncStdoutToPython("/controller/callback_disable_mic_automatic_selection"); + asyncStdoutToPython("/set/disable_auto_mic_select"); } else { - asyncStdoutToPython("/controller/callback_enable_mic_automatic_selection"); + asyncStdoutToPython("/set/enable_auto_mic_select"); } }; diff --git a/src-ui/logics/configs/useEnableAutoSpeakerSelect.js b/src-ui/logics/configs/useEnableAutoSpeakerSelect.js index 79895545..2512fd55 100644 --- a/src-ui/logics/configs/useEnableAutoSpeakerSelect.js +++ b/src-ui/logics/configs/useEnableAutoSpeakerSelect.js @@ -7,15 +7,15 @@ export const useEnableAutoSpeakerSelect = () => { const getEnableAutoSpeakerSelect = () => { updateEnableAutoSpeakerSelect(() => new Promise(() => {})); - asyncStdoutToPython("/config/enable_speaker_automatic_selection"); + asyncStdoutToPython("/get/auto_speaker_select"); }; const toggleEnableAutoSpeakerSelect = () => { updateEnableAutoSpeakerSelect(() => new Promise(() => {})); if (currentEnableAutoSpeakerSelect.data) { - asyncStdoutToPython("/controller/callback_disable_speaker_automatic_selection"); + asyncStdoutToPython("/set/disable_auto_speaker_select"); } else { - asyncStdoutToPython("/controller/callback_enable_speaker_automatic_selection"); + asyncStdoutToPython("/set/enable_auto_speaker_select"); } }; diff --git a/src-ui/logics/configs/useMicDeviceList.js b/src-ui/logics/configs/useMicDeviceList.js index ac2ad813..4616d69d 100644 --- a/src-ui/logics/configs/useMicDeviceList.js +++ b/src-ui/logics/configs/useMicDeviceList.js @@ -7,7 +7,7 @@ export const useMicDeviceList = () => { const getMicDeviceList = () => { updateMicDeviceList(() => new Promise(() => {})); - asyncStdoutToPython("/controller/list_mic_device"); + asyncStdoutToPython("/get/list_mic_device"); }; return { diff --git a/src-ui/logics/configs/useMicHostList.js b/src-ui/logics/configs/useMicHostList.js index 9dcd044c..3595cff5 100644 --- a/src-ui/logics/configs/useMicHostList.js +++ b/src-ui/logics/configs/useMicHostList.js @@ -7,7 +7,7 @@ export const useMicHostList = () => { const getMicHostList = () => { updateMicHostList(() => new Promise(() => {})); - asyncStdoutToPython("/controller/list_mic_host"); + asyncStdoutToPython("/get/list_mic_host"); }; return { diff --git a/src-ui/logics/configs/useMicThreshold.js b/src-ui/logics/configs/useMicThreshold.js index 0a850f88..0ac383e4 100644 --- a/src-ui/logics/configs/useMicThreshold.js +++ b/src-ui/logics/configs/useMicThreshold.js @@ -7,24 +7,24 @@ export const useMicThreshold = () => { const { updateEnableAutomaticMicThreshold, currentEnableAutomaticMicThreshold } = useStore_EnableAutomaticMicThreshold(); const getMicThreshold = () => { - asyncStdoutToPython("/config/input_mic_energy_threshold"); + asyncStdoutToPython("/get/mic_energy_threshold"); }; const setMicThreshold = (mic_threshold) => { - asyncStdoutToPython("/controller/callback_set_mic_energy_threshold", mic_threshold); + asyncStdoutToPython("/set/mic_energy_threshold", mic_threshold); }; const getEnableAutomaticMicThreshold = () => { updateEnableAutomaticMicThreshold(() => new Promise(() => {})); - asyncStdoutToPython("/config/input_mic_dynamic_energy_threshold"); + asyncStdoutToPython("/get/mic_dynamic_energy_threshold"); }; const toggleEnableAutomaticMicThreshold = () => { updateEnableAutomaticMicThreshold(() => new Promise(() => {})); if (currentEnableAutomaticMicThreshold.data) { - asyncStdoutToPython("/controller/callback_disable_mic_dynamic_energy_threshold"); + asyncStdoutToPython("/set/disable_mic_dynamic_energy_threshold"); } else { - asyncStdoutToPython("/controller/callback_enable_mic_dynamic_energy_threshold"); + asyncStdoutToPython("/set/enable_mic_dynamic_energy_threshold"); } }; diff --git a/src-ui/logics/configs/useSelectedMicDevice.js b/src-ui/logics/configs/useSelectedMicDevice.js index 9eb9288c..8639faaa 100644 --- a/src-ui/logics/configs/useSelectedMicDevice.js +++ b/src-ui/logics/configs/useSelectedMicDevice.js @@ -7,12 +7,12 @@ export const useSelectedMicDevice = () => { const getSelectedMicDevice = () => { updateSelectedMicDevice(() => new Promise(() => {})); - asyncStdoutToPython("/config/choice_mic_device"); + asyncStdoutToPython("/get/selected_mic_device"); }; const setSelectedMicDevice = (selected_mic_device) => { updateSelectedMicDevice(() => new Promise(() => {})); - asyncStdoutToPython("/controller/callback_set_mic_device", selected_mic_device); + asyncStdoutToPython("/set/selected_mic_device", selected_mic_device); }; return { diff --git a/src-ui/logics/configs/useSelectedMicHost.js b/src-ui/logics/configs/useSelectedMicHost.js index ee624705..97ad8e00 100644 --- a/src-ui/logics/configs/useSelectedMicHost.js +++ b/src-ui/logics/configs/useSelectedMicHost.js @@ -7,12 +7,12 @@ export const useSelectedMicHost = () => { const getSelectedMicHost = () => { updateSelectedMicHost(() => new Promise(() => {})); - asyncStdoutToPython("/config/choice_mic_host"); + asyncStdoutToPython("/get/selected_mic_host"); }; const setSelectedMicHost = (selected_mic_host) => { updateSelectedMicHost(() => new Promise(() => {})); - asyncStdoutToPython("/controller/callback_set_mic_host", selected_mic_host); + asyncStdoutToPython("/set/selected_mic_host", selected_mic_host); }; return { diff --git a/src-ui/logics/configs/useSelectedSpeakerDevice.js b/src-ui/logics/configs/useSelectedSpeakerDevice.js index 4bef87c0..00053873 100644 --- a/src-ui/logics/configs/useSelectedSpeakerDevice.js +++ b/src-ui/logics/configs/useSelectedSpeakerDevice.js @@ -7,12 +7,12 @@ export const useSelectedSpeakerDevice = () => { const getSelectedSpeakerDevice = () => { updateSelectedSpeakerDevice(() => new Promise(() => {})); - asyncStdoutToPython("/config/choice_speaker_device"); + asyncStdoutToPython("/get/selected_speaker_device"); }; const setSelectedSpeakerDevice = (selected_speaker_device) => { updateSelectedSpeakerDevice(() => new Promise(() => {})); - asyncStdoutToPython("/controller/callback_set_speaker_device", selected_speaker_device); + asyncStdoutToPython("/set/selected_speaker_device", selected_speaker_device); }; return { diff --git a/src-ui/logics/configs/useSendMessageButtonType.js b/src-ui/logics/configs/useSendMessageButtonType.js index 27d19ef8..13e5be74 100644 --- a/src-ui/logics/configs/useSendMessageButtonType.js +++ b/src-ui/logics/configs/useSendMessageButtonType.js @@ -7,12 +7,12 @@ export const useSendMessageButtonType = () => { const getSendMessageButtonType = () => { updateSendMessageButtonType(() => new Promise(() => {})); - asyncStdoutToPython("/config/send_message_button_type"); + asyncStdoutToPython("/get/send_message_button_type"); }; const setSendMessageButtonType = (selected_type) => { updateSendMessageButtonType(() => new Promise(() => {})); - asyncStdoutToPython("/controller/callback_set_send_message_button_type", selected_type); + asyncStdoutToPython("/set/send_message_button_type", selected_type); }; return { diff --git a/src-ui/logics/configs/useSoftwareVersion.js b/src-ui/logics/configs/useSoftwareVersion.js index 055184fa..1731160b 100644 --- a/src-ui/logics/configs/useSoftwareVersion.js +++ b/src-ui/logics/configs/useSoftwareVersion.js @@ -7,7 +7,7 @@ export const useSoftwareVersion = () => { const getSoftwareVersion = () => { updateSoftwareVersion(() => new Promise(() => {})); - asyncStdoutToPython("/config/version"); + asyncStdoutToPython("/get/version"); }; return { diff --git a/src-ui/logics/configs/useSpeakerDeviceList.js b/src-ui/logics/configs/useSpeakerDeviceList.js index ec8cac1c..faf191b3 100644 --- a/src-ui/logics/configs/useSpeakerDeviceList.js +++ b/src-ui/logics/configs/useSpeakerDeviceList.js @@ -7,7 +7,7 @@ export const useSpeakerDeviceList = () => { const getSpeakerDeviceList = () => { updateSpeakerDeviceList(() => new Promise(() => {})); - asyncStdoutToPython("/controller/list_speaker_device"); + asyncStdoutToPython("/get/list_speaker_device"); }; return { diff --git a/src-ui/logics/configs/useSpeakerThreshold.js b/src-ui/logics/configs/useSpeakerThreshold.js index 74c2307b..fab741ae 100644 --- a/src-ui/logics/configs/useSpeakerThreshold.js +++ b/src-ui/logics/configs/useSpeakerThreshold.js @@ -7,24 +7,24 @@ export const useSpeakerThreshold = () => { const { updateEnableAutomaticSpeakerThreshold, currentEnableAutomaticSpeakerThreshold } = useStore_EnableAutomaticSpeakerThreshold(); const getSpeakerThreshold = () => { - asyncStdoutToPython("/config/input_speaker_energy_threshold"); + asyncStdoutToPython("/get/speaker_energy_threshold"); }; const setSpeakerThreshold = (speaker_threshold) => { - asyncStdoutToPython("/controller/callback_set_speaker_energy_threshold", speaker_threshold); + asyncStdoutToPython("/set/speaker_energy_threshold", speaker_threshold); }; const getEnableAutomaticSpeakerThreshold = () => { updateEnableAutomaticSpeakerThreshold(() => new Promise(() => {})); - asyncStdoutToPython("/config/input_speaker_dynamic_energy_threshold"); + asyncStdoutToPython("/get/speaker_dynamic_energy_threshold"); }; const toggleEnableAutomaticSpeakerThreshold = () => { updateEnableAutomaticSpeakerThreshold(() => new Promise(() => {})); if (currentEnableAutomaticSpeakerThreshold.data) { - asyncStdoutToPython("/controller/callback_disable_speaker_dynamic_energy_threshold"); + asyncStdoutToPython("/set/disable_speaker_dynamic_energy_threshold"); } else { - asyncStdoutToPython("/controller/callback_enable_speaker_dynamic_energy_threshold"); + asyncStdoutToPython("/set/enable_speaker_dynamic_energy_threshold"); } }; diff --git a/src-ui/logics/configs/useUiLanguage.js b/src-ui/logics/configs/useUiLanguage.js index 31e134e5..671d314b 100644 --- a/src-ui/logics/configs/useUiLanguage.js +++ b/src-ui/logics/configs/useUiLanguage.js @@ -7,12 +7,12 @@ export const useUiLanguage = () => { const getUiLanguage = () => { updateUiLanguage(() => new Promise(() => {})); - asyncStdoutToPython("/config/ui_language"); + asyncStdoutToPython("/get/ui_language"); }; const setUiLanguage = (selected_ui_language) => { updateUiLanguage(() => new Promise(() => {})); - asyncStdoutToPython("/controller/callback_set_ui_language", selected_ui_language); + asyncStdoutToPython("/set/ui_language", selected_ui_language); }; return { diff --git a/src-ui/logics/useLanguageSettings.js b/src-ui/logics/useLanguageSettings.js index b2bc8a64..e3a4756f 100644 --- a/src-ui/logics/useLanguageSettings.js +++ b/src-ui/logics/useLanguageSettings.js @@ -10,24 +10,24 @@ export const useLanguageSettings = () => { const getEnableMultiTranslation = () => { updateEnableMultiTranslation(() => new Promise(() => {})); - asyncStdoutToPython("/config/enable_multi_translation"); + asyncStdoutToPython("/get/multi_language_translation"); }; const getSelectedPresetTabNumber = () => { updateSelectedPresetTabNumber(() => new Promise(() => {})); - asyncStdoutToPython("/config/selected_tab_no"); + asyncStdoutToPython("/get/selected_tab_no"); }; const setSelectedPresetTabNumber = (preset_number) => { updateSelectedPresetTabNumber(() => new Promise(() => {})); - asyncStdoutToPython("/controller/callback_selected_language_preset_tab", preset_number); + asyncStdoutToPython("/set/selected_tab_no", preset_number); }; const getSelectedYourLanguages = () => { updateSelectedYourLanguages(() => new Promise(() => {})); - asyncStdoutToPython("/config/selected_tab_your_languages"); + asyncStdoutToPython("/get/selected_your_languages"); }; 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 = () => { updateSelectedTargetLanguages(() => new Promise(() => {})); - asyncStdoutToPython("/config/selected_tab_target_languages"); + asyncStdoutToPython("/get/selected_target_languages"); }; 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.country = selected_language_data.country, - asyncStdoutToPython("/controller/set_target_language_and_country", send_obj); + asyncStdoutToPython("/set/selected_target_languages", send_obj); }; return { diff --git a/src-ui/logics/useMainFunction.js b/src-ui/logics/useMainFunction.js index 88e20245..114ec31f 100644 --- a/src-ui/logics/useMainFunction.js +++ b/src-ui/logics/useMainFunction.js @@ -36,27 +36,27 @@ export const useMainFunction = () => { const toggleTranslation = () => { asyncUpdateTranslationStatus(asyncPending); if (currentTranslationStatus.data) { - asyncStdoutToPython("/controller/callback_disable_translation"); + asyncStdoutToPython("/set/disable_translation"); } else { - asyncStdoutToPython("/controller/callback_enable_translation"); + asyncStdoutToPython("/set/enable_translation"); } }; const toggleTranscriptionSend = () => { asyncUpdateTranscriptionSendStatus(asyncPending); if (currentTranscriptionSendStatus.data) { - asyncStdoutToPython("/controller/callback_disable_transcription_send"); + asyncStdoutToPython("/set/disable_transcription_send"); } else { - asyncStdoutToPython("/controller/callback_enable_transcription_send"); + asyncStdoutToPython("/set/enable_transcription_send"); } }; const toggleTranscriptionReceive = () => { asyncUpdateTranscriptionReceiveStatus(asyncPending); if (currentTranscriptionReceiveStatus.data) { - asyncStdoutToPython("/controller/callback_disable_transcription_receive"); + asyncStdoutToPython("/set/disable_transcription_receive"); } else { - asyncStdoutToPython("/controller/callback_enable_transcription_receive"); + asyncStdoutToPython("/set/enable_transcription_receive"); } }; diff --git a/src-ui/logics/useMessage.js b/src-ui/logics/useMessage.js index bb3a1ea2..3773e0ba 100644 --- a/src-ui/logics/useMessage.js +++ b/src-ui/logics/useMessage.js @@ -14,7 +14,7 @@ export const useMessage = () => { id: uuid, message: message, }; - asyncStdoutToPython("/controller/callback_messagebox_send", send_message_object); + asyncStdoutToPython("/run/send_message_box", send_message_object); addMessageLogs({ id: uuid, diff --git a/src-ui/logics/useReceiveRoutes.js b/src-ui/logics/useReceiveRoutes.js index fee89a4a..acd5668b 100644 --- a/src-ui/logics/useReceiveRoutes.js +++ b/src-ui/logics/useReceiveRoutes.js @@ -72,77 +72,77 @@ export const useReceiveRoutes = () => { } = useVolume(); const routes = { - "/controller/callback_enable_translation": updateTranslationStatus, - "/controller/callback_disable_translation": updateTranslationStatus, - "/controller/callback_enable_transcription_send": updateTranscriptionSendStatus, - "/controller/callback_disable_transcription_send": updateTranscriptionSendStatus, - "/controller/callback_enable_transcription_receive": updateTranscriptionReceiveStatus, - "/controller/callback_disable_transcription_receive": updateTranscriptionReceiveStatus, + "/set/enable_translation": updateTranslationStatus, + "/set/disable_translation": updateTranslationStatus, + "/set/enable_transcription_send": updateTranscriptionSendStatus, + "/set/disable_transcription_send": updateTranscriptionSendStatus, + "/set/enable_transcription_receive": updateTranscriptionReceiveStatus, + "/set/disable_transcription_receive": updateTranscriptionReceiveStatus, - "/config/selected_tab_no": updateSelectedPresetTabNumber, - "/controller/callback_selected_language_preset_tab": updateSelectedPresetTabNumber, - "/config/enable_multi_translation": updateEnableMultiTranslation, - "/config/selected_tab_your_languages": updateSelectedYourLanguages, - "/controller/set_your_language_and_country": updateSelectedYourLanguages, - "/config/selected_tab_target_languages": updateSelectedTargetLanguages, - "/controller/set_your_language_and_country": updateSelectedTargetLanguages, + "/get/selected_tab_no": updateSelectedPresetTabNumber, + "/set/selected_tab_no": updateSelectedPresetTabNumber, + "/get/multi_language_translation": updateEnableMultiTranslation, + "/get/selected_your_languages": updateSelectedYourLanguages, + "/set/selected_your_languages": updateSelectedYourLanguages, + "/get/selected_target_languages": 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, - "/controller/callback_enable_mic_automatic_selection": updateEnableAutoMicSelect, - "/controller/callback_disable_mic_automatic_selection": updateEnableAutoMicSelect, - "/config/enable_speaker_automatic_selection": updateEnableAutoSpeakerSelect, - "/controller/callback_enable_speaker_automatic_selection": updateEnableAutoSpeakerSelect, - "/controller/callback_disable_speaker_automatic_selection": updateEnableAutoSpeakerSelect, + "/get/auto_mic_select": updateEnableAutoMicSelect, + "/set/enable_auto_mic_select": updateEnableAutoMicSelect, + "/set/disable_auto_mic_select": updateEnableAutoMicSelect, + "/get/auto_speaker_select": updateEnableAutoSpeakerSelect, + "/set/enable_auto_speaker_select": updateEnableAutoSpeakerSelect, + "/set/disable_auto_speaker_select": updateEnableAutoSpeakerSelect, - "/controller/list_mic_host": (payload) => updateMicHostList(arrayToObject(payload)), - "/config/choice_mic_host": updateSelectedMicHost, - "/controller/callback_set_mic_host": (payload) => { + "/get/list_mic_host": (payload) => updateMicHostList(arrayToObject(payload)), + "/get/selected_mic_host": updateSelectedMicHost, + "/set/selected_mic_host": (payload) => { updateSelectedMicHost(payload.host); updateSelectedMicDevice(payload.device); }, - "/controller/list_mic_device": (payload) => updateMicDeviceList(arrayToObject(payload)), - "/config/choice_mic_device": updateSelectedMicDevice, - "/controller/callback_set_mic_device": updateSelectedMicDevice, + "/get/list_mic_device": (payload) => updateMicDeviceList(arrayToObject(payload)), + "/get/selected_mic_device": updateSelectedMicDevice, + "/set/selected_mic_device": updateSelectedMicDevice, - "/controller/list_speaker_device": (payload) => updateSpeakerDeviceList(arrayToObject(payload)), - "/config/choice_speaker_device": updateSelectedSpeakerDevice, - "/controller/callback_set_speaker_device": updateSelectedSpeakerDevice, + "/get/list_speaker_device": (payload) => updateSpeakerDeviceList(arrayToObject(payload)), + "/get/selected_speaker_device": updateSelectedSpeakerDevice, + "/set/selected_speaker_device": updateSelectedSpeakerDevice, "/action/check_mic_threshold_energy": updateVolumeVariable_Mic, "/action/check_speaker_threshold_energy": updateVolumeVariable_Speaker, - "/controller/callback_enable_check_mic_threshold": updateMicThresholdCheckStatus, - "/controller/callback_disable_check_mic_threshold": updateMicThresholdCheckStatus, - "/controller/callback_enable_check_speaker_threshold": updateSpeakerThresholdCheckStatus, - "/controller/callback_disable_check_speaker_threshold": updateSpeakerThresholdCheckStatus, + "/set/enable_check_mic_threshold": updateMicThresholdCheckStatus, + "/set/disable_check_mic_threshold": updateMicThresholdCheckStatus, + "/set/enable_check_speaker_threshold": updateSpeakerThresholdCheckStatus, + "/set/disable_check_speaker_threshold": updateSpeakerThresholdCheckStatus, - "/config/enable_auto_clear_message_box": updateEnableAutoClearMessageBox, - "/controller/callback_enable_auto_clear_chatbox": updateEnableAutoClearMessageBox, - "/controller/callback_disable_auto_clear_chatbox": updateEnableAutoClearMessageBox, + "/get/auto_clear_message_box": updateEnableAutoClearMessageBox, + "/set/enable_auto_clear_message_box": updateEnableAutoClearMessageBox, + "/set/disable_auto_clear_message_box": updateEnableAutoClearMessageBox, - "/config/send_message_button_type": updateSendMessageButtonType, - "/controller/callback_set_send_message_button_type": updateSendMessageButtonType, + "/get/send_message_button_type": updateSendMessageButtonType, + "/set/send_message_button_type": updateSendMessageButtonType, - "/config/input_mic_energy_threshold": updateMicThreshold, - "/controller/callback_set_mic_energy_threshold": updateMicThreshold, - "/config/input_speaker_energy_threshold": updateSpeakerThreshold, - "/controller/callback_set_speaker_energy_threshold": updateSpeakerThreshold, + "/get/mic_energy_threshold": updateMicThreshold, + "/set/mic_energy_threshold": updateMicThreshold, + "/get/speaker_energy_threshold": updateSpeakerThreshold, + "/set/speaker_energy_threshold": updateSpeakerThreshold, - "/config/input_mic_dynamic_energy_threshold": updateEnableAutomaticMicThreshold, - "/controller/callback_enable_mic_dynamic_energy_threshold": updateEnableAutomaticMicThreshold, - "/controller/callback_disable_mic_dynamic_energy_threshold": updateEnableAutomaticMicThreshold, - "/config/input_speaker_dynamic_energy_threshold": updateEnableAutomaticSpeakerThreshold, - "/controller/callback_enable_speaker_dynamic_energy_threshold": updateEnableAutomaticSpeakerThreshold, + "/get/mic_dynamic_energy_threshold": updateEnableAutomaticMicThreshold, + "/set/enable_mic_dynamic_energy_threshold": updateEnableAutomaticMicThreshold, + "/set/disable_mic_dynamic_energy_threshold": updateEnableAutomaticMicThreshold, + "/get/speaker_dynamic_energy_threshold": updateEnableAutomaticSpeakerThreshold, + "/set/enable_speaker_dynamic_energy_threshold": updateEnableAutomaticSpeakerThreshold, - "/config/ui_language": updateUiLanguage, - "/controller/callback_set_ui_language": updateUiLanguage, + "/get/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_receive_speaker_message": addReceivedMessageLog }; diff --git a/src-ui/logics/useSelectableLanguageList.js b/src-ui/logics/useSelectableLanguageList.js index 1e31a2d2..c2ad71cf 100644 --- a/src-ui/logics/useSelectableLanguageList.js +++ b/src-ui/logics/useSelectableLanguageList.js @@ -6,7 +6,7 @@ export const useSelectableLanguageList = () => { const { currentSelectableLanguageList, updateSelectableLanguageList } = useStore_SelectableLanguageList(); const getSelectableLanguageList = () => { - asyncStdoutToPython("/controller/list_language_and_country"); + asyncStdoutToPython("/get/list_languages"); }; return { diff --git a/src-ui/logics/useVolume.js b/src-ui/logics/useVolume.js index 6ae7587c..974b822b 100644 --- a/src-ui/logics/useVolume.js +++ b/src-ui/logics/useVolume.js @@ -18,11 +18,11 @@ export const useVolume = () => { return { volumeCheckStart_Mic: () => { updateMicThresholdCheckStatus(asyncPending); - asyncStdoutToPython("/controller/callback_enable_check_mic_threshold"); + asyncStdoutToPython("/set/enable_check_mic_threshold"); }, volumeCheckStop_Mic: () => { updateMicThresholdCheckStatus(asyncPending); - asyncStdoutToPython("/controller/callback_disable_check_mic_threshold"); + asyncStdoutToPython("/set/disable_check_mic_threshold"); }, updateVolumeVariable_Mic: (payload) => { updateMicVolume(payload); @@ -36,11 +36,11 @@ export const useVolume = () => { volumeCheckStart_Speaker: () => { updateSpeakerVolume("0"); updateSpeakerThresholdCheckStatus(asyncPending); - asyncStdoutToPython("/controller/callback_enable_check_speaker_threshold"); + asyncStdoutToPython("/set/enable_check_speaker_threshold"); }, volumeCheckStop_Speaker: () => { updateSpeakerThresholdCheckStatus(asyncPending); - asyncStdoutToPython("/controller/callback_disable_check_speaker_threshold"); + asyncStdoutToPython("/set/disable_check_speaker_threshold"); }, updateVolumeVariable_Speaker: (payload) => { updateSpeakerVolume(payload); From de445998277d3a6e1e8d8c1a1c3e13ebb945f192 Mon Sep 17 00:00:00 2001 From: misyaguziya Date: Fri, 20 Sep 2024 05:35:51 +0900 Subject: [PATCH 3/3] =?UTF-8?q?=F0=9F=91=8D=EF=B8=8F[Update]=20Model:=20Au?= =?UTF-8?q?to=20Mic/Speaker=20Select=20ON=E6=99=82=E3=81=ABDefault=20Devic?= =?UTF-8?q?e=E3=82=92UI=E3=81=AB=E3=82=BB=E3=83=83=E3=83=88=E3=81=99?= =?UTF-8?q?=E3=82=8B=E3=82=88=E3=81=86=E3=81=AB=E5=A4=89=E6=9B=B4?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../models/transcription/transcription_utils.py | 12 +++++++----- src-python/webui_controller.py | 6 ++++-- 2 files changed, 11 insertions(+), 7 deletions(-) diff --git a/src-python/models/transcription/transcription_utils.py b/src-python/models/transcription/transcription_utils.py index 2b51ec31..e00e03eb 100644 --- a/src-python/models/transcription/transcription_utils.py +++ b/src-python/models/transcription/transcription_utils.py @@ -125,11 +125,7 @@ class DeviceManager: sleep(1) enumerator.UnregisterEndpointNotificationCallback(cb) self.update() - - 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"]) + self.noticeDefaultDevice() cb = Client() enumerator = AudioUtilities.GetDeviceEnumerator() @@ -160,6 +156,12 @@ class DeviceManager: def clearCallbackDefaultOutputDevice(self): 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): return self.input_devices diff --git a/src-python/webui_controller.py b/src-python/webui_controller.py index 734cd796..bda7956f 100644 --- a/src-python/webui_controller.py +++ b/src-python/webui_controller.py @@ -552,9 +552,10 @@ def getAutoMicSelect(*args, **kwargs) -> dict: return {"status":200, "result":config.AUTO_MIC_SELECT} def setEnableAutoMicSelect(data, action, *args, **kwargs) -> dict: + config.AUTO_MIC_SELECT = True update_device = UpdateSelectedMicDevice(action) device_manager.setCallbackDefaultInputDevice(update_device.set) - config.AUTO_MIC_SELECT = True + device_manager.noticeDefaultDevice() return {"status":200, "result":config.AUTO_MIC_SELECT} def setDisableAutoMicSelect(*args, **kwargs) -> dict: @@ -710,9 +711,10 @@ def getAutoSpeakerSelect(*args, **kwargs) -> dict: return {"status":200, "result":config.AUTO_SPEAKER_SELECT} def setEnableAutoSpeakerSelect(data, action, *args, **kwargs) -> dict: + config.AUTO_SPEAKER_SELECT = True update_device = UpdateSelectedSpeakerDevice(action) device_manager.setCallbackDefaultOutputDevice(update_device.set) - config.AUTO_SPEAKER_SELECT = True + device_manager.noticeDefaultDevice() return {"status":200, "result":config.AUTO_SPEAKER_SELECT} def setDisableAutoSpeakerSelect(*args, **kwargs) -> dict: