diff --git a/src-python/config.py b/src-python/config.py index ec4c1dc3..eec377c3 100644 --- a/src-python/config.py +++ b/src-python/config.py @@ -963,7 +963,7 @@ class Config: self._VERSION = "2.2.5" self._ENABLE_SPEAKER2CHATBOX = False # Speaker2Chatbox self._ENABLE_SPEAKER2CHATBOX_PASS_CONFIRMATION = "VRCT=0YEN" - self._PATH_LOCAL = os_path.dirname(sys.argv[0]) + self._PATH_LOCAL = os_path.dirname(sys.executable) self._PATH_CONFIG = os_path.join(self._PATH_LOCAL, "config.json") self._PATH_LOGS = os_path.join(self._PATH_LOCAL, "logs") os_makedirs(self._PATH_LOGS, exist_ok=True) diff --git a/src-python/webui_controller.py b/src-python/webui_controller.py index 4d3a03b4..5f69fd01 100644 --- a/src-python/webui_controller.py +++ b/src-python/webui_controller.py @@ -4,7 +4,7 @@ from subprocess import Popen from threading import Thread from config import config from model import model -from view import view +# from view import view from utils import getKeyByValue, isUniqueStrings, strPctToInt import argparse @@ -33,18 +33,19 @@ def callbackQuitVrct(): def callbackEnableEasterEgg(): config.IS_EASTER_EGG_ENABLED = True config.OVERLAY_UI_TYPE = "sakura" - view.printToTextbox_enableEasterEgg() + # view.printToTextbox_enableEasterEgg() def setMainWindowGeometry(): - PRE_SCALING_INT = strPctToInt(view.getPreUiScaling()) - NEW_SCALING_INT = strPctToInt(config.UI_SCALING) - MULTIPLY_FLOAT = (NEW_SCALING_INT / PRE_SCALING_INT) - main_window_geometry = view.getMainWindowGeometry(return_int=True) - main_window_geometry["width"] = str(int(main_window_geometry["width"] * MULTIPLY_FLOAT)) - main_window_geometry["height"] = str(int(main_window_geometry["height"] * MULTIPLY_FLOAT)) - main_window_geometry["x_pos"] = str(main_window_geometry["x_pos"]) - main_window_geometry["y_pos"] = str(main_window_geometry["y_pos"]) - config.MAIN_WINDOW_GEOMETRY = main_window_geometry + # PRE_SCALING_INT = strPctToInt(view.getPreUiScaling()) + # NEW_SCALING_INT = strPctToInt(config.UI_SCALING) + # MULTIPLY_FLOAT = (NEW_SCALING_INT / PRE_SCALING_INT) + # main_window_geometry = view.getMainWindowGeometry(return_int=True) + # main_window_geometry["width"] = str(int(main_window_geometry["width"] * MULTIPLY_FLOAT)) + # main_window_geometry["height"] = str(int(main_window_geometry["height"] * MULTIPLY_FLOAT)) + # main_window_geometry["x_pos"] = str(main_window_geometry["x_pos"]) + # main_window_geometry["y_pos"] = str(main_window_geometry["y_pos"]) + # config.MAIN_WINDOW_GEOMETRY = main_window_geometry + pass def messageFormatter(format_type:str, translation, message): if format_type == "RECEIVED": @@ -68,7 +69,7 @@ def changeToCTranslate2Process(): config.CHOICE_INPUT_TRANSLATOR = "CTranslate2" config.CHOICE_OUTPUT_TRANSLATOR = "CTranslate2" updateTranslationEngineAndEngineList() - view.printToTextbox_TranslationEngineLimitError() + # view.printToTextbox_TranslationEngineLimitError() # func transcription send message class MicMessage: @@ -82,7 +83,7 @@ class MicMessage: addSentMessageLog(message) translation = "" if model.checkKeywords(message): - self.action({"status":"error", f"message":"Detected by word filter:{message}"}) + self.action("mic", {"status":"error", "message":f"Detected by word filter:{message}"}) return elif model.detectRepeatSendMessage(message): return @@ -104,7 +105,7 @@ class MicMessage: osc_message = messageFormatter("SEND", translation, message) model.oscSendMessage(osc_message) - self.action({"status":"success", "message":message, "translation":translation}) + self.action("mic", {"status":"success", "message":message, "translation":translation}) if config.ENABLE_LOGGER is True: if len(translation) > 0: translation = f" ({translation})" @@ -122,7 +123,7 @@ def startTranscriptionSendMessage(action:Callable[[dict], None]) -> None: def stopTranscriptionSendMessage(action:Callable[[dict], None]) -> None: model.stopMicTranscript() - action({"status":"success", "message":"Stopped sending messages"}) + action("mic", {"status":"success", "message":"Stopped sending messages"}) def startThreadingTranscriptionSendMessage(action:Callable[[dict], None]) -> None: th_startTranscriptionSendMessage = Thread(target=startTranscriptionSendMessage, args=(action,)) @@ -134,18 +135,19 @@ def stopThreadingTranscriptionSendMessage(action:Callable[[dict], None]) -> None th_stopTranscriptionSendMessage.daemon = True th_stopTranscriptionSendMessage.start() -def startTranscriptionSendMessageOnCloseConfigWindow(): - model.startMicTranscript(sendMicMessage, view.printToTextbox_TranscriptionSendNoDeviceError) +def startTranscriptionSendMessageOnCloseConfigWindow(action:Callable[[dict], None]) -> None: + mic_message = MicMessage(action) + model.startMicTranscript(mic_message.send) def stopTranscriptionSendMessageOnOpenConfigWindow(): model.stopMicTranscript() -def startThreadingTranscriptionSendMessageOnCloseConfigWindow(): - th_startTranscriptionSendMessage = Thread(target=startTranscriptionSendMessageOnCloseConfigWindow) +def startThreadingTranscriptionSendMessageOnCloseConfigWindow(action:Callable[[dict], None]) -> None: + th_startTranscriptionSendMessage = Thread(target=startTranscriptionSendMessageOnCloseConfigWindow, args=(action,)) th_startTranscriptionSendMessage.daemon = True th_startTranscriptionSendMessage.start() -def stopThreadingTranscriptionSendMessageOnOpenConfigWindow(): +def stopThreadingTranscriptionSendMessageOnOpenConfigWindow() -> None: th_stopTranscriptionSendMessage = Thread(target=stopTranscriptionSendMessageOnOpenConfigWindow) th_stopTranscriptionSendMessage.daemon = True th_stopTranscriptionSendMessage.start() @@ -157,7 +159,7 @@ class SpeakerMessage: def receive(self, message): if isinstance(message, bool) and message is False: - self.action({"status":"error", "message":"No mic device detected."}) + self.action("speaker", {"status":"error", "message":"No mic device detected."}) elif isinstance(message, str) and len(message) > 0: translation = "" if model.detectRepeatReceiveMessage(message): @@ -190,7 +192,7 @@ class SpeakerMessage: # ------------Speaker2Chatbox------------ # update textbox message log (Received) - self.action({"status":"success", "message":message, "translation":translation}) + self.action("speaker",{"status":"success", "message":message, "translation":translation}) if config.ENABLE_LOGGER is True: if len(translation) > 0: translation = f" ({translation})" @@ -214,15 +216,15 @@ def stopThreadingTranscriptionReceiveMessage(action:Callable[[dict], None]) -> N th_stopTranscriptionReceiveMessage.daemon = True th_stopTranscriptionReceiveMessage.start() -def startTranscriptionReceiveMessageOnCloseConfigWindow(): - model.startSpeakerTranscript(receiveSpeakerMessage, view.printToTextbox_TranscriptionReceiveNoDeviceError) - +def startTranscriptionReceiveMessageOnCloseConfigWindow(action:Callable[[dict], None]) -> None: + speaker_message = SpeakerMessage(action) + model.startSpeakerTranscript(speaker_message.receive) def stopTranscriptionReceiveMessageOnOpenConfigWindow(): model.stopSpeakerTranscript() -def startThreadingTranscriptionReceiveMessageOnCloseConfigWindow(): - th_startTranscriptionReceiveMessage = Thread(target=startTranscriptionReceiveMessageOnCloseConfigWindow) +def startThreadingTranscriptionReceiveMessageOnCloseConfigWindow(action:Callable[[dict], None]) -> None: + th_startTranscriptionReceiveMessage = Thread(target=startTranscriptionReceiveMessageOnCloseConfigWindow, args=(action,)) th_startTranscriptionReceiveMessage.daemon = True th_startTranscriptionReceiveMessage.start() @@ -261,7 +263,7 @@ def sendChatMessage(message): # model.updateOverlay(overlay_image) # update textbox message log (Sent) - view.printToTextbox_SentMessage(message, translation) + # view.printToTextbox_SentMessage(message, translation) if config.ENABLE_LOGGER is True: if len(translation) > 0: translation = f" ({translation})" @@ -269,12 +271,14 @@ def sendChatMessage(message): # delete message in entry message box if config.ENABLE_AUTO_CLEAR_MESSAGE_BOX is True: - view.clearMessageBox() + # view.clearMessageBox() + pass def messageBoxPressKeyEnter(): - model.oscStopSendTyping() - message = view.getTextFromMessageBox() - sendChatMessage(message) + # model.oscStopSendTyping() + # message = view.getTextFromMessageBox() + # sendChatMessage(message) + pass def messageBoxPressKeyAny(e): if config.ENABLE_SEND_MESSAGE_TO_VRC is True: @@ -283,10 +287,11 @@ def messageBoxPressKeyAny(e): model.oscStopSendTyping() def messageBoxFocusIn(e): - view.foregroundOffIfForegroundEnabled() + # view.foregroundOffIfForegroundEnabled() + pass def messageBoxFocusOut(e): - view.foregroundOnIfForegroundEnabled() + # view.foregroundOnIfForegroundEnabled() if config.ENABLE_SEND_MESSAGE_TO_VRC is True: model.oscStopSendTyping() @@ -300,7 +305,7 @@ def updateMessageBox(index_offset): 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) + # view.replaceMessageBox(target_message_text) config.CURRENT_SENT_MESSAGES_LOG_INDEX = new_index except IndexError: pass @@ -355,7 +360,14 @@ def setYourLanguageAndCountry(select:dict, *args, **kwargs) -> dict: config.SOURCE_LANGUAGE = select["language"] config.SOURCE_COUNTRY = select["country"] updateTranslationEngineAndEngineList() - return {"status":"success"} + return {"status":"success", + "data":{ + "your":{ + "language":config.SOURCE_LANGUAGE, + "country":config.SOURCE_COUNTRY + } + } + } def setTargetLanguageAndCountry(select:dict, *args, **kwargs) -> dict: print("setTargetLanguageAndCountry", select) @@ -365,7 +377,14 @@ def setTargetLanguageAndCountry(select:dict, *args, **kwargs) -> dict: config.TARGET_LANGUAGE = select["language"] config.TARGET_COUNTRY = select["country"] updateTranslationEngineAndEngineList() - return {"status":"success"} + return {"status":"success", + "data":{ + "target":{ + "language":config.TARGET_LANGUAGE, + "country":config.TARGET_COUNTRY + }, + } + } def swapYourLanguageAndTargetLanguage(*args, **kwargs) -> dict: print("swapYourLanguageAndTargetLanguage") @@ -373,7 +392,17 @@ def swapYourLanguageAndTargetLanguage(*args, **kwargs) -> dict: target_language = config.SELECTED_TAB_TARGET_LANGUAGES[config.SELECTED_TAB_NO] setYourLanguageAndCountry(target_language) setTargetLanguageAndCountry(your_language) - return {"status":"success"} + return {"status":"success", + "data":{ + "your":{"language":config.SOURCE_LANGUAGE, + "country":config.SOURCE_COUNTRY, + }, + "target":{ + "language":config.TARGET_LANGUAGE, + "country":config.TARGET_COUNTRY, + }, + }, + } def callbackSelectedLanguagePresetTab(selected_tab_no:str, *args, **kwargs) -> dict: print("callbackSelectedLanguagePresetTab", selected_tab_no) @@ -397,13 +426,13 @@ def callbackSelectedLanguagePresetTab(selected_tab_no:str, *args, **kwargs) -> d config.TARGET_LANGUAGE = select["language"] config.TARGET_COUNTRY = select["country"] updateTranslationEngineAndEngineList() - return {"status":"success"} + return {"status":"success", "data":config.SELECTED_TAB_NO} def callbackSelectedTranslationEngine(selected_translation_engine:str, *args, **kwargs) -> dict: print("callbackSelectedTranslationEngine", selected_translation_engine) setYourTranslateEngine(selected_translation_engine) setTargetTranslateEngine(selected_translation_engine) - return {"status":"success"} + return {"status":"success", "data":selected_translation_engine} # command func def callbackEnableTranslation(*args, **kwargs) -> dict: @@ -411,23 +440,23 @@ def callbackEnableTranslation(*args, **kwargs) -> dict: config.ENABLE_TRANSLATION = True if model.isLoadedCTranslate2Model() is False: model.changeTranslatorCTranslate2Model() - return {"status":"success"} + return {"status":"success", "data":config.ENABLE_TRANSLATION} def callbackDisableTranslation(*args, **kwargs) -> dict: print("callbackDisableTranslation") config.ENABLE_TRANSLATION = False - return {"status":"success"} + return {"status":"success", "data":config.ENABLE_TRANSLATION} def callbackEnableTranscriptionSend(data, action, *args, **kwargs) -> dict: print("callbackEnableTranscriptionSend") config.ENABLE_TRANSCRIPTION_SEND = True startThreadingTranscriptionSendMessage(action) - return {"status":"success"} + return {"status":"success", "data":config.ENABLE_TRANSCRIPTION_SEND} def callbackDisableTranscriptionSend(data, action, *args, **kwargs) -> dict: config.ENABLE_TRANSCRIPTION_SEND = False stopThreadingTranscriptionSendMessage(action) - return {"status":"success"} + return {"status":"success", "data":config.ENABLE_TRANSCRIPTION_SEND} def callbackEnableTranscriptionReceive(data, action, *args, **kwargs) -> dict: config.ENABLE_TRANSCRIPTION_RECEIVE = True @@ -436,109 +465,109 @@ def callbackEnableTranscriptionReceive(data, action, *args, **kwargs) -> dict: if config.ENABLE_OVERLAY_SMALL_LOG is True: if model.overlay.initialized is False and model.overlay.checkSteamvrRunning() is True: model.startOverlay() - return {"status":"success"} + return {"status":"success", "data":config.ENABLE_TRANSCRIPTION_RECEIVE} def callbackDisableTranscriptionReceive(data, action, *args, **kwargs) -> dict: config.ENABLE_TRANSCRIPTION_RECEIVE = False stopThreadingTranscriptionReceiveMessage(action) - return {"status":"success"} + return {"status":"success", "data":config.ENABLE_TRANSCRIPTION_RECEIVE} -def callbackEnableForeground() -> None: +def callbackEnableForeground(*args, **kwargs) -> dict: config.ENABLE_FOREGROUND = True - return {"status":"success"} + return {"status":"success", "data":config.ENABLE_FOREGROUND} -def callbackDisableForeground() -> None: +def callbackDisableForeground(*args, **kwargs) -> dict: config.ENABLE_FOREGROUND = False - return {"status":"success"} + return {"status":"success", "data":config.ENABLE_FOREGROUND} -def callbackEnableMainWindowSidebarCompactMode() -> None: +def callbackEnableMainWindowSidebarCompactMode(*args, **kwargs) -> dict: config.IS_MAIN_WINDOW_SIDEBAR_COMPACT_MODE = True - return {"status":"success"} + return {"status":"success", "data":config.IS_MAIN_WINDOW_SIDEBAR_COMPACT_MODE} -def callbackDisableMainWindowSidebarCompactMode() -> None: +def callbackDisableMainWindowSidebarCompactMode(*args, **kwargs) -> dict: config.IS_MAIN_WINDOW_SIDEBAR_COMPACT_MODE = False - return {"status":"success"} + return {"status":"success", "data":config.IS_MAIN_WINDOW_SIDEBAR_COMPACT_MODE} # Config Window -def callbackOpenConfigWindow() -> dict: +def callbackOpenConfigWindow(*args, **kwargs) -> dict: if config.ENABLE_TRANSCRIPTION_SEND is True: stopThreadingTranscriptionSendMessageOnOpenConfigWindow() if config.ENABLE_TRANSCRIPTION_RECEIVE is True: stopThreadingTranscriptionReceiveMessageOnOpenConfigWindow() return {"status":"success"} -def callbackCloseConfigWindow() -> dict: +def callbackCloseConfigWindow(data, action, *args, **kwargs) -> dict: model.stopCheckMicEnergy() model.stopCheckSpeakerEnergy() if config.ENABLE_TRANSCRIPTION_SEND is True: - startThreadingTranscriptionSendMessageOnCloseConfigWindow() + startThreadingTranscriptionSendMessageOnCloseConfigWindow(action) if config.ENABLE_TRANSCRIPTION_RECEIVE is True: sleep(2) if config.ENABLE_TRANSCRIPTION_RECEIVE is True: - startThreadingTranscriptionReceiveMessageOnCloseConfigWindow() + startThreadingTranscriptionReceiveMessageOnCloseConfigWindow(action) return {"status":"success"} # Compact Mode Switch -def callbackEnableConfigWindowCompactMode() -> dict: +def callbackEnableConfigWindowCompactMode(*args, **kwargs) -> dict: config.IS_CONFIG_WINDOW_COMPACT_MODE = True model.stopCheckMicEnergy() model.stopCheckSpeakerEnergy() - return {"status":"success"} + return {"status":"success", "data":config.IS_CONFIG_WINDOW_COMPACT_MODE} -def callbackDisableConfigWindowCompactMode() -> dict: +def callbackDisableConfigWindowCompactMode(*args, **kwargs) -> dict: config.IS_CONFIG_WINDOW_COMPACT_MODE = False model.stopCheckMicEnergy() model.stopCheckSpeakerEnergy() - return {"status":"success"} + return {"status":"success", "data":config.IS_CONFIG_WINDOW_COMPACT_MODE} # Appearance Tab -def callbackSetTransparency(value) -> dict: - print("callbackSetTransparency", int(value)) - config.TRANSPARENCY = int(value) - return {"status":"success"} +def callbackSetTransparency(data, *args, **kwargs) -> dict: + print("callbackSetTransparency", int(data)) + config.TRANSPARENCY = int(data) + return {"status":"success", "data":config.TRANSPARENCY} -def callbackSetAppearance(value) -> dict: - print("callbackSetAppearance", value) - config.APPEARANCE_THEME = value - return {"status":"success"} +def callbackSetAppearance(data, *args, **kwargs) -> dict: + print("callbackSetAppearance", data) + config.APPEARANCE_THEME = data + return {"status":"success", "data":config.APPEARANCE_THEME} -def callbackSetUiScaling(value) -> dict: - print("callbackSetUiScaling", value) - config.UI_SCALING = value - return {"status":"success"} +def callbackSetUiScaling(data, *args, **kwargs) -> dict: + print("callbackSetUiScaling", data) + config.UI_SCALING = data + return {"status":"success", "data":config.UI_SCALING} -def callbackSetTextboxUiScaling(value) -> dict: - print("callbackSetTextboxUiScaling", int(value)) - config.TEXTBOX_UI_SCALING = int(value) - return {"status":"success"} +def callbackSetTextboxUiScaling(data, *args, **kwargs) -> dict: + print("callbackSetTextboxUiScaling", int(data)) + config.TEXTBOX_UI_SCALING = int(data) + return {"status":"success", "data":config.TEXTBOX_UI_SCALING} -def callbackSetMessageBoxRatio(value) -> dict: - print("callbackSetMessageBoxRatio", int(value)) - config.MESSAGE_BOX_RATIO = int(value) - return {"status":"success"} +def callbackSetMessageBoxRatio(data, *args, **kwargs) -> dict: + print("callbackSetMessageBoxRatio", int(data)) + config.MESSAGE_BOX_RATIO = int(data) + return {"status":"success", "data":config.MESSAGE_BOX_RATIO} -def callbackSetFontFamily(value) -> dict: - print("callbackSetFontFamily", value) - config.FONT_FAMILY = value - return {"status":"success"} +def callbackSetFontFamily(data, *args, **kwargs) -> dict: + print("callbackSetFontFamily", data) + config.FONT_FAMILY = data + return {"status":"success", "data":config.FONT_FAMILY} -def callbackSetUiLanguage(value) -> dict: - print("callbackSetUiLanguage", value) - value = getKeyByValue(config.SELECTABLE_UI_LANGUAGES_DICT, value) - print("callbackSetUiLanguage__after_getKeyByValue", value) - config.UI_LANGUAGE = value - return {"status":"success"} +def callbackSetUiLanguage(data, *args, **kwargs) -> dict: + print("callbackSetUiLanguage", data) + data = getKeyByValue(config.SELECTABLE_UI_LANGUAGES_DICT, data) + print("callbackSetUiLanguage__after_getKeyByValue", data) + config.UI_LANGUAGE = data + return {"status":"success", "data":config.UI_LANGUAGE} -def callbackSetEnableRestoreMainWindowGeometry(value) -> dict: - print("callbackSetEnableRestoreMainWindowGeometry", value) - config.ENABLE_RESTORE_MAIN_WINDOW_GEOMETRY = value - return {"status":"success"} +def callbackSetEnableRestoreMainWindowGeometry(data, *args, **kwargs) -> dict: + print("callbackSetEnableRestoreMainWindowGeometry", data) + config.ENABLE_RESTORE_MAIN_WINDOW_GEOMETRY = data + return {"status":"success", "data":config.ENABLE_RESTORE_MAIN_WINDOW_GEOMETRY} # Translation Tab -def callbackSetUseTranslationFeature(value) -> dict: - print("callbackSetUseTranslationFeature", value) - config.USE_TRANSLATION_FEATURE = value +def callbackSetUseTranslationFeature(data, *args, **kwargs) -> dict: + print("callbackSetUseTranslationFeature", data) + config.USE_TRANSLATION_FEATURE = data if config.USE_TRANSLATION_FEATURE is True: if model.checkCTranslatorCTranslate2ModelWeight(): config.IS_RESET_BUTTON_DISPLAYED_FOR_TRANSLATION = False @@ -551,11 +580,16 @@ def callbackSetUseTranslationFeature(value) -> dict: config.IS_RESET_BUTTON_DISPLAYED_FOR_TRANSLATION = True else: config.IS_RESET_BUTTON_DISPLAYED_FOR_TRANSLATION = False - return {"status":"success"} + return {"status":"success", + "data":{ + "feature":config.USE_TRANSLATION_FEATURE, + "reset":config.IS_RESET_BUTTON_DISPLAYED_FOR_TRANSLATION, + }, + } -def callbackSetCtranslate2WeightType(value) -> dict: - print("callbackSetCtranslate2WeightType", value) - config.CTRANSLATE2_WEIGHT_TYPE = str(value) +def callbackSetCtranslate2WeightType(data, *args, **kwargs) -> dict: + print("callbackSetCtranslate2WeightType", data) + config.CTRANSLATE2_WEIGHT_TYPE = str(data) if model.checkCTranslatorCTranslate2ModelWeight(): config.IS_RESET_BUTTON_DISPLAYED_FOR_TRANSLATION = False def callback(): @@ -565,15 +599,20 @@ def callbackSetCtranslate2WeightType(value) -> dict: th_callback.start() else: config.IS_RESET_BUTTON_DISPLAYED_FOR_TRANSLATION = True - return {"status":"success"} + return {"status":"success", + "data":{ + "feature":config.CTRANSLATE2_WEIGHT_TYPE, + "reset":config.IS_RESET_BUTTON_DISPLAYED_FOR_TRANSLATION, + }, + } -def callbackSetDeeplAuthKey(value) -> dict: +def callbackSetDeeplAuthKey(data, *args, **kwargs) -> dict: status = "error" - print("callbackSetDeeplAuthKey", str(value)) - if len(value) == 36 or len(value) == 39: - result = model.authenticationTranslatorDeepLAuthKey(auth_key=value) + print("callbackSetDeeplAuthKey", str(data)) + if len(data) == 36 or len(data) == 39: + result = model.authenticationTranslatorDeepLAuthKey(auth_key=data) if result is True: - key = value + key = data status = "success" else: key = None @@ -581,112 +620,121 @@ def callbackSetDeeplAuthKey(value) -> dict: auth_keys["DeepL_API"] = key config.AUTH_KEYS = auth_keys updateTranslationEngineAndEngineList() - return {"status":status} + return {"status":status, "data":config.AUTH_KEYS["DeepL_API"]} -def callbackClearDeeplAuthKey() -> dict: +def callbackClearDeeplAuthKey(*args, **kwargs) -> dict: auth_keys = config.AUTH_KEYS auth_keys["DeepL_API"] = None config.AUTH_KEYS = auth_keys updateTranslationEngineAndEngineList() - return {"status":"success"} + return {"status":"success", "data":config.AUTH_KEYS["DeepL_API"]} # Transcription Tab # Transcription (Mic) -def callbackSetMicHost(value) -> dict: - print("callbackSetMicHost", value) - config.CHOICE_MIC_HOST = value +def callbackSetMicHost(data, *args, **kwargs) -> dict: + print("callbackSetMicHost", data) + config.CHOICE_MIC_HOST = data config.CHOICE_MIC_DEVICE = model.getInputDefaultDevice() model.stopCheckMicEnergy() - return {"status":"success"} + return {"status":"success", + "data":{ + "host":config.CHOICE_MIC_HOST, + "device":config.CHOICE_MIC_DEVICE, + }, + } -def callbackSetMicDevice(value) -> dict: - print("callbackSetMicDevice", value) - config.CHOICE_MIC_DEVICE = value +def callbackSetMicDevice(data, *args, **kwargs) -> dict: + print("callbackSetMicDevice", data) + config.CHOICE_MIC_DEVICE = data model.stopCheckMicEnergy() - return {"status":"success"} + return {"status":"success", + "data":{ + "host":config.CHOICE_MIC_HOST, + }, + } -def callbackSetMicEnergyThreshold(value) -> dict: +def callbackSetMicEnergyThreshold(data, *args, **kwargs) -> dict: status = "error" - print("callbackSetMicEnergyThreshold", value) - value = int(value) - if 0 <= value <= config.MAX_MIC_ENERGY_THRESHOLD: - config.INPUT_MIC_ENERGY_THRESHOLD = value + print("callbackSetMicEnergyThreshold", data) + data = int(data) + if 0 <= data <= config.MAX_MIC_ENERGY_THRESHOLD: + config.INPUT_MIC_ENERGY_THRESHOLD = data status = "success" - return {"status": status} + return {"status": status, "data": config.INPUT_MIC_ENERGY_THRESHOLD} -def callbackSetMicDynamicEnergyThreshold(value) -> dict: - print("callbackSetMicDynamicEnergyThreshold", value) - config.INPUT_MIC_DYNAMIC_ENERGY_THRESHOLD = value - return {"status":"success"} +def callbackSetMicDynamicEnergyThreshold(data, *args, **kwargs) -> dict: + print("callbackSetMicDynamicEnergyThreshold", data) + config.INPUT_MIC_DYNAMIC_ENERGY_THRESHOLD = data + return {"status":"success", "data":config.INPUT_MIC_DYNAMIC_ENERGY_THRESHOLD} -class ProgressBarMicEnergy: +class ProgressBarEnergy: def __init__(self, action): self.action = action def set(self, energy) -> None: - self.action({"status":"success", "energy":energy}) + self.action("energy", {"status":"success", "energy":energy}) def callbackEnableCheckMicThreshold(data, action, *args, **kwargs) -> dict: print("callbackEnableCheckMicThreshold") - progressbar_mic_energy = ProgressBarMicEnergy(action) + progressbar_mic_energy = ProgressBarEnergy(action) model.startCheckMicEnergy(progressbar_mic_energy.set) return {"status":"success"} -def callbackDisableCheckMicThreshold() -> dict: +def callbackDisableCheckMicThreshold(*args, **kwargs) -> dict: print("callbackDisableCheckMicThreshold") model.stopCheckMicEnergy() return {"status":"success"} -def callbackSetMicRecordTimeout(value) -> dict: - print("callbackSetMicRecordTimeout", value) - response = {"status":"success"} - if value != "": - try: - value = int(value) - if 0 <= value <= config.INPUT_MIC_PHRASE_TIMEOUT: - config.INPUT_MIC_RECORD_TIMEOUT = value - else: - raise ValueError() - except Exception: - response = {"status":"error", "message":"Error Mic Record Timeout"} +def callbackSetMicRecordTimeout(data, *args, **kwargs) -> dict: + print("callbackSetMicRecordTimeout", 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":"error", "message":"Error Mic Record Timeout"} + else: + response = {"status":"success", "data":config.INPUT_MIC_RECORD_TIMEOUT} return response -def callbackSetMicPhraseTimeout(value) -> dict: - print("callbackSetMicPhraseTimeout", value) - response = {"status":"success"} - if value != "": - try: - value = int(value) - if value >= config.INPUT_MIC_RECORD_TIMEOUT: - config.INPUT_MIC_PHRASE_TIMEOUT = value - else: - raise ValueError() - except Exception: - response = {"status":"error", "message":"Error Mic Phrase Timeout"} +def callbackSetMicPhraseTimeout(data, *args, **kwargs) -> dict: + print("callbackSetMicPhraseTimeout", 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":"error", "message":"Error Mic Phrase Timeout"} + else: + response = {"status":"success", "data":config.INPUT_MIC_PHRASE_TIMEOUT} return response -def callbackSetMicMaxPhrases(value) -> dict: - print("callbackSetMicMaxPhrases", value) - response = {"status":"success"} - if value != "": - try: - value = int(value) - if 0 <= value: - config.INPUT_MIC_MAX_PHRASES = value - else: - raise ValueError() - except Exception: - response = {"status":"error", "message":"Error Mic Max Phrases"} +def callbackSetMicMaxPhrases(data, *args, **kwargs) -> dict: + print("callbackSetMicMaxPhrases", data) + try: + data = int(data) + if 0 <= data: + config.INPUT_MIC_MAX_PHRASES = data + else: + raise ValueError() + except Exception: + response = {"status":"error", "message":"Error Mic Max Phrases"} + else: + response = {"status":"success", "data":config.INPUT_MIC_MAX_PHRASES} return response -def callbackSetMicWordFilter(values) -> dict: - print("callbackSetMicWordFilter", values) - values = str(values) - values = [w.strip() for w in values.split(",") if len(w.strip()) > 0] +def callbackSetMicWordFilter(data, *args, **kwargs) -> dict: + print("callbackSetMicWordFilter", 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 values: + for value in data: if value in new_input_mic_word_filter_list: # If the value is already in the list, do nothing. pass @@ -697,123 +745,106 @@ def callbackSetMicWordFilter(values) -> dict: model.resetKeywordProcessor() model.addKeywords() - return {"status":"success"} + return {"status":"success", "data":config.INPUT_MIC_WORD_FILTER} -def callbackDeleteMicWordFilter(value) -> dict: - print("callbackDeleteMicWordFilter", value) +def callbackDeleteMicWordFilter(data, *args, **kwargs) -> dict: + print("callbackDeleteMicWordFilter", data) try: new_input_mic_word_filter_list = config.INPUT_MIC_WORD_FILTER - new_input_mic_word_filter_list.remove(str(value)) + 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: print("There was no the target word in config.INPUT_MIC_WORD_FILTER") - return {"status":"success"} + return {"status":"success", "data":config.INPUT_MIC_WORD_FILTER} # Transcription (Speaker) -def callbackSetSpeakerDevice(value) -> dict: - print("callbackSetSpeakerDevice", value) - config.CHOICE_SPEAKER_DEVICE = value +def callbackSetSpeakerDevice(data, *args, **kwargs) -> dict: + print("callbackSetSpeakerDevice", data) + config.CHOICE_SPEAKER_DEVICE = data + model.stopCheckSpeakerEnergy() + return {"status":"success", "data":config.CHOICE_SPEAKER_DEVICE} +def callbackSetSpeakerEnergyThreshold(data, *args, **kwargs) -> dict: + print("callbackSetSpeakerEnergyThreshold", data) + try: + data = int(data) + if 0 <= data <= config.MAX_SPEAKER_ENERGY_THRESHOLD: + # view.clearNotificationMessage() + config.INPUT_SPEAKER_ENERGY_THRESHOLD = data + # view.setGuiVariable_SpeakerEnergyThreshold(config.INPUT_SPEAKER_ENERGY_THRESHOLD) + else: + raise ValueError() + except Exception: + response = {"status":"error", "message":"Error Set Speaker Energy Threshold"} + else: + response = {"status":"success", "data":config.INPUT_SPEAKER_ENERGY_THRESHOLD} + return response + +def callbackSetSpeakerDynamicEnergyThreshold(data, *args, **kwargs) -> dict: + print("callbackSetSpeakerDynamicEnergyThreshold", data) + config.INPUT_SPEAKER_DYNAMIC_ENERGY_THRESHOLD = data + return {"status":"success", "data":config.INPUT_SPEAKER_DYNAMIC_ENERGY_THRESHOLD} + +def callbackEnableCheckSpeakerThreshold(data, action, *args, **kwargs) -> dict: + print("callbackEnableCheckSpeakerThreshold") + progressbar_speaker_energy = ProgressBarEnergy(action) + model.startCheckSpeakerEnergy(progressbar_speaker_energy.set) + return {"status":"success"} + +def callbackDisableCheckSpeakerThreshold(*args, **kwargs) -> dict: + print("callbackDisableCheckSpeakerThreshold") model.stopCheckSpeakerEnergy() return {"status":"success"} -def callbackSetSpeakerEnergyThreshold(value) -> dict: - print("callbackSetSpeakerEnergyThreshold", value) - response = {"status":"success"} - if value != "": - try: - value = int(value) - if 0 <= value and value <= config.MAX_SPEAKER_ENERGY_THRESHOLD: - view.clearNotificationMessage() - config.INPUT_SPEAKER_ENERGY_THRESHOLD = value - view.setGuiVariable_SpeakerEnergyThreshold(config.INPUT_SPEAKER_ENERGY_THRESHOLD) - else: - raise ValueError() - except Exception: - response = {"status":"error", "message":"Error Set Speaker Energy Threshold"} +def callbackSetSpeakerRecordTimeout(data, *args, **kwargs) -> dict: + print("callbackSetSpeakerRecordTimeout", 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":"error", "message":"Error Speaker Record Timeout"} + else: + response = {"status":"success", "data":config.INPUT_SPEAKER_RECORD_TIMEOUT} return response -def callbackSetSpeakerDynamicEnergyThreshold(value) -> dict: - print("callbackSetSpeakerDynamicEnergyThreshold", value) - config.INPUT_SPEAKER_DYNAMIC_ENERGY_THRESHOLD = value - if config.INPUT_SPEAKER_DYNAMIC_ENERGY_THRESHOLD is True: - view.closeSpeakerEnergyThresholdWidget() +def callbackSetSpeakerPhraseTimeout(data, *args, **kwargs) -> dict: + print("callbackSetSpeakerPhraseTimeout", 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":"error", "message":"Error Speaker Phrase Timeout"} else: - view.openSpeakerEnergyThresholdWidget() - return {"status":"success"} + response = {"status":"success", "data":config.INPUT_SPEAKER_PHRASE_TIMEOUT} + return response -def setProgressBarSpeakerEnergy(energy): - view.updateSetProgressBar_SpeakerEnergy(energy) - -def callbackCheckSpeakerThreshold(is_turned_on): - print("callbackCheckSpeakerThreshold", is_turned_on) - if is_turned_on is True: - view.replaceSpeakerThresholdCheckButton_Disabled() - model.startCheckSpeakerEnergy( - setProgressBarSpeakerEnergy, - view.initProgressBar_SpeakerEnergy, - view.showErrorMessage_CheckSpeakerThreshold_NoDevice - ) - - view.replaceSpeakerThresholdCheckButton_Active() +def callbackSetSpeakerMaxPhrases(data, *args, **kwargs) -> dict: + print("callbackSetSpeakerMaxPhrases", data) + try: + data = int(data) + if 0 <= data: + config.INPUT_SPEAKER_MAX_PHRASES = data + else: + raise ValueError() + except Exception: + response = {"status":"error", "message":"Error Speaker Max Phrases"} else: - view.replaceSpeakerThresholdCheckButton_Disabled() - model.stopCheckSpeakerEnergy() - view.replaceSpeakerThresholdCheckButton_Passive() - -def callbackSetSpeakerRecordTimeout(value): - print("callbackSetSpeakerRecordTimeout", value) - if value == "": - return - try: - value = int(value) - if 0 <= value and value <= config.INPUT_SPEAKER_PHRASE_TIMEOUT: - view.clearNotificationMessage() - config.INPUT_SPEAKER_RECORD_TIMEOUT = value - view.setGuiVariable_SpeakerRecordTimeout(config.INPUT_SPEAKER_RECORD_TIMEOUT) - else: - raise ValueError() - except Exception: - view.showErrorMessage_SpeakerRecordTimeout() - -def callbackSetSpeakerPhraseTimeout(value): - print("callbackSetSpeakerPhraseTimeout", value) - if value == "": - return - try: - value = int(value) - if 0 <= value and value >= config.INPUT_SPEAKER_RECORD_TIMEOUT: - view.clearNotificationMessage() - config.INPUT_SPEAKER_PHRASE_TIMEOUT = value - view.setGuiVariable_SpeakerPhraseTimeout(config.INPUT_SPEAKER_PHRASE_TIMEOUT) - else: - raise ValueError() - except Exception: - view.showErrorMessage_SpeakerPhraseTimeout() - -def callbackSetSpeakerMaxPhrases(value): - print("callbackSetSpeakerMaxPhrases", value) - if value == "": - return - try: - value = int(value) - if 0 <= value: - view.clearNotificationMessage() - config.INPUT_SPEAKER_MAX_PHRASES = value - view.setGuiVariable_SpeakerMaxPhrases(config.INPUT_SPEAKER_MAX_PHRASES) - else: - raise ValueError() - except Exception: - view.showErrorMessage_SpeakerMaxPhrases() + response = {"status":"success", "data":config.INPUT_SPEAKER_MAX_PHRASES} + return response # Transcription (Internal AI Model) -def callbackSetUserWhisperFeature(value): - print("callbackSetUserWhisperFeature", value) - config.USE_WHISPER_FEATURE = value +def callbackSetUserWhisperFeature(data, *args, **kwargs) -> dict: + print("callbackSetUserWhisperFeature", data) + config.USE_WHISPER_FEATURE = data if config.USE_WHISPER_FEATURE is True: - view.openWhisperWeightTypeWidget() if model.checkTranscriptionWhisperModelWeight() is True: config.IS_RESET_BUTTON_DISPLAYED_FOR_WHISPER = False config.SELECTED_TRANSCRIPTION_ENGINE = "Whisper" @@ -821,50 +852,66 @@ def callbackSetUserWhisperFeature(value): config.IS_RESET_BUTTON_DISPLAYED_FOR_WHISPER = True config.SELECTED_TRANSCRIPTION_ENGINE = "Google" else: - view.closeWhisperWeightTypeWidget() config.IS_RESET_BUTTON_DISPLAYED_FOR_WHISPER = False config.SELECTED_TRANSCRIPTION_ENGINE = "Google" - view.showRestartButtonIfRequired() + return {"status":"success", + "data":{ + "feature":config.USE_WHISPER_FEATURE, + "transcription_engine":config.SELECTED_TRANSCRIPTION_ENGINE, + "reset":config.IS_RESET_BUTTON_DISPLAYED_FOR_WHISPER, + }, + } -def callbackSetWhisperWeightType(value): - print("callbackSetWhisperWeightType", value) - config.WHISPER_WEIGHT_TYPE = str(value) - view.updateSelectedWhisperWeightType(config.WHISPER_WEIGHT_TYPE) +def callbackSetWhisperWeightType(data, *args, **kwargs) -> dict: + print("callbackSetWhisperWeightType", 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" - view.showRestartButtonIfRequired() + return {"status":"success", + "data":{ + "weight_type":config.WHISPER_WEIGHT_TYPE, + "transcription_engine":config.SELECTED_TRANSCRIPTION_ENGINE, + "reset":config.IS_RESET_BUTTON_DISPLAYED_FOR_WHISPER, + } + } # VR Tab -def callbackSetOverlaySettings(value, set_type:str): - print("callbackSetOverlaySettings", value, set_type) +def callbackSetOverlaySettingsOpacity(data, *args, **kwargs) -> dict: + print("callbackSetOverlaySettingsOpacity", data) pre_settings = config.OVERLAY_SETTINGS - pre_settings[set_type] = value + pre_settings["opacity"] = data config.OVERLAY_SETTINGS = pre_settings - match (set_type): - case "opacity": - model.updateOverlayImageOpacity() - case "ui_scaling": - model.updateOverlayImageUiScaling() + model.updateOverlayImageOpacity() + return {"status":"success", "data":config.OVERLAY_SETTINGS["opacity"]} -def callbackSetEnableOverlaySmallLog(value): - print("callbackSetEnableOverlaySmallLog", value) - config.ENABLE_OVERLAY_SMALL_LOG = value +def callbackSetOverlaySettingsUiScaling(data, *args, **kwargs) -> dict: + print("callbackSetOverlaySettingsUiScaling", data) + pre_settings = config.OVERLAY_SETTINGS + pre_settings["ui_scaling"] = data + config.OVERLAY_SETTINGS = pre_settings + model.updateOverlayImageUiScaling() + return {"status":"success", "data":config.OVERLAY_SETTINGS["ui_scaling"]} + +def callbackEnableOverlaySmallLog(data, *args, **kwargs) -> dict: + print("callbackEnableOverlaySmallLog", data) + config.ENABLE_OVERLAY_SMALL_LOG = data 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() - elif config.ENABLE_OVERLAY_SMALL_LOG is False: + return {"status":"success", "data":config.ENABLE_OVERLAY_SMALL_LOG} + +def callbackDisableOverlaySmallLog(data, *args, **kwargs) -> dict: + print("callbackDisableOverlaySmallLog", data) + config.ENABLE_OVERLAY_SMALL_LOG = data + if config.ENABLE_OVERLAY_SMALL_LOG is False: model.clearOverlayImage() model.shutdownOverlay() - - if config.ENABLE_OVERLAY_SMALL_LOG is True: - view.setStateOverlaySmallLog("enabled") - elif config.ENABLE_OVERLAY_SMALL_LOG is False: - view.setStateOverlaySmallLog("disabled") + return {"status":"success", "data":config.ENABLE_OVERLAY_SMALL_LOG} def callbackSetOverlaySmallLogSettings(value, set_type:str): print("callbackSetOverlaySmallLogSettings", value, set_type) @@ -877,112 +924,162 @@ def callbackSetOverlaySmallLogSettings(value, set_type:str): case "display_duration" | "fadeout_duration": model.updateOverlayTimes() +def callbackSetOverlaySmallLogSettingsXPos(data, *args, **kwargs) -> dict: + print("callbackSetOverlaySmallLogSettingsXPos", data) + pre_settings = config.OVERLAY_SMALL_LOG_SETTINGS + pre_settings["x_pos"] = data + config.OVERLAY_SMALL_LOG_SETTINGS = pre_settings + model.updateOverlayPosition() + return {"status":"success", "data":config.OVERLAY_SMALL_LOG_SETTINGS["x_pos"]} + +def callbackSetOverlaySmallLogSettingsYPos(data, *args, **kwargs) -> dict: + print("callbackSetOverlaySmallLogSettingsYPos", data) + pre_settings = config.OVERLAY_SMALL_LOG_SETTINGS + pre_settings["y_pos"] = data + config.OVERLAY_SMALL_LOG_SETTINGS = pre_settings + model.updateOverlayPosition() + return {"status":"success", "data":config.OVERLAY_SMALL_LOG_SETTINGS["y_pos"]} + +def callbackSetOverlaySmallLogSettingsZPos(data, *args, **kwargs) -> dict: + print("callbackSetOverlaySmallLogSettingsZPos", data) + pre_settings = config.OVERLAY_SMALL_LOG_SETTINGS + pre_settings["z_pos"] = data + config.OVERLAY_SMALL_LOG_SETTINGS = pre_settings + model.updateOverlayPosition() + return {"status":"success", "data":config.OVERLAY_SMALL_LOG_SETTINGS["z_pos"]} + +def callbackSetOverlaySmallLogSettingsXRotation(data, *args, **kwargs) -> dict: + print("callbackSetOverlaySmallLogSettingsXRotation", data) + pre_settings = config.OVERLAY_SMALL_LOG_SETTINGS + pre_settings["x_rotation"] = data + config.OVERLAY_SMALL_LOG_SETTINGS = pre_settings + model.updateOverlayPosition() + return {"status":"success", "data":config.OVERLAY_SMALL_LOG_SETTINGS["x_rotation"]} + +def callbackSetOverlaySmallLogSettingsYRotation(data, *args, **kwargs) -> dict: + print("callbackSetOverlaySmallLogSettingsYRotation", data) + pre_settings = config.OVERLAY_SMALL_LOG_SETTINGS + pre_settings["y_rotation"] = data + config.OVERLAY_SMALL_LOG_SETTINGS = pre_settings + model.updateOverlayPosition() + return {"status":"success", "data":config.OVERLAY_SMALL_LOG_SETTINGS["y_rotation"]} + +def callbackSetOverlaySmallLogSettingsZRotation(data, *args, **kwargs) -> dict: + print("callbackSetOverlaySmallLogSettingsZRotation", data) + pre_settings = config.OVERLAY_SMALL_LOG_SETTINGS + pre_settings["z_rotation"] = data + config.OVERLAY_SMALL_LOG_SETTINGS = pre_settings + model.updateOverlayPosition() + return {"status":"success", "data":config.OVERLAY_SMALL_LOG_SETTINGS["z_rotation"]} + # Others Tab -def callbackSetEnableAutoClearMessageBox(value): - print("callbackSetEnableAutoClearMessageBox", value) - config.ENABLE_AUTO_CLEAR_MESSAGE_BOX = value +def callbackSetEnableAutoClearMessageBox(data, *args, **kwargs) -> dict: + print("callbackSetEnableAutoClearMessageBox", data) + config.ENABLE_AUTO_CLEAR_MESSAGE_BOX = data + return {"status":"success", "data":config.ENABLE_AUTO_CLEAR_MESSAGE_BOX} -def callbackSetEnableSendOnlyTranslatedMessages(value): - print("callbackSetEnableSendOnlyTranslatedMessages", value) - config.ENABLE_SEND_ONLY_TRANSLATED_MESSAGES = value +def callbackSetEnableSendOnlyTranslatedMessages(data, *args, **kwargs) -> dict: + print("callbackSetEnableSendOnlyTranslatedMessages", data) + config.ENABLE_SEND_ONLY_TRANSLATED_MESSAGES = data + return {"status":"success", "data":config.ENABLE_SEND_ONLY_TRANSLATED_MESSAGES} -def callbackSetSendMessageButtonType(value): - print("callbackSetSendMessageButtonType", value) - config.SEND_MESSAGE_BUTTON_TYPE = value - view.changeMainWindowSendMessageButton(config.SEND_MESSAGE_BUTTON_TYPE) +def callbackSetSendMessageButtonType(data, *args, **kwargs) -> dict: + print("callbackSetSendMessageButtonType", data) + config.SEND_MESSAGE_BUTTON_TYPE = data + return {"status":"success", "data":config.SEND_MESSAGE_BUTTON_TYPE} -def callbackSetEnableNoticeXsoverlay(value): - print("callbackSetEnableNoticeXsoverlay", value) - config.ENABLE_NOTICE_XSOVERLAY = value +def callbackEnableNoticeXsoverlay(*args, **kwargs) -> dict: + print("callbackEnableNoticeXsoverlay") + config.ENABLE_NOTICE_XSOVERLAY = True + return {"status":"success", "data":config.ENABLE_NOTICE_XSOVERLAY} -def callbackSetEnableAutoExportMessageLogs(value): - print("callbackSetEnableAutoExportMessageLogs", value) - config.ENABLE_LOGGER = value +def callbackDisableNoticeXsoverlay(*args, **kwargs) -> dict: + print("callbackDisableNoticeXsoverlay") + config.ENABLE_NOTICE_XSOVERLAY = False + return {"status":"success", "data":config.ENABLE_NOTICE_XSOVERLAY} - if config.ENABLE_LOGGER is True: - model.startLogger() - else: - model.stopLogger() +def callbackEnableAutoExportMessageLogs(*args, **kwargs) -> dict: + print("callbackEnableAutoExportMessageLogs") + config.ENABLE_LOGGER = True + model.startLogger() -def callbackSetEnableVrcMicMuteSync(value): - print("callbackSetEnableVrcMicMuteSync", value) - config.ENABLE_VRC_MIC_MUTE_SYNC = value - if config.ENABLE_VRC_MIC_MUTE_SYNC is True: - model.startCheckMuteSelfStatus() - view.setStateVrcMicMuteSync("enabled") - else: - model.stopCheckMuteSelfStatus() - view.setStateVrcMicMuteSync("disabled") +def callbackDisableAutoExportMessageLogs(*args, **kwargs) -> dict: + print("callbackDisableAutoExportMessageLogs") + config.ENABLE_LOGGER = False + model.stopLogger() + +def callbackEnableVrcMicMuteSync(*args, **kwargs) -> dict: + print("callbackEnableVrcMicMuteSync") + config.ENABLE_VRC_MIC_MUTE_SYNC = True + model.startCheckMuteSelfStatus() model.changeMicTranscriptStatus() +def callbackDisableVrcMicMuteSync(*args, **kwargs) -> dict: + print("callbackDisableVrcMicMuteSync") + config.ENABLE_VRC_MIC_MUTE_SYNC = False + model.stopCheckMuteSelfStatus() + model.changeMicTranscriptStatus() -def callbackSetEnableSendMessageToVrc(value): - print("callbackSetEnableSendMessageToVrc", value) - config.ENABLE_SEND_MESSAGE_TO_VRC = value +def callbackEnableSendMessageToVrc(*args, **kwargs) -> dict: + print("callbackEnableSendMessageToVrc") + config.ENABLE_SEND_MESSAGE_TO_VRC = True + return {"status":"success", "data":config.ENABLE_SEND_MESSAGE_TO_VRC} + +def callbackDisableSendMessageToVrc(*args, **kwargs) -> dict: + print("callbackSetEnableSendMessageToVrc") + config.ENABLE_SEND_MESSAGE_TO_VRC = False + return {"status":"success", "data":config.ENABLE_SEND_MESSAGE_TO_VRC} # Others (Message Formats(Send) -def callbackSetSendMessageFormat(value): - print("callbackSetSendMessageFormat", value) - if isUniqueStrings(["[message]"], value) is True: - config.SEND_MESSAGE_FORMAT = value - view.clearNotificationMessage() - view.setSendMessageFormat_EntryWidgets(config.SEND_MESSAGE_FORMAT) - else: - view.showErrorMessage_SendMessageFormat() - view.setSendMessageFormat_EntryWidgets(config.SEND_MESSAGE_FORMAT) +def callbackSetSendMessageFormat(data, *args, **kwargs) -> dict: + print("callbackSetSendMessageFormat", data) + if isUniqueStrings(["[message]"], data) is True: + config.SEND_MESSAGE_FORMAT = data + return {"status":"success", "data":config.SEND_MESSAGE_FORMAT} -def callbackSetSendMessageFormatWithT(value): - print("callbackSetSendMessageFormatWithT", value) - if len(value) > 0: - if isUniqueStrings(["[message]", "[translation]"], value) is True: - config.SEND_MESSAGE_FORMAT_WITH_T = value - view.clearNotificationMessage() - view.setSendMessageFormatWithT_EntryWidgets(config.SEND_MESSAGE_FORMAT_WITH_T) - else: - view.showErrorMessage_SendMessageFormatWithT() - view.setSendMessageFormatWithT_EntryWidgets(config.SEND_MESSAGE_FORMAT_WITH_T) +def callbackSetSendMessageFormatWithT(data, *args, **kwargs) -> dict: + print("callbackSetSendMessageFormatWithT", data) + if len(data) > 0: + if isUniqueStrings(["[message]", "[translation]"], data) is True: + config.SEND_MESSAGE_FORMAT_WITH_T = data + return {"status":"success", "data":config.SEND_MESSAGE_FORMAT_WITH_T} # Others (Message Formats(Received) -def callbackSetReceivedMessageFormat(value): - print("callbackSetReceivedMessageFormat", value) - if isUniqueStrings(["[message]"], value) is True: - config.RECEIVED_MESSAGE_FORMAT = value - view.clearNotificationMessage() - view.setReceivedMessageFormat_EntryWidgets(config.RECEIVED_MESSAGE_FORMAT) - else: - view.showErrorMessage_ReceivedMessageFormat() - view.setReceivedMessageFormat_EntryWidgets(config.RECEIVED_MESSAGE_FORMAT) +def callbackSetReceivedMessageFormat(data, *args, **kwargs) -> dict: + print("callbackSetReceivedMessageFormat", data) + if isUniqueStrings(["[message]"], data) is True: + config.RECEIVED_MESSAGE_FORMAT = data + return {"status":"success", "data":config.RECEIVED_MESSAGE_FORMAT} -def callbackSetReceivedMessageFormatWithT(value): - print("callbackSetReceivedMessageFormatWithT", value) - if len(value) > 0: - if isUniqueStrings(["[message]", "[translation]"], value) is True: - config.RECEIVED_MESSAGE_FORMAT_WITH_T = value - view.clearNotificationMessage() - view.setReceivedMessageFormatWithT_EntryWidgets(config.RECEIVED_MESSAGE_FORMAT_WITH_T) - else: - view.showErrorMessage_ReceivedMessageFormatWithT() - view.setReceivedMessageFormatWithT_EntryWidgets(config.RECEIVED_MESSAGE_FORMAT_WITH_T) +def callbackSetReceivedMessageFormatWithT(data, *args, **kwargs) -> dict: + print("callbackSetReceivedMessageFormatWithT", data) + if len(data) > 0: + if isUniqueStrings(["[message]", "[translation]"], data) is True: + config.RECEIVED_MESSAGE_FORMAT_WITH_T = data + return {"status":"success", "data":config.RECEIVED_MESSAGE_FORMAT_WITH_T} # ---------------------Speaker2Chatbox--------------------- -def callbackSetEnableSendReceivedMessageToVrc(value): - print("callbackSetEnableSendReceivedMessageToVrc", value) - config.ENABLE_SEND_RECEIVED_MESSAGE_TO_VRC = value +def callbackEnableSendReceivedMessageToVrc(*args, **kwargs) -> dict: + print("callbackEnableSendReceivedMessageToVrc") + config.ENABLE_SEND_RECEIVED_MESSAGE_TO_VRC = True + return {"status":"success", "data":config.ENABLE_SEND_RECEIVED_MESSAGE_TO_VRC} + +def callbackDisableSendReceivedMessageToVrc(*args, **kwargs) -> dict: + print("callbackDisableSendReceivedMessageToVrc") + config.ENABLE_SEND_RECEIVED_MESSAGE_TO_VRC = False + return {"status":"success", "data":config.ENABLE_SEND_RECEIVED_MESSAGE_TO_VRC} # ---------------------Speaker2Chatbox--------------------- # Advanced Settings Tab -def callbackSetOscIpAddress(value): - if value == "": - return - print("callbackSetOscIpAddress", str(value)) - config.OSC_IP_ADDRESS = str(value) - -def callbackSetOscPort(value): - if value == "": - return - print("callbackSetOscPort", int(value)) - config.OSC_PORT = int(value) +def callbackSetOscIpAddress(data, *args, **kwargs) -> dict: + print("callbackSetOscIpAddress", str(data)) + config.OSC_IP_ADDRESS = str(data) + return {"status":"success", "data":config.OSC_IP_ADDRESS} +def callbackSetOscPort(data, *args, **kwargs) -> dict: + print("callbackSetOscPort", int(data)) + config.OSC_PORT = int(data) + return {"status":"success", "data":config.OSC_PORT} def getListLanguageAndCountry(): return model.getListLanguageAndCountry() @@ -996,27 +1093,7 @@ def getListInputDevice(): def getListOutputDevice(): return model.getListOutputDevice() - -def initSetConfigByExeArguments(): - parser = argparse.ArgumentParser() - parser.add_argument("--ip") - parser.add_argument("--port") - args = parser.parse_args() - if args.ip is not None: - config.OSC_IP_ADDRESS = str(args.ip) - view.setGuiVariable_OscIpAddress(config.OSC_IP_ADDRESS) - if args.port is not None: - config.OSC_PORT = int(args.port) - view.setGuiVariable_OscPort(config.OSC_PORT) - -def createMainWindow(splash): - splash.toProgress(1) - # create GUI - view.createGUI() - splash.toProgress(2) - - # init config - initSetConfigByExeArguments() +def init(): initSetTranslateEngine() initSetLanguageAndCountry() @@ -1026,7 +1103,6 @@ def createMainWindow(splash): auth_keys = config.AUTH_KEYS auth_keys["DeepL_API"] = None config.AUTH_KEYS = auth_keys - view.printToTextbox_AuthenticationError() # set Translation Engine updateTranslationEngineAndEngineList() @@ -1042,7 +1118,8 @@ def createMainWindow(splash): # check Software Updated if model.checkSoftwareUpdated() is True: - view.showUpdateAvailableButton() + # view.showUpdateAvailableButton() + pass # init logger if config.ENABLE_LOGGER is True: @@ -1053,128 +1130,185 @@ def createMainWindow(splash): if config.ENABLE_VRC_MIC_MUTE_SYNC is True: model.startCheckMuteSelfStatus() - splash.toProgress(3) # Last one. +# def initSetConfigByExeArguments(): +# parser = argparse.ArgumentParser() +# parser.add_argument("--ip") +# parser.add_argument("--port") +# args = parser.parse_args() +# if args.ip is not None: +# config.OSC_IP_ADDRESS = str(args.ip) +# # view.setGuiVariable_OscIpAddress(config.OSC_IP_ADDRESS) +# if args.port is not None: +# config.OSC_PORT = int(args.port) +# # view.setGuiVariable_OscPort(config.OSC_PORT) + +# def createMainWindow(splash): +# splash.toProgress(1) +# # create GUI +# # view.createGUI() +# splash.toProgress(2) + +# # init config +# initSetConfigByExeArguments() +# initSetTranslateEngine() +# initSetLanguageAndCountry() + +# if config.AUTH_KEYS["DeepL_API"] is not None: +# if model.authenticationTranslatorDeepLAuthKey(auth_key=config.AUTH_KEYS["DeepL_API"]) is False: +# # error update Auth key +# auth_keys = config.AUTH_KEYS +# auth_keys["DeepL_API"] = None +# config.AUTH_KEYS = auth_keys +# # view.printToTextbox_AuthenticationError() + +# # set Translation Engine +# updateTranslationEngineAndEngineList() + +# # set Transcription Engine +# if config.USE_WHISPER_FEATURE is True: +# config.SELECTED_TRANSCRIPTION_ENGINE = "Whisper" +# else: +# config.SELECTED_TRANSCRIPTION_ENGINE = "Google" + +# # set word filter +# model.addKeywords() + +# # check Software Updated +# if model.checkSoftwareUpdated() is True: +# # view.showUpdateAvailableButton() +# pass + +# # init logger +# if config.ENABLE_LOGGER is True: +# model.startLogger() + +# # init OSC receive +# model.startReceiveOSC() +# if config.ENABLE_VRC_MIC_MUTE_SYNC is True: +# model.startCheckMuteSelfStatus() + +# splash.toProgress(3) # Last one. # set UI and callback - view.register( - common_registers={ - "callback_enable_easter_egg": callbackEnableEasterEgg, + # view.register( + # common_registers={ + # "callback_enable_easter_egg": callbackEnableEasterEgg, - "callback_update_software": callbackUpdateSoftware, - "callback_restart_software": callbackRestartSoftware, - "callback_filepath_logs": callbackFilepathLogs, - "callback_filepath_config_file": callbackFilepathConfigFile, - "callback_quit_vrct": callbackQuitVrct, - }, + # "callback_update_software": callbackUpdateSoftware, + # "callback_restart_software": callbackRestartSoftware, + # "callback_filepath_logs": callbackFilepathLogs, + # "callback_filepath_config_file": callbackFilepathConfigFile, + # "callback_quit_vrct": callbackQuitVrct, + # }, - window_action_registers={ - "callback_open_config_window": callbackOpenConfigWindow, - "callback_close_config_window": callbackCloseConfigWindow, - }, + # window_action_registers={ + # "callback_open_config_window": callbackOpenConfigWindow, + # "callback_close_config_window": callbackCloseConfigWindow, + # }, - main_window_registers={ - "callback_enable_main_window_sidebar_compact_mode": callbackEnableMainWindowSidebarCompactMode, - "callback_disable_main_window_sidebar_compact_mode": callbackDisableMainWindowSidebarCompactMode, + # main_window_registers={ + # "callback_enable_main_window_sidebar_compact_mode": callbackEnableMainWindowSidebarCompactMode, + # "callback_disable_main_window_sidebar_compact_mode": callbackDisableMainWindowSidebarCompactMode, - "callback_toggle_translation": callbackToggleTranslation, - "callback_toggle_transcription_send": callbackToggleTranscriptionSend, - "callback_toggle_transcription_receive": callbackToggleTranscriptionReceive, - "callback_toggle_foreground": callbackToggleForeground, + # "callback_toggle_translation": callbackToggleTranslation, + # "callback_toggle_transcription_send": callbackToggleTranscriptionSend, + # "callback_toggle_transcription_receive": callbackToggleTranscriptionReceive, + # "callback_toggle_foreground": callbackToggleForeground, - "callback_your_language": setYourLanguageAndCountry, - "callback_target_language": setTargetLanguageAndCountry, - "values": model.getListLanguageAndCountry(), - "callback_swap_languages": swapYourLanguageAndTargetLanguage, + # "callback_your_language": setYourLanguageAndCountry, + # "callback_target_language": setTargetLanguageAndCountry, + # "values": model.getListLanguageAndCountry(), + # "callback_swap_languages": swapYourLanguageAndTargetLanguage, - "callback_selected_language_preset_tab": callbackSelectedLanguagePresetTab, + # "callback_selected_language_preset_tab": callbackSelectedLanguagePresetTab, - "callback_selected_translation_engine": callbackSelectedTranslationEngine, + # "callback_selected_translation_engine": callbackSelectedTranslationEngine, - "message_box_bind_Return": messageBoxPressKeyEnter, - "message_box_bind_Any_KeyPress": messageBoxPressKeyAny, - "message_box_bind_FocusIn": messageBoxFocusIn, - "message_box_bind_FocusOut": messageBoxFocusOut, - "message_box_bind_Up_KeyPress": messageBoxUpKeyPress, - "message_box_bind_Down_KeyPress": messageBoxDownKeyPress, - }, + # "message_box_bind_Return": messageBoxPressKeyEnter, + # "message_box_bind_Any_KeyPress": messageBoxPressKeyAny, + # "message_box_bind_FocusIn": messageBoxFocusIn, + # "message_box_bind_FocusOut": messageBoxFocusOut, + # "message_box_bind_Up_KeyPress": messageBoxUpKeyPress, + # "message_box_bind_Down_KeyPress": messageBoxDownKeyPress, + # }, - config_window_registers={ - # Compact Mode Switch - "callback_disable_config_window_compact_mode": callbackEnableConfigWindowCompactMode, - "callback_enable_config_window_compact_mode": callbackDisableConfigWindowCompactMode, + # config_window_registers={ + # # Compact Mode Switch + # "callback_disable_config_window_compact_mode": callbackEnableConfigWindowCompactMode, + # "callback_enable_config_window_compact_mode": callbackDisableConfigWindowCompactMode, - # Appearance Tab - "callback_set_transparency": callbackSetTransparency, - "callback_set_appearance": callbackSetAppearance, - "callback_set_ui_scaling": callbackSetUiScaling, - "callback_set_textbox_ui_scaling": callbackSetTextboxUiScaling, - "callback_set_message_box_ratio": callbackSetMessageBoxRatio, - "callback_set_font_family": callbackSetFontFamily, - "callback_set_ui_language": callbackSetUiLanguage, - "callback_set_enable_restore_main_window_geometry": callbackSetEnableRestoreMainWindowGeometry, + # # Appearance Tab + # "callback_set_transparency": callbackSetTransparency, + # "callback_set_appearance": callbackSetAppearance, + # "callback_set_ui_scaling": callbackSetUiScaling, + # "callback_set_textbox_ui_scaling": callbackSetTextboxUiScaling, + # "callback_set_message_box_ratio": callbackSetMessageBoxRatio, + # "callback_set_font_family": callbackSetFontFamily, + # "callback_set_ui_language": callbackSetUiLanguage, + # "callback_set_enable_restore_main_window_geometry": callbackSetEnableRestoreMainWindowGeometry, - # Translation Tab - "callback_set_use_translation_feature": callbackSetUseTranslationFeature, - "callback_set_ctranslate2_weight_type": callbackSetCtranslate2WeightType, - "callback_set_deepl_auth_key": callbackSetDeeplAuthKey, + # # Translation Tab + # "callback_set_use_translation_feature": callbackSetUseTranslationFeature, + # "callback_set_ctranslate2_weight_type": callbackSetCtranslate2WeightType, + # "callback_set_deepl_auth_key": callbackSetDeeplAuthKey, - # Transcription Tab (Mic) - "callback_set_mic_host": callbackSetMicHost, - "list_mic_host": model.getListInputHost(), - "callback_set_mic_device": callbackSetMicDevice, - "list_mic_device": model.getListInputDevice(), - "callback_set_mic_energy_threshold": callbackSetMicEnergyThreshold, - "callback_set_mic_dynamic_energy_threshold": callbackSetMicDynamicEnergyThreshold, - "callback_check_mic_threshold": callbackCheckMicThreshold, - "callback_set_mic_record_timeout": callbackSetMicRecordTimeout, - "callback_set_mic_phrase_timeout": callbackSetMicPhraseTimeout, - "callback_set_mic_max_phrases": callbackSetMicMaxPhrases, - "callback_set_mic_word_filter": callbackSetMicWordFilter, - "callback_delete_mic_word_filter": callbackDeleteMicWordFilter, + # # Transcription Tab (Mic) + # "callback_set_mic_host": callbackSetMicHost, + # "list_mic_host": model.getListInputHost(), + # "callback_set_mic_device": callbackSetMicDevice, + # "list_mic_device": model.getListInputDevice(), + # "callback_set_mic_energy_threshold": callbackSetMicEnergyThreshold, + # "callback_set_mic_dynamic_energy_threshold": callbackSetMicDynamicEnergyThreshold, + # "callback_check_mic_threshold": callbackCheckMicThreshold, + # "callback_set_mic_record_timeout": callbackSetMicRecordTimeout, + # "callback_set_mic_phrase_timeout": callbackSetMicPhraseTimeout, + # "callback_set_mic_max_phrases": callbackSetMicMaxPhrases, + # "callback_set_mic_word_filter": callbackSetMicWordFilter, + # "callback_delete_mic_word_filter": callbackDeleteMicWordFilter, - # Transcription Tab (Speaker) - "callback_set_speaker_device": callbackSetSpeakerDevice, - "list_speaker_device": model.getListOutputDevice(), - "callback_set_speaker_energy_threshold": callbackSetSpeakerEnergyThreshold, - "callback_set_speaker_dynamic_energy_threshold": callbackSetSpeakerDynamicEnergyThreshold, - "callback_check_speaker_threshold": callbackCheckSpeakerThreshold, - "callback_set_speaker_record_timeout": callbackSetSpeakerRecordTimeout, - "callback_set_speaker_phrase_timeout": callbackSetSpeakerPhraseTimeout, - "callback_set_speaker_max_phrases": callbackSetSpeakerMaxPhrases, + # # Transcription Tab (Speaker) + # "callback_set_speaker_device": callbackSetSpeakerDevice, + # "list_speaker_device": model.getListOutputDevice(), + # "callback_set_speaker_energy_threshold": callbackSetSpeakerEnergyThreshold, + # "callback_set_speaker_dynamic_energy_threshold": callbackSetSpeakerDynamicEnergyThreshold, + # "callback_check_speaker_threshold": callbackCheckSpeakerThreshold, + # "callback_set_speaker_record_timeout": callbackSetSpeakerRecordTimeout, + # "callback_set_speaker_phrase_timeout": callbackSetSpeakerPhraseTimeout, + # "callback_set_speaker_max_phrases": callbackSetSpeakerMaxPhrases, - # Transcription Tab (Internal AI Model) - "callback_set_use_whisper_feature": callbackSetUserWhisperFeature, - "callback_set_whisper_weight_type": callbackSetWhisperWeightType, + # # Transcription Tab (Internal AI Model) + # "callback_set_use_whisper_feature": callbackSetUserWhisperFeature, + # "callback_set_whisper_weight_type": callbackSetWhisperWeightType, - # VR Tab - "callback_set_overlay_settings": callbackSetOverlaySettings, - "callback_set_enable_overlay_small_log": callbackSetEnableOverlaySmallLog, - "callback_set_overlay_small_log_settings": callbackSetOverlaySmallLogSettings, + # # VR Tab + # "callback_set_overlay_settings": callbackSetOverlaySettings, + # "callback_set_enable_overlay_small_log": callbackSetEnableOverlaySmallLog, + # "callback_set_overlay_small_log_settings": callbackSetOverlaySmallLogSettings, - # Others Tab - "callback_set_enable_auto_clear_chatbox": callbackSetEnableAutoClearMessageBox, - "callback_set_send_only_translated_messages": callbackSetEnableSendOnlyTranslatedMessages, - "callback_set_send_message_button_type": callbackSetSendMessageButtonType, - "callback_set_enable_notice_xsoverlay": callbackSetEnableNoticeXsoverlay, - "callback_set_enable_auto_export_message_logs": callbackSetEnableAutoExportMessageLogs, - "callback_set_enable_vrc_mic_mute_sync": callbackSetEnableVrcMicMuteSync, - "callback_set_enable_send_message_to_vrc": callbackSetEnableSendMessageToVrc, - # Others(Message Formats(Send) - "callback_set_send_message_format": callbackSetSendMessageFormat, - "callback_set_send_message_format_with_t": callbackSetSendMessageFormatWithT, - # Others(Message Formats(Received) - "callback_set_received_message_format": callbackSetReceivedMessageFormat, - "callback_set_received_message_format_with_t": callbackSetReceivedMessageFormatWithT, + # # Others Tab + # "callback_set_enable_auto_clear_chatbox": callbackSetEnableAutoClearMessageBox, + # "callback_set_send_only_translated_messages": callbackSetEnableSendOnlyTranslatedMessages, + # "callback_set_send_message_button_type": callbackSetSendMessageButtonType, + # "callback_set_enable_notice_xsoverlay": callbackSetEnableNoticeXsoverlay, + # "callback_set_enable_auto_export_message_logs": callbackSetEnableAutoExportMessageLogs, + # "callback_set_enable_vrc_mic_mute_sync": callbackSetEnableVrcMicMuteSync, + # "callback_set_enable_send_message_to_vrc": callbackSetEnableSendMessageToVrc, + # # Others(Message Formats(Send) + # "callback_set_send_message_format": callbackSetSendMessageFormat, + # "callback_set_send_message_format_with_t": callbackSetSendMessageFormatWithT, + # # Others(Message Formats(Received) + # "callback_set_received_message_format": callbackSetReceivedMessageFormat, + # "callback_set_received_message_format_with_t": callbackSetReceivedMessageFormatWithT, - # Speaker2Chatbox---------------- - "callback_set_enable_send_received_message_to_vrc": callbackSetEnableSendReceivedMessageToVrc, - # Speaker2Chatbox---------------- + # # Speaker2Chatbox---------------- + # "callback_set_enable_send_received_message_to_vrc": callbackSetEnableSendReceivedMessageToVrc, + # # Speaker2Chatbox---------------- - # Advanced Settings Tab - "callback_set_osc_ip_address": callbackSetOscIpAddress, - "callback_set_osc_port": callbackSetOscPort, - }, - ) + # # Advanced Settings Tab + # "callback_set_osc_ip_address": callbackSetOscIpAddress, + # "callback_set_osc_port": callbackSetOscPort, + # }, + # ) -def showMainWindow(): - view.startMainLoop() \ No newline at end of file +# def showMainWindow(): +# view.startMainLoop() \ No newline at end of file diff --git a/src-python/webui_mainloop.py b/src-python/webui_mainloop.py index 315cee44..5556c771 100644 --- a/src-python/webui_mainloop.py +++ b/src-python/webui_mainloop.py @@ -143,41 +143,54 @@ controller_mapping = { "/controller/callback_set_mic_max_phrases": controller.callbackSetMicMaxPhrases, "/controller/callback_set_mic_word_filter": controller.callbackSetMicWordFilter, "/controller/callback_delete_mic_word_filter": controller.callbackDeleteMicWordFilter, - "/controller/callback_set_speaker_device": controller.callbackSetSpeakerDevice, "/controller/callback_set_speaker_energy_threshold": controller.callbackSetSpeakerEnergyThreshold, "/controller/callback_set_speaker_dynamic_energy_threshold": controller.callbackSetSpeakerDynamicEnergyThreshold, - "/controller/callback_check_speaker_threshold": controller.callbackCheckSpeakerThreshold, + "/controller/callback_enable_check_speaker_threshold": controller.callbackEnableCheckSpeakerThreshold, + "/controller/callback_disable_check_speaker_threshold": controller.callbackDisableCheckSpeakerThreshold, "/controller/callback_set_speaker_record_timeout": controller.callbackSetSpeakerRecordTimeout, "/controller/callback_set_speaker_phrase_timeout": controller.callbackSetSpeakerPhraseTimeout, "/controller/callback_set_speaker_max_phrases": controller.callbackSetSpeakerMaxPhrases, "/controller/callback_set_use_whisper_feature": controller.callbackSetUserWhisperFeature, "/controller/callback_set_whisper_weight_type": controller.callbackSetWhisperWeightType, - "/controller/callback_set_overlay_settings": controller.callbackSetOverlaySettings, - "/controller/callback_set_enable_overlay_small_log": controller.callbackSetEnableOverlaySmallLog, - "/controller/callback_set_overlay_small_log_settings": controller.callbackSetOverlaySmallLogSettings, + "/controller/callback_set_overlay_settings_opacity": controller.callbackSetOverlaySettingsOpacity, + "/controller/callback_set_overlay_settings_ui_scaling": controller.callbackSetOverlaySettingsUiScaling, + "/controller/callback_enable_overlay_small_log": controller.callbackEnableOverlaySmallLog, + "/controller/callback_disable_overlay_small_log": controller.callbackDisableOverlaySmallLog, + "/controller/callback_set_overlay_small_log_settings_x_pos": controller.callbackSetOverlaySmallLogSettingsXPos, + "/controller/callback_set_overlay_small_log_settings_y_pos": controller.callbackSetOverlaySmallLogSettingsYPos, + "/controller/callback_set_overlay_small_log_settings_z_pos": controller.callbackSetOverlaySmallLogSettingsZPos, + "/controller/callback_set_overlay_small_log_settings_x_rotation": controller.callbackSetOverlaySmallLogSettingsXRotation, + "/controller/callback_set_overlay_small_log_settings_y_rotation": controller.callbackSetOverlaySmallLogSettingsYRotation, + "/controller/callback_set_overlay_small_log_settings_z_rotation": controller.callbackSetOverlaySmallLogSettingsZRotation, "/controller/callback_set_enable_auto_clear_chatbox": controller.callbackSetEnableAutoClearMessageBox, "/controller/callback_set_send_only_translated_messages": controller.callbackSetEnableSendOnlyTranslatedMessages, "/controller/callback_set_send_message_button_type": controller.callbackSetSendMessageButtonType, - "/controller/callback_set_enable_notice_xsoverlay": controller.callbackSetEnableNoticeXsoverlay, - "/controller/callback_set_enable_auto_export_message_logs": controller.callbackSetEnableAutoExportMessageLogs, - "/controller/callback_set_enable_vrc_mic_mute_sync": controller.callbackSetEnableVrcMicMuteSync, - "/controller/callback_set_enable_send_message_to_vrc": controller.callbackSetEnableSendMessageToVrc, + "/controller/callback_enable_notice_xsoverlay": controller.callbackEnableNoticeXsoverlay, + "/controller/callback_disable_notice_xsoverlay": controller.callbackDisableNoticeXsoverlay, + "/controller/callback_enable_auto_export_message_logs": controller.callbackEnableAutoExportMessageLogs, + "/controller/callback_disable_auto_export_message_logs": controller.callbackDisableAutoExportMessageLogs, + "/controller/callback_enable_vrc_mic_mute_sync": controller.callbackEnableVrcMicMuteSync, + "/controller/callback_disable_vrc_mic_mute_sync": controller.callbackDisableVrcMicMuteSync, + "/controller/callback_enable_send_message_to_vrc": controller.callbackEnableSendMessageToVrc, + "/controller/callback_disable_send_message_to_vrc": controller.callbackDisableSendMessageToVrc, "/controller/callback_set_send_message_format": controller.callbackSetSendMessageFormat, "/controller/callback_set_send_message_format_with_t": controller.callbackSetSendMessageFormatWithT, "/controller/callback_set_received_message_format": controller.callbackSetReceivedMessageFormat, "/controller/callback_set_received_message_format_with_t": controller.callbackSetReceivedMessageFormatWithT, - "/controller/callback_set_enable_send_received_message_to_vrc": controller.callbackSetEnableSendReceivedMessageToVrc, + "/controller/callback_enable_send_received_message_to_vrc": controller.callbackEnableSendReceivedMessageToVrc, + "/controller/callback_disable_send_received_message_to_vrc": controller.callbackDisableSendReceivedMessageToVrc, "/controller/callback_set_osc_ip_address": controller.callbackSetOscIpAddress, "/controller/callback_set_osc_port": controller.callbackSetOscPort, } action_mapping = { - "/controller/callback_enable_transcription_send": "/action/transcription_send_message", - "/controller/callback_disable_transcription_send": "/action/transcription_send_stopped", - "/controller/callback_enable_transcription_receive": "/action/transcription_receive_message", - "/controller/callback_disable_transcription_receive": "/action/transcription_receive_stopped", - "/controller/callback_enable_check_mic_threshold": "/action/check_mic_threshold_energy", + "/controller/callback_close_config_window": {"mic":"/action/transcription_send_message", "speaker":"/action/transcription_receive_message"}, + "/controller/callback_enable_transcription_send": {"mic":"/action/transcription_send_message"}, + "/controller/callback_disable_transcription_send": {"mic":"/action/transcription_send_stopped"}, + "/controller/callback_enable_transcription_receive": {"speaker":"/action/transcription_receive_message"}, + "/controller/callback_disable_transcription_receive": {"speaker":"/action/transcription_receive_stopped"}, + "/controller/callback_enable_check_mic_threshold": {"mic":"/action/check_mic_threshold_energy"}, } def handleConfigRequest(endpoint): @@ -205,12 +218,12 @@ def handleControllerRequest(endpoint, data=None): return response, status class Action: - def __init__(self, endpoint:str) -> None: - self.endpoint = endpoint + def __init__(self, endpoints:dict) -> None: + self.endpoints = endpoints - def transmit(self, data:dict) -> None: + def transmit(self, key:str, data:dict) -> None: response = { - "endpoint": self.endpoint, + "endpoint": self.endpoints[key], "status": 200, "data": data, } @@ -221,37 +234,49 @@ def main(): received_data = sys.stdin.readline().strip() received_data = json.loads(received_data) - if received_data is True: - response_data = { - "status": "ok", - "id": received_data["id"], - "data": received_data["data"], - } - response = json.dumps(response_data) - time.sleep(2) - print(response, flush=True) + with open('process.log', 'a') as f: + f.write(f"received_data: {received_data}\n") - # endpoint = received_data.get("endpoint", None) - # data = received_data.get("data", None) - - # match endpoint.split("/")[1]: - # case "config": - # response_data, status = handleConfigRequest(endpoint, data) - # case "controller": - # response_data, status = handleControllerRequest(endpoint, data) - # case _: - # pass - - # response = { - # "status": status, - # "endpoint": endpoint, - # "data": response_data, + if received_data: + # response_data = { + # "status": 200, + # "id": received_data["id"], + # "data": received_data["data"], # } - - # response = json.dumps(response) + # response = json.dumps(response_data) # time.sleep(2) # print(response, flush=True) + endpoint = received_data.get("endpoint", None) + data = received_data.get("data", None) + + with open('process.log', 'a') as f: + f.write(f"received_data : endpoint: {endpoint}, data:{data}\n") + + try: + match endpoint.split("/")[1]: + case "config": + result_data, status = handleConfigRequest(endpoint, data) + case "controller": + result_data, status = handleControllerRequest(endpoint, data) + case _: + pass + except Exception as e: + result_data = str(e) + status = 500 + + response = { + "status": status, + "endpoint": endpoint, + "result": result_data, + } + + response = json.dumps(response) + with open('process.log', 'a') as f: + f.write(f"response: {response}\n") + + print(response, flush=True) + if __name__ == "__main__": # endpoint = "/controller/list_mic_host" # data = None @@ -265,6 +290,7 @@ if __name__ == "__main__": # print(response, flush=True) try: + controller.init() print(json.dumps({"init_key_from_py": "Initialization from Python."}), flush=True) while True: main()