Merge branch 'donwload_ai_models' into for_webui

src-python/config.py

@@ -98,14 +98,6 @@ class Config:
     def MESSAGE_BOX_RATIO_RANGE(self):
         return self._MESSAGE_BOX_RATIO_RANGE
 
-    @property
-    def SELECTABLE_CTRANSLATE2_WEIGHT_TYPE_LIST(self):
-        return self._SELECTABLE_CTRANSLATE2_WEIGHT_TYPE_LIST
-
-    @property
-    def SELECTABLE_WHISPER_WEIGHT_TYPE_LIST(self):
-        return self._SELECTABLE_WHISPER_WEIGHT_TYPE_LIST
-
     @property
     def MAX_MIC_THRESHOLD(self):
         return self._MAX_MIC_THRESHOLD
@@ -177,50 +169,23 @@ class Config:
         if isinstance(value, bool):
             self._ENABLE_CHECK_ENERGY_RECEIVE = value
 
-    # @property
+    @property
-    # def SENT_MESSAGES_LOG(self):
+    def SELECTABLE_CTRANSLATE2_WEIGHT_TYPE_DICT(self):
-    #     return self._SENT_MESSAGES_LOG
+        return self._SELECTABLE_CTRANSLATE2_WEIGHT_TYPE_DICT
 
-    # @SENT_MESSAGES_LOG.setter
+    @SELECTABLE_CTRANSLATE2_WEIGHT_TYPE_DICT.setter
-    # def SENT_MESSAGES_LOG(self, value):
+    def SELECTABLE_CTRANSLATE2_WEIGHT_TYPE_DICT(self, value):
-    #     if isinstance(value, list):
+        if isinstance(value, dict):
-    #         self._SENT_MESSAGES_LOG = value
+            self._SELECTABLE_CTRANSLATE2_WEIGHT_TYPE_DICT = value
-
-    # @property
-    # def CURRENT_SENT_MESSAGES_LOG_INDEX(self):
-    #     return self._CURRENT_SENT_MESSAGES_LOG_INDEX
-
-    # @CURRENT_SENT_MESSAGES_LOG_INDEX.setter
-    # def CURRENT_SENT_MESSAGES_LOG_INDEX(self, value):
-    #     if isinstance(value, int):
-    #         self._CURRENT_SENT_MESSAGES_LOG_INDEX = value
 
     @property
-    def IS_RESET_BUTTON_DISPLAYED_FOR_TRANSLATION(self):
+    def SELECTABLE_WHISPER_WEIGHT_TYPE_DICT(self):
-        return self._IS_RESET_BUTTON_DISPLAYED_FOR_TRANSLATION
+        return self._SELECTABLE_WHISPER_WEIGHT_TYPE_DICT
 
-    @IS_RESET_BUTTON_DISPLAYED_FOR_TRANSLATION.setter
+    @SELECTABLE_WHISPER_WEIGHT_TYPE_DICT.setter
-    def IS_RESET_BUTTON_DISPLAYED_FOR_TRANSLATION(self, value):
+    def SELECTABLE_WHISPER_WEIGHT_TYPE_DICT(self, value):
-        if isinstance(value, bool):
+        if isinstance(value, dict):
-            self._IS_RESET_BUTTON_DISPLAYED_FOR_TRANSLATION = value
+            self._SELECTABLE_WHISPER_WEIGHT_TYPE_DICT = value
-
-    @property
-    def IS_RESET_BUTTON_DISPLAYED_FOR_WHISPER(self):
-        return self._IS_RESET_BUTTON_DISPLAYED_FOR_WHISPER
-
-    @IS_RESET_BUTTON_DISPLAYED_FOR_WHISPER.setter
-    def IS_RESET_BUTTON_DISPLAYED_FOR_WHISPER(self, value):
-        if isinstance(value, bool):
-            self._IS_RESET_BUTTON_DISPLAYED_FOR_WHISPER = value
-
-    # @property
-    # def IS_EASTER_EGG_ENABLED(self):
-    #     return self._IS_EASTER_EGG_ENABLED
-
-    # @IS_EASTER_EGG_ENABLED.setter
-    # def IS_EASTER_EGG_ENABLED(self, value):
-    #     if isinstance(value, bool):
-    #         self._IS_EASTER_EGG_ENABLED = value
 
     # Save Json Data
     ## Main Window
@@ -297,7 +262,7 @@ class Config:
     def SELECTED_TRANSCRIPTION_ENGINE(self, value):
         if isinstance(value, str):
             self._SELECTED_TRANSCRIPTION_ENGINE = value
-            # self.saveConfig(inspect.currentframe().f_code.co_name, value)
+            self.saveConfig(inspect.currentframe().f_code.co_name, value)
 
     @property
     @json_serializable('MULTI_LANGUAGE_TRANSLATION')
@@ -711,28 +676,6 @@ class Config:
             self._USE_EXCLUDE_WORDS = value
             self.saveConfig(inspect.currentframe().f_code.co_name, value)
 
-    @property
-    @json_serializable('USE_TRANSLATION_FEATURE')
-    def USE_TRANSLATION_FEATURE(self):
-        return self._USE_TRANSLATION_FEATURE
-
-    @USE_TRANSLATION_FEATURE.setter
-    def USE_TRANSLATION_FEATURE(self, value):
-        if isinstance(value, bool):
-            self._USE_TRANSLATION_FEATURE = value
-            self.saveConfig(inspect.currentframe().f_code.co_name, value)
-
-    @property
-    @json_serializable('USE_WHISPER_FEATURE')
-    def USE_WHISPER_FEATURE(self):
-        return self._USE_WHISPER_FEATURE
-
-    @USE_WHISPER_FEATURE.setter
-    def USE_WHISPER_FEATURE(self, value):
-        if isinstance(value, bool):
-            self._USE_WHISPER_FEATURE = value
-            self.saveConfig(inspect.currentframe().f_code.co_name, value)
-
     @property
     @json_serializable('SELECTED_TRANSLATION_COMPUTE_DEVICE')
     def SELECTED_TRANSLATION_COMPUTE_DEVICE(self):
@@ -762,7 +705,6 @@ class Config:
 
     @CTRANSLATE2_WEIGHT_TYPE.setter
     def CTRANSLATE2_WEIGHT_TYPE(self, value):
-        # if isinstance(value, str) and value in self.SELECTABLE_CTRANSLATE2_WEIGHT_TYPE_LIST:
         if isinstance(value, str):
             self._CTRANSLATE2_WEIGHT_TYPE = value
             self.saveConfig(inspect.currentframe().f_code.co_name, value)
@@ -980,20 +922,20 @@ class Config:
         self._UI_SCALING_RANGE = (40, 200)
         self._TEXTBOX_UI_SCALING_RANGE = (40, 200)
         self._MESSAGE_BOX_RATIO_RANGE = (1, 99)
-        self._SELECTABLE_CTRANSLATE2_WEIGHT_TYPE_LIST = [
+        self._SELECTABLE_CTRANSLATE2_WEIGHT_TYPE_DICT = {
-            "Small",
+            "small": False,
-            "Large",
+            "large": False,
-        ]
+        }
 
-        self._SELECTABLE_WHISPER_WEIGHT_TYPE_LIST = [
+        self._SELECTABLE_WHISPER_WEIGHT_TYPE_DICT = {
-            "tiny",
+            "tiny": False,
-            "base",
+            "base": False,
-            "small",
+            "small": False,
-            "medium",
+            "medium": False,
-            "large-v1",
+            "large-v1": False,
-            "large-v2",
+            "large-v2": False,
-            "large-v3",
+            "large-v3": False,
-        ]
+        }
 
         self._MAX_MIC_THRESHOLD = 2000
         self._MAX_SPEAKER_THRESHOLD = 4000
@@ -1008,12 +950,6 @@ class Config:
         self._ENABLE_CHECK_ENERGY_SEND = False
         self._ENABLE_CHECK_ENERGY_RECEIVE = False
 
-        # self._SENT_MESSAGES_LOG = []
-        # self._CURRENT_SENT_MESSAGES_LOG_INDEX = 0
-        self._IS_RESET_BUTTON_DISPLAYED_FOR_TRANSLATION = False
-        self._IS_RESET_BUTTON_DISPLAYED_FOR_WHISPER = False
-        # self._IS_EASTER_EGG_ENABLED = False
-
         # Save Json Data
         ## Main Window
         self._SELECTED_TAB_NO = "1"
@@ -1086,7 +1022,7 @@ class Config:
                 },
             },
         }
-        self._SELECTED_TRANSCRIPTION_ENGINE = "Google"
+        self._SELECTED_TRANSCRIPTION_ENGINE = "Whisper"
         self._MULTI_LANGUAGE_TRANSLATION = False
         self._CONVERT_MESSAGE_TO_ROMAJI = False
         self._CONVERT_MESSAGE_TO_HIRAGANA = False
@@ -1133,11 +1069,9 @@ class Config:
             "DeepL_API": None,
         }
         self._USE_EXCLUDE_WORDS = True
-        self._USE_TRANSLATION_FEATURE = True
-        self._USE_WHISPER_FEATURE = False
         self._SELECTED_TRANSLATION_COMPUTE_DEVICE = {"device": "cpu", "device_index": 0, "device_name":"cpu"}
         self._SELECTED_TRANSCRIPTION_COMPUTE_DEVICE = {"device": "cpu", "device_index": 0, "device_name":"cpu"}
-        self._CTRANSLATE2_WEIGHT_TYPE = "Small"
+        self._CTRANSLATE2_WEIGHT_TYPE = "small"
         self._WHISPER_WEIGHT_TYPE = "base"
         self._SEND_MESSAGE_FORMAT = "[message]"
         self._SEND_MESSAGE_FORMAT_WITH_T = "[message]([translation])"

src-python/main.py

@@ -1,33 +0,0 @@
-if __name__ == "__main__":
-    try:
-        import ctypes
-        ctypes.windll.shcore.SetProcessDpiAwareness(0)
-
-        from vrct_gui.splash_window import SplashWindow
-        splash = SplashWindow()
-        splash.showSplash()
-
-        from config import config
-        # version 2.2.0からweightフォルダをweightsに変更する
-        from utils import renameWeightFolder
-        renameWeightFolder(config.PATH_LOCAL)
-
-        from models.translation.translation_utils import downloadCTranslate2Weight
-        if config.USE_TRANSLATION_FEATURE is True:
-            downloadCTranslate2Weight(config.PATH_LOCAL, config.CTRANSLATE2_WEIGHT_TYPE, splash.updateDownloadProgress)
-
-        from models.transcription.transcription_whisper import downloadWhisperWeight
-        if config.USE_WHISPER_FEATURE is True:
-            downloadWhisperWeight(config.PATH_LOCAL, config.WHISPER_WEIGHT_TYPE, splash.updateDownloadProgress)
-
-        splash.toProgress(0)
-
-        import controller
-        controller.createMainWindow(splash)
-        splash.destroySplash()
-        controller.showMainWindow()
-
-    except Exception:
-        import traceback
-        with open('error.log', 'a') as f:
-            traceback.print_exc(file=f)

src-python/model.py

@@ -101,8 +101,8 @@ class Model:
         self.kks = kakasi()
         self.watchdog = Watchdog(config.WATCHDOG_TIMEOUT, config.WATCHDOG_INTERVAL)
 
-    def checkCTranslatorCTranslate2ModelWeight(self):
+    def checkTranslatorCTranslate2ModelWeight(self, weight_type:str):
-        return checkCTranslate2Weight(config.PATH_LOCAL, config.CTRANSLATE2_WEIGHT_TYPE)
+        return checkCTranslate2Weight(config.PATH_LOCAL, weight_type)
 
     def changeTranslatorCTranslate2Model(self):
         self.translator.changeCTranslate2Model(
@@ -111,17 +111,17 @@ class Model:
             config.SELECTED_TRANSLATION_COMPUTE_DEVICE["device"],
             config.SELECTED_TRANSLATION_COMPUTE_DEVICE["device_index"])
 
-    def downloadCTranslate2ModelWeight(self, callbackFunc=None):
+    def downloadCTranslate2ModelWeight(self, weight_type, callback=None, end_callback=None):
-        return downloadCTranslate2Weight(config.PATH_LOCAL, config.CTRANSLATE2_WEIGHT_TYPE, callbackFunc)
+        return downloadCTranslate2Weight(config.PATH_LOCAL, weight_type, callback, end_callback)
 
     def isLoadedCTranslate2Model(self):
         return self.translator.isLoadedCTranslate2Model()
 
-    def checkTranscriptionWhisperModelWeight(self):
+    def checkTranscriptionWhisperModelWeight(self, weight_type:str):
-        return checkWhisperWeight(config.PATH_LOCAL, config.WHISPER_WEIGHT_TYPE)
+        return checkWhisperWeight(config.PATH_LOCAL, weight_type)
 
-    def downloadWhisperModelWeight(self, callbackFunc=None):
+    def downloadWhisperModelWeight(self, weight_type, callback=None, end_callback=None):
-        return downloadWhisperWeight(config.PATH_LOCAL, config.WHISPER_WEIGHT_TYPE, callbackFunc)
+        return downloadWhisperWeight(config.PATH_LOCAL, weight_type, callback, end_callback)
 
     def resetKeywordProcessor(self):
         del self.keyword_processor
@@ -252,7 +252,7 @@ class Model:
             target_country,
             message
             )
-        return [translation], success_flag
+        return [translation], [success_flag]
 
     def addKeywords(self):
         for f in config.MIC_WORD_FILTER:

src-python/models/transcription/transcription_whisper.py

@@ -63,17 +63,16 @@ def checkWhisperWeight(root, weight_type):
         pass
     return result
 
-def downloadWhisperWeight(root, weight_type, callbackFunc):
+def downloadWhisperWeight(root, weight_type, callback=None, end_callback=None):
     path = os_path.join(root, "weights", "whisper", weight_type)
     os_makedirs(path, exist_ok=True)
-    if checkWhisperWeight(root, weight_type) is True:
+    if checkWhisperWeight(root, weight_type) is False:
-        callbackFunc(1)
+        for filename in _FILENAMES:
-        return
+            file_path = os_path.join(path, filename)
-
+            url = huggingface_hub.hf_hub_url(_MODELS[weight_type], filename)
-    for filename in _FILENAMES:
+            downloadFile(url, file_path, func=callback if filename == "model.bin" else None)
-        file_path = os_path.join(path, filename)
+    if isinstance(end_callback, Callable):
-        url = huggingface_hub.hf_hub_url(_MODELS[weight_type], filename)
+        end_callback()
-        downloadFile(url, file_path, func=callbackFunc)
 
 def getWhisperModel(root, weight_type, device="cpu", device_index=0):
     path = os_path.join(root, "weights", "whisper", weight_type)
@@ -93,10 +92,14 @@ if __name__ == "__main__":
         print(value)
         pass
 
-    downloadWhisperWeight("./", "tiny", callback)
+    def end_callback():
-    downloadWhisperWeight("./", "base", callback)
+        print("end")
-    downloadWhisperWeight("./", "small", callback)
+        pass
-    downloadWhisperWeight("./", "medium", callback)
+
-    downloadWhisperWeight("./", "large-v1", callback)
+    downloadWhisperWeight("./", "tiny", callback, end_callback)
-    downloadWhisperWeight("./", "large-v2", callback)
+    downloadWhisperWeight("./", "base", callback, end_callback)
-    downloadWhisperWeight("./", "large-v3", callback)
+    downloadWhisperWeight("./", "small", callback, end_callback)
+    downloadWhisperWeight("./", "medium", callback, end_callback)
+    downloadWhisperWeight("./", "large-v1", callback, end_callback)
+    downloadWhisperWeight("./", "large-v2", callback, end_callback)
+    downloadWhisperWeight("./", "large-v3", callback, end_callback)

src-python/models/translation/translation_utils.py

@@ -8,7 +8,7 @@ import hashlib
 from utils import printLog
 
 ctranslate2_weights = {
-    "Small": { # M2M-100 418M-parameter model
+    "small": { # M2M-100 418M-parameter model
         "url": "https://github.com/misyaguziya/VRCT-weights/releases/download/v1.0/m2m100_418m.zip",
         "directory_name": "m2m100_418m",
         "tokenizer": "facebook/m2m100_418M",
@@ -18,7 +18,7 @@ ctranslate2_weights = {
             "shared_vocabulary.txt": "bd440aa21b8ca3453fc792a0018a1f3fe68b3464aadddd4d16a4b72f73c86d8c",
         }
     },
-    "Large": { # M2M-100 1.2B-parameter model
+    "large": { # M2M-100 1.2B-parameter model
         "url": "https://github.com/misyaguziya/VRCT-weights/releases/download/v1.0/m2m100_12b.zip",
         "directory_name": "m2m100_12b",
         "tokenizer": "facebook/m2m100_1.2b",
@@ -39,7 +39,7 @@ def calculate_file_hash(file_path, block_size=65536):
 
     return hash_object.hexdigest()
 
-def checkCTranslate2Weight(path, weight_type="Small"):
+def checkCTranslate2Weight(root, weight_type="small"):
     weight_directory_name = ctranslate2_weights[weight_type]["directory_name"]
     hash_data = ctranslate2_weights[weight_type]["hash"]
     files = [
@@ -47,6 +47,7 @@ def checkCTranslate2Weight(path, weight_type="Small"):
         "sentencepiece.model",
         "shared_vocabulary.txt"
     ]
+    path = os_path.join(root, "weights", "ctranslate2")
 
     # check already downloaded
     already_downloaded = False
@@ -60,30 +61,30 @@ def checkCTranslate2Weight(path, weight_type="Small"):
         already_downloaded = True
     return already_downloaded
 
-def downloadCTranslate2Weight(root, weight_type="Small", callbackFunc=None):
+def downloadCTranslate2Weight(root, weight_type="small", callback=None, end_callback=None):
     url = ctranslate2_weights[weight_type]["url"]
     filename = "weight.zip"
     path = os_path.join(root, "weights", "ctranslate2")
     os_makedirs(path, exist_ok=True)
 
-    if checkCTranslate2Weight(path, weight_type):
+    if checkCTranslate2Weight(root, weight_type) is False:
-        callbackFunc(1)
+        try:
-        return
+            with tempfile.TemporaryDirectory() as tmp_path:
+                res = requests_get(url, stream=True)
+                file_size = int(res.headers.get('content-length', 0))
+                total_chunk = 0
+                with open(os_path.join(tmp_path, filename), 'wb') as file:
+                    for chunk in res.iter_content(chunk_size=1024*2000):
+                        file.write(chunk)
+                        if isinstance(callback, Callable):
+                            total_chunk += len(chunk)
+                            callback(total_chunk/file_size)
+                        printLog(f"Downloading CTranslate Model: {total_chunk/file_size:.0%}")
 
-    try:
+                with ZipFile(os_path.join(tmp_path, filename)) as zf:
-        with tempfile.TemporaryDirectory() as tmp_path:
+                    zf.extractall(path)
-            res = requests_get(url, stream=True)
+        except Exception as e:
-            file_size = int(res.headers.get('content-length', 0))
+            printLog("warning:downloadCTranslate2Weight()", e)
-            total_chunk = 0
-            with open(os_path.join(tmp_path, filename), 'wb') as file:
-                for chunk in res.iter_content(chunk_size=1024*2000):
-                    file.write(chunk)
-                    if isinstance(callbackFunc, Callable):
-                        total_chunk += len(chunk)
-                        callbackFunc(total_chunk/file_size)
-                    printLog(f"Downloading CTranslate Model: {total_chunk/file_size:.0%}")
 
-            with ZipFile(os_path.join(tmp_path, filename)) as zf:
+    if isinstance(end_callback, Callable):
-                zf.extractall(path)
+        end_callback()
-    except Exception as e:
-        printLog("warning:downloadCTranslate2Weight()", e)

src-python/webui_controller.py

@@ -134,21 +134,55 @@ class Controller:
                 energy,
             )
 
-    def downloadCTranslate2ProgressBar(self, progress) -> None:
+    class DownloadCTranslate2:
-        printLog("CTranslate2 Weight Download Progress", progress)
+        def __init__(self, run_mapping:dict,  weight_type:str, run:Callable[[int, str, Any], None]) -> None:
-        self.run(
+            self.run_mapping = run_mapping
-            200,
+            self.weight_type = weight_type
-            self.run_mapping["download_ctranslate2"],
+            self.run = run
-            progress,
-        )
 
-    def downloadWhisperProgressBar(self, progress) -> None:
+        def progressBar(self, progress) -> None:
-        printLog("Whisper Weight Download Progress", progress)
+            printLog("CTranslate2 Weight Download Progress", progress)
-        self.run(
+            self.run(
-            200,
+                200,
-            self.run_mapping["download_whisper"],
+                self.run_mapping["download_ctranslate2_weight"],
-            progress,
+                {"weight_type": self.weight_type, "progress": progress},
-        )
+            )
+
+        def downloaded(self) -> None:
+            weight_type_dict = config.SELECTABLE_CTRANSLATE2_WEIGHT_TYPE_DICT
+            weight_type_dict["self.weight_type"] = True
+            config.SELECTABLE_CTRANSLATE2_WEIGHT_TYPE_DICT = weight_type_dict
+
+            self.run(
+                200,
+                self.run_mapping["downloaded_ctranslate2_weight"],
+                self.weight_type,
+            )
+
+    class DownloadWhisper:
+        def __init__(self, run_mapping:dict, weight_type:str, run:Callable[[int, str, Any], None]) -> None:
+            self.run_mapping = run_mapping
+            self.weight_type = weight_type
+            self.run = run
+
+        def progressBar(self, progress) -> None:
+            printLog("Whisper Weight Download Progress", progress)
+            self.run(
+                200,
+                self.run_mapping["download_whisper_weight"],
+                {"weight_type": self.weight_type, "progress": progress},
+            )
+
+        def downloaded(self) -> None:
+            weight_type_dict = config.SELECTABLE_WHISPER_WEIGHT_TYPE_DICT
+            weight_type_dict[self.weight_type] = True
+            config.SELECTABLE_WHISPER_WEIGHT_TYPE_DICT = weight_type_dict
+
+            self.run(
+                200,
+                self.run_mapping["downloaded_whisper_weight"],
+                self.weight_type,
+            )
 
     def micMessage(self, message: Union[str, bool]) -> None:
         if isinstance(message, bool) and message is False:
@@ -397,8 +431,8 @@ class Controller:
         return {"status":200,"result":config.SELECTED_TRANSLATION_COMPUTE_DEVICE}
 
     @staticmethod
-    def getSelectableCtranslate2WeightTypeList(*args, **kwargs) -> dict:
+    def getSelectableCtranslate2WeightTypeDict(*args, **kwargs) -> dict:
-        return {"status":200, "result":config.SELECTABLE_CTRANSLATE2_WEIGHT_TYPE_LIST}
+        return {"status":200, "result":config.SELECTABLE_CTRANSLATE2_WEIGHT_TYPE_DICT}
 
     @staticmethod
     def getSelectedTranscriptionComputeDevice(*args, **kwargs) -> dict:
@@ -411,8 +445,8 @@ class Controller:
         return {"status":200,"result":config.SELECTED_TRANSCRIPTION_COMPUTE_DEVICE}
 
     @staticmethod
-    def getSelectableWhisperWeightTypeList(*args, **kwargs) -> dict:
+    def getSelectableWhisperWeightTypeDict(*args, **kwargs) -> dict:
-        return {"status":200, "result":config.SELECTABLE_WHISPER_WEIGHT_TYPE_LIST}
+        return {"status":200, "result":config.SELECTABLE_WHISPER_WEIGHT_TYPE_DICT}
 
     @staticmethod
     def getMaxMicThreshold(*args, **kwargs) -> dict:
@@ -511,6 +545,11 @@ class Controller:
     def getSelectedTranscriptionEngine(*args, **kwargs) -> dict:
         return {"status":200, "result":config.SELECTED_TRANSCRIPTION_ENGINE}
 
+    @staticmethod
+    def setSelectedTranscriptionEngine(data, *args, **kwargs) -> dict:
+        config.SELECTED_TRANSCRIPTION_ENGINE = str(data)
+        return {"status":200, "result":config.SELECTED_TRANSCRIPTION_ENGINE}
+
     @staticmethod
     def getMultiLanguageTranslation(*args, **kwargs) -> dict:
         return {"status":200, "result":config.MULTI_LANGUAGE_TRANSLATION}
@@ -1072,74 +1111,6 @@ class Controller:
         self.updateTranslationEngineAndEngineList()
         return {"status":200, "result":config.AUTH_KEYS["DeepL_API"]}
 
-    @staticmethod
-    def getUseTranslationFeature(*args, **kwargs) -> dict:
-        return {"status":200, "result":config.USE_TRANSLATION_FEATURE}
-
-    @staticmethod
-    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,
-                    },
-                }
-
-    @staticmethod
-    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,
-                    },
-                }
-
-    @staticmethod
-    def getUseWhisperFeature(*args, **kwargs) -> dict:
-        return {"status":200, "result":config.USE_WHISPER_FEATURE}
-
-    @staticmethod
-    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,
-                    },
-                }
-
-    @staticmethod
-    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,
-                    },
-                }
-
     @staticmethod
     def getCtranslate2WeightType(*args, **kwargs) -> dict:
         return {"status":200, "result":config.CTRANSLATE2_WEIGHT_TYPE}
@@ -1147,21 +1118,13 @@ class Controller:
     @staticmethod
     def setCtranslate2WeightType(data, *args, **kwargs) -> dict:
         config.CTRANSLATE2_WEIGHT_TYPE = str(data)
-        if model.checkCTranslatorCTranslate2ModelWeight():
+        if model.checkTranslatorCTranslate2ModelWeight(config.CTRANSLATE2_WEIGHT_TYPE):
-            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:
+        return {"status":200, "result":config.CTRANSLATE2_WEIGHT_TYPE}
-            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,
-                    },
-                }
 
     @staticmethod
     def getWhisperWeightType(*args, **kwargs) -> dict:
@@ -1170,19 +1133,7 @@ class Controller:
     @staticmethod
     def setWhisperWeightType(data, *args, **kwargs) -> dict:
         config.WHISPER_WEIGHT_TYPE = str(data)
-        if model.checkTranscriptionWhisperModelWeight() is True:
+        return {"status":200, "result": config.WHISPER_WEIGHT_TYPE}
-            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,
-                }
-            }
 
     @staticmethod
     def getAutoClearMessageBox(*args, **kwargs) -> dict:
@@ -1469,12 +1420,33 @@ class Controller:
         th_start_update_software.start()
         return {"status":200, "result":True}
 
-    def downloadCtranslate2Weight(self, *args, **kwargs) -> dict:
+    def downloadCtranslate2Weight(self, data:str, *args, **kwargs) -> dict:
-        self.startThreadingDownloadCtranslate2Weight(self.downloadCTranslate2ProgressBar)
+        weight_type = str(data)
+        download_ctranslate2 = self.DownloadCTranslate2(
+            self.run_mapping,
+            weight_type,
+            self.run
+            )
+
+        self.startThreadingDownloadCtranslate2Weight(
+            weight_type,
+            download_ctranslate2.progressBar,
+            download_ctranslate2.downloaded,
+            )
         return {"status":200, "result":True}
 
-    def downloadWhisperWeight(self, *args, **kwargs) -> dict:
+    def downloadWhisperWeight(self, data:str, *args, **kwargs) -> dict:
-        self.startThreadingDownloadWhisperWeight(self.downloadWhisperProgressBar)
+        weight_type = str(data)
+        download_whisper = self.DownloadWhisper(
+            self.run_mapping,
+            weight_type,
+            self.run
+        )
+        self.startThreadingDownloadWhisperWeight(
+            weight_type,
+            download_whisper.progressBar,
+            download_whisper.downloaded,
+            )
         return {"status":200, "result":True}
 
     @staticmethod
@@ -1583,14 +1555,35 @@ class Controller:
         cleaned_text = re.sub(pattern, r'\1', text)
         return cleaned_text
 
+    def updateDownloadedCTranslate2ModelWeight(self) -> None:
+        weight_type_dict = config.SELECTABLE_CTRANSLATE2_WEIGHT_TYPE_DICT
+        for weight_type in weight_type_dict.keys():
+            weight_type_dict[weight_type] = model.checkTranslatorCTranslate2ModelWeight(weight_type)
+        config.SELECTABLE_CTRANSLATE2_WEIGHT_TYPE_DICT = weight_type_dict
+
     def updateTranslationEngineAndEngineList(self):
-        engine = config.SELECTED_TRANSLATION_ENGINES[config.SELECTED_TAB_NO]
+        engines = config.SELECTED_TRANSLATION_ENGINES
-        engines = self.getTranslationEngines()["result"]
+        engine = engines[config.SELECTED_TAB_NO]
-        if engine not in engines:
+        selectable_engines = self.getTranslationEngines()["result"]
+        if engine not in selectable_engines:
             engine = "CTranslate2"
-        config.SELECTED_TRANSLATION_ENGINES[config.SELECTED_TAB_NO] = engine
+        engines[config.SELECTED_TAB_NO] = engine
+        config.SELECTED_TRANSLATION_ENGINES = engines
+
         self.run(200, self.run_mapping["selected_translation_engines"], config.SELECTED_TRANSLATION_ENGINES)
-        self.run(200, self.run_mapping["translation_engines"], engines)
+        self.run(200, self.run_mapping["translation_engines"], selectable_engines)
+
+    def updateDownloadedWhisperModelWeight(self) -> None:
+        weight_type_dict = config.SELECTABLE_WHISPER_WEIGHT_TYPE_DICT
+        for weight_type in weight_type_dict.keys():
+            weight_type_dict[weight_type] = model.checkTranscriptionWhisperModelWeight(weight_type)
+        config.SELECTABLE_WHISPER_WEIGHT_TYPE_DICT = weight_type_dict
+
+    def updateTranscriptionEngine(self):
+        weight_type_dict = config.SELECTABLE_WHISPER_WEIGHT_TYPE_DICT
+        weight_type = config.WHISPER_WEIGHT_TYPE
+        if config.SELECTED_TRANSCRIPTION_ENGINE == "Whisper" and weight_type_dict[weight_type] is False:
+            config.SELECTED_TRANSCRIPTION_ENGINE = "Google"
 
     def startCheckMicEnergy(self) -> None:
         while self.device_access_status is False:
@@ -1635,14 +1628,14 @@ class Controller:
         th_stopCheckSpeakerEnergy.join()
 
     @staticmethod
-    def startThreadingDownloadCtranslate2Weight(callback:Callable[[float], None]) -> None:
+    def startThreadingDownloadCtranslate2Weight(weight_type:str, callback:Callable[[float], None], end_callback:Callable[[float], None]) -> None:
-        th_download = Thread(target=model.downloadCTranslate2ModelWeight, args=(callback,))
+        th_download = Thread(target=model.downloadCTranslate2ModelWeight, args=(weight_type, callback, end_callback))
         th_download.daemon = True
         th_download.start()
 
     @staticmethod
-    def startThreadingDownloadWhisperWeight(callback:Callable[[float], None]) -> None:
+    def startThreadingDownloadWhisperWeight(weight_type:str, callback:Callable[[float], None], end_callback:Callable[[float], None]) -> None:
-        th_download = Thread(target=model.downloadWhisperModelWeight, args=(callback,))
+        th_download = Thread(target=model.downloadWhisperModelWeight, args=(weight_type, callback, end_callback))
         th_download.daemon = True
         th_download.start()
 
@@ -1676,26 +1669,25 @@ class Controller:
                 auth_keys["DeepL_API"] = None
                 config.AUTH_KEYS = auth_keys
 
+        # download CTranslate2 Model Weight
+        printLog("Download CTranslate2 Model Weight")
+        if model.checkTranslatorCTranslate2ModelWeight(config.CTRANSLATE2_WEIGHT_TYPE) is False:
+            self.downloadCtranslate2Weight(config.CTRANSLATE2_WEIGHT_TYPE)
+
         # set Translation Engine
         printLog("Set Translation Engine")
+        self.updateDownloadedCTranslate2ModelWeight()
         self.updateTranslationEngineAndEngineList()
 
-        # check Downloaded CTranslate2 Model Weight
+        # download Whisper Model Weight
-        printLog("Check Downloaded CTranslate2 Model Weight")
+        printLog("Download Whisper Model Weight")
-        if config.USE_TRANSLATION_FEATURE is True and model.checkCTranslatorCTranslate2ModelWeight() is False:
+        if model.checkTranscriptionWhisperModelWeight(config.WHISPER_WEIGHT_TYPE) is False:
-            self.startThreadingDownloadCtranslate2Weight(self.downloadCTranslate2ProgressBar)
+            self.downloadWhisperWeight(config.WHISPER_WEIGHT_TYPE)
 
         # set Transcription Engine
         printLog("Set Transcription Engine")
-        if config.USE_WHISPER_FEATURE is True:
+        self.updateDownloadedWhisperModelWeight()
-            config.SELECTED_TRANSCRIPTION_ENGINE = "Whisper"
+        self.updateTranscriptionEngine()
-        else:
-            config.SELECTED_TRANSCRIPTION_ENGINE = "Google"
-
-        # check Downloaded Whisper Model Weight
-        printLog("Check Downloaded Whisper Model Weight")
-        if config.USE_WHISPER_FEATURE is True and model.checkTranscriptionWhisperModelWeight() is False:
-            self.startThreadingDownloadWhisperWeight(self.downloadWhisperProgressBar)
 
         # set word filter
         printLog("Set Word Filter")

src-python/webui_mainloop.py

@@ -20,8 +20,10 @@ run_mapping = {
     "error_translation_engine":"/run/error_translation_engine",
     "word_filter":"/run/word_filter",
 
-    "download_ctranslate2":"/run/download_ctranslate2_weight",
+    "download_ctranslate2_weight":"/run/download_ctranslate2_weight",
-    "download_whisper":"/run/download_whisper_weight",
+    "downloaded_ctranslate2_weight":"/run/downloaded_ctranslate2_weight",
+    "download_whisper_weight":"/run/download_whisper_weight",
+    "downloaded_whisper_weight":"/run/downloaded_whisper_weight",
 
     "selected_mic_device":"/run/selected_mic_device",
     "selected_speaker_device":"/run/selected_speaker_device",
@@ -79,6 +81,7 @@ mapping = {
     "/set/data/selected_target_languages": {"status": True, "variable":controller.setSelectedTargetLanguages},
 
     "/get/data/selected_transcription_engine": {"status": False, "variable":controller.getSelectedTranscriptionEngine},
+    "/set/data/selected_transcription_engine": {"status": False, "variable":controller.setSelectedTranscriptionEngine},
 
     "/run/send_message_box": {"status": False, "variable":controller.sendMessageBox},
     "/run/typing_message_box": {"status": False, "variable":controller.typingMessageBox},
@@ -128,15 +131,11 @@ mapping = {
     "/set/data/main_window_geometry": {"status": True, "variable":controller.setMainWindowGeometry},
 
     # Translation
-    "/get/data/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/data/translation_compute_device_list": {"status": True, "variable":controller.getComputeDeviceList},
     "/get/data/selected_translation_compute_device": {"status": True, "variable":controller.getSelectedTranslationComputeDevice},
     "/set/data/selected_translation_compute_device": {"status": True, "variable":controller.setSelectedTranslationComputeDevice},
 
-    "/get/data/selectable_ctranslate2_weight_type_list": {"status": True, "variable":controller.getSelectableCtranslate2WeightTypeList},
+    "/get/data/selectable_ctranslate2_weight_type_dict": {"status": True, "variable":controller.getSelectableCtranslate2WeightTypeDict},
 
     "/get/data/ctranslate2_weight_type": {"status": True, "variable":controller.getCtranslate2WeightType},
     "/set/data/ctranslate2_weight_type": {"status": True, "variable":controller.setCtranslate2WeightType},
@@ -241,15 +240,11 @@ mapping = {
     "/get/data/selected_transcription_compute_device": {"status": True, "variable":controller.getSelectedTranscriptionComputeDevice},
     "/set/data/selected_transcription_compute_device": {"status": True, "variable":controller.setSelectedTranscriptionComputeDevice},
 
-    "/get/data/selectable_whisper_weight_type_list": {"status": True, "variable":controller.getSelectableWhisperWeightTypeList},
+    "/get/data/selectable_whisper_weight_type_dict": {"status": True, "variable":controller.getSelectableWhisperWeightTypeDict},
 
     "/get/data/whisper_weight_type": {"status": True, "variable":controller.getWhisperWeightType},
     "/set/data/whisper_weight_type": {"status": True, "variable":controller.setWhisperWeightType},
 
-    "/get/data/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},
-
     "/run/download_whisper_weight": {"status": True, "variable":controller.downloadWhisperWeight},
 
     # VR
@@ -517,7 +512,7 @@ if __name__ == "__main__":
                     case "/set/data/ui_language":
                         data = "ja"
                     case "/set/data/ctranslate2_weight_type":
-                        data = "Small"
+                        data = "small"
                     case "/set/data/deepl_auth_key":
                         data = "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee:fx"
                     case "/set/data/selected_mic_host":