途中まで翻訳Engine部分がまだ

config.py

@@ -135,43 +135,43 @@ class Config:
             saveJson(self.PATH_CONFIG, inspect.currentframe().f_code.co_name, value)
 
     @property
-    def INPUT_SOURCE_LANG(self):
+    def SOURCE_LANGUAGE(self):
-        return self._INPUT_SOURCE_LANG
+        return self._SOURCE_LANGUAGE
 
-    @INPUT_SOURCE_LANG.setter
+    @SOURCE_LANGUAGE.setter
-    def INPUT_SOURCE_LANG(self, value):
+    def SOURCE_LANGUAGE(self, value):
-        if value in list(translation_lang[self.CHOICE_TRANSLATOR]["source"].keys()):
+        if type(value) is str:
-            self._INPUT_SOURCE_LANG = value
+            self._SOURCE_LANGUAGE = value
             saveJson(self.PATH_CONFIG, inspect.currentframe().f_code.co_name, value)
 
     @property
-    def INPUT_TARGET_LANG(self):
+    def SOURCE_COUNTRY(self):
-        return self._INPUT_TARGET_LANG
+        return self._SOURCE_COUNTRY
 
-    @INPUT_TARGET_LANG.setter
+    @SOURCE_COUNTRY.setter
-    def INPUT_TARGET_LANG(self, value):
+    def SOURCE_COUNTRY(self, value):
-        if value in list(translation_lang[self.CHOICE_TRANSLATOR]["target"].keys()):
+        if type(value) is str:
-            self._INPUT_TARGET_LANG = value
+            self._SOURCE_COUNTRY = value
             saveJson(self.PATH_CONFIG, inspect.currentframe().f_code.co_name, value)
 
     @property
-    def OUTPUT_SOURCE_LANG(self):
+    def TARGET_LANGUAGE(self):
-        return self._OUTPUT_SOURCE_LANG
+        return self._TARGET_LANGUAGE
 
-    @OUTPUT_SOURCE_LANG.setter
+    @TARGET_LANGUAGE.setter
-    def OUTPUT_SOURCE_LANG(self, value):
+    def TARGET_LANGUAGE(self, value):
-        if value in list(translation_lang[self.CHOICE_TRANSLATOR]["source"].keys()):
+        if type(value) is str:
-            self._OUTPUT_SOURCE_LANG = value
+            self._TARGET_LANGUAGE = value
             saveJson(self.PATH_CONFIG, inspect.currentframe().f_code.co_name, value)
 
     @property
-    def OUTPUT_TARGET_LANG(self):
+    def TARGET_COUNTRY(self):
-        return self._OUTPUT_TARGET_LANG
+        return self._TARGET_COUNTRY
 
-    @OUTPUT_TARGET_LANG.setter
+    @TARGET_COUNTRY.setter
-    def OUTPUT_TARGET_LANG(self, value):
+    def TARGET_COUNTRY(self, value):
-        if value in list(translation_lang[self.CHOICE_TRANSLATOR]["target"].keys()):
+        if type(value) is str:
-            self._OUTPUT_TARGET_LANG = value
+            self._TARGET_COUNTRY = value
             saveJson(self.PATH_CONFIG, inspect.currentframe().f_code.co_name, value)
 
     @property
@@ -194,16 +194,6 @@ class Config:
             self._CHOICE_MIC_DEVICE = value
             saveJson(self.PATH_CONFIG, inspect.currentframe().f_code.co_name, value)
 
-    @property
-    def INPUT_MIC_VOICE_LANGUAGE(self):
-        return self._INPUT_MIC_VOICE_LANGUAGE
-
-    @INPUT_MIC_VOICE_LANGUAGE.setter
-    def INPUT_MIC_VOICE_LANGUAGE(self, value):
-        if value in list(transcription_lang.keys()):
-            self._INPUT_MIC_VOICE_LANGUAGE = value
-            saveJson(self.PATH_CONFIG, inspect.currentframe().f_code.co_name, value)
-
     @property
     def INPUT_MIC_ENERGY_THRESHOLD(self):
         return self._INPUT_MIC_ENERGY_THRESHOLD
@@ -276,16 +266,6 @@ class Config:
                 self._CHOICE_SPEAKER_DEVICE = value
                 saveJson(self.PATH_CONFIG, inspect.currentframe().f_code.co_name, value)
 
-    @property
-    def INPUT_SPEAKER_VOICE_LANGUAGE(self):
-        return self._INPUT_SPEAKER_VOICE_LANGUAGE
-
-    @INPUT_SPEAKER_VOICE_LANGUAGE.setter
-    def INPUT_SPEAKER_VOICE_LANGUAGE(self, value):
-        if value in list(transcription_lang.keys()):
-            self._INPUT_SPEAKER_VOICE_LANGUAGE = value
-            saveJson(self.PATH_CONFIG, inspect.currentframe().f_code.co_name, value)
-
     @property
     def INPUT_SPEAKER_ENERGY_THRESHOLD(self):
         return self._INPUT_SPEAKER_ENERGY_THRESHOLD
@@ -432,6 +412,36 @@ class Config:
     def MAX_SPEAKER_ENERGY_THRESHOLD(self):
         return self._MAX_SPEAKER_ENERGY_THRESHOLD
 
+    @property
+    def SELECTED_TAB_NO(self):
+        return self._SELECTED_TAB_NO
+
+    @SELECTED_TAB_NO.setter
+    def SELECTED_TAB_NO(self, value):
+        if type(value) is str:
+            self._SELECTED_TAB_NO = value
+            saveJson(self.PATH_CONFIG, inspect.currentframe().f_code.co_name, value)
+
+    @property
+    def SELECTED_TAB_YOUR_LANGUAGES(self):
+        return self._SELECTED_TAB_YOUR_LANGUAGES
+
+    @SELECTED_TAB_YOUR_LANGUAGES.setter
+    def SELECTED_TAB_YOUR_LANGUAGES(self, value):
+        if type(value) is dict:
+            self._SELECTED_TAB_YOUR_LANGUAGES = value
+            saveJson(self.PATH_CONFIG, inspect.currentframe().f_code.co_name, value)
+
+    @property
+    def SELECTED_TAB_TARGET_LANGUAGES(self):
+        return self._SELECTED_TAB_TARGET_LANGUAGES
+
+    @SELECTED_TAB_TARGET_LANGUAGES.setter
+    def SELECTED_TAB_TARGET_LANGUAGES(self, value):
+        if type(value) is dict:
+            self._SELECTED_TAB_TARGET_LANGUAGES = value
+            saveJson(self.PATH_CONFIG, inspect.currentframe().f_code.co_name, value)
+
     def init_config(self):
         self._VERSION = "1.3.2"
         self._PATH_CONFIG = "./config.json"
@@ -445,13 +455,12 @@ class Config:
         self._FONT_FAMILY = "Yu Gothic UI"
         self._UI_LANGUAGE = "en"
         self._CHOICE_TRANSLATOR = translatorEngine[0]
-        self._INPUT_SOURCE_LANG = list(translation_lang[self.CHOICE_TRANSLATOR]["source"].keys())[0]
+        self._SOURCE_LANGUAGE = "Japanese"
-        self._INPUT_TARGET_LANG = list(translation_lang[self.CHOICE_TRANSLATOR]["target"].keys())[1]
+        self._SOURCE_COUNTRY = "Japan"
-        self._OUTPUT_SOURCE_LANG = list(translation_lang[self.CHOICE_TRANSLATOR]["source"].keys())[1]
+        self._TARGET_LANGUAGE = "English"
-        self._OUTPUT_TARGET_LANG = list(translation_lang[self.CHOICE_TRANSLATOR]["target"].keys())[0]
+        self._TARGET_COUNTRY = "United States"
         self._CHOICE_MIC_HOST = getDefaultInputDevice()["host"]["name"]
         self._CHOICE_MIC_DEVICE = getDefaultInputDevice()["device"]["name"]
-        self._INPUT_MIC_VOICE_LANGUAGE = list(transcription_lang.keys())[0]
         self._INPUT_MIC_ENERGY_THRESHOLD = 300
         self._INPUT_MIC_DYNAMIC_ENERGY_THRESHOLD = True
         self._INPUT_MIC_RECORD_TIMEOUT = 3
@@ -459,7 +468,6 @@ class Config:
         self._INPUT_MIC_MAX_PHRASES = 10
         self._INPUT_MIC_WORD_FILTER = []
         self._CHOICE_SPEAKER_DEVICE = getDefaultOutputDevice()["name"]
-        self._INPUT_SPEAKER_VOICE_LANGUAGE = list(transcription_lang.keys())[1]
         self._INPUT_SPEAKER_ENERGY_THRESHOLD = 300
         self._INPUT_SPEAKER_DYNAMIC_ENERGY_THRESHOLD = True
         self._INPUT_SPEAKER_RECORD_TIMEOUT = 3
@@ -485,6 +493,17 @@ class Config:
         ]
         self._MAX_MIC_ENERGY_THRESHOLD = 2000
         self._MAX_SPEAKER_ENERGY_THRESHOLD = 4000
+        self._SELECTED_TAB_NO = "tab_1"
+        self._SELECTED_TAB_YOUR_LANGUAGES = {
+            "tab_1":"Japanese\n(Japan)",
+            "tab_2":"Japanese\n(Japan)",
+            "tab_3":"Japanese\n(Japan)",
+        }
+        self._SELECTED_TAB_TARGET_LANGUAGES = {
+            "tab_1":"English\n(United States)",
+            "tab_2":"English\n(United States)",
+            "tab_3":"English\n(United States)",
+        }
 
     def load_config(self):
         if os_path.isfile(self.PATH_CONFIG) is not False:

main.py

@@ -3,6 +3,8 @@ import customtkinter
 from vrct_gui import vrct_gui
 from config import config
 from model import model
+from models.translation.translation_languages import translatorEngine, translation_lang
+from models.transcription.transcription_languages import transcription_lang
 
 # func transcription send message
 def sendMicMessage(message):
@@ -117,6 +119,86 @@ def foregroundOnForcefully(e):
     if config.ENABLE_FOREGROUND:
         vrct_gui.attributes("-topmost", True)
 
+# func select languages
+def getListLanguageAndCountry():
+    langs = []
+    for lang in model.SUPPORTED_LANGUAGES:
+        for country in transcription_lang[lang]:
+            langs.append(f"{lang}\n({country})")
+    return langs
+
+def getLanguageAndState(select):
+    parts = select.split("\n")
+    language = parts[0]
+    country = parts[1][1:-1]
+    return language, country
+
+def setYourLanguageAndCountry(select):
+    languages = config.SELECTED_TAB_YOUR_LANGUAGES
+    languages[config.SELECTED_TAB_NO] = select
+    config.SELECTED_TAB_YOUR_LANGUAGES = languages
+
+    language, country = getLanguageAndState(select)
+    config.SOURCE_LANGUAGE = language
+    config.SOURCE_COUNTRY = country
+
+def setTargetLanguageAndCountry(select):
+    languages = config.SELECTED_TAB_TARGET_LANGUAGES
+    languages[config.SELECTED_TAB_NO] = select
+    config.SELECTED_TAB_TARGET_LANGUAGES = languages
+
+    language, country = getLanguageAndState(select)
+    config.TARGET_LANGUAGE = language
+    config.TARGET_COUNTRY = country
+
+def callbackSelectedTabNo1():
+    config.SELECTED_TAB_NO = "tab_1"
+    vrct_gui.YOUR_LANGUAGE = config.SELECTED_TAB_YOUR_LANGUAGES[config.SELECTED_TAB_NO]
+    vrct_gui.TARGET_LANGUAGE = config.SELECTED_TAB_TARGET_LANGUAGES[config.SELECTED_TAB_NO]
+
+    languages = config.SELECTED_TAB_YOUR_LANGUAGES
+    select = languages[config.SELECTED_TAB_NO]
+    language, country = getLanguageAndState(select)
+    config.SOURCE_LANGUAGE = language
+    config.SOURCE_COUNTRY = country
+    languages = config.SELECTED_TAB_TARGET_LANGUAGES
+    select = languages[config.SELECTED_TAB_NO]
+    language, country = getLanguageAndState(select)
+    config.TARGET_LANGUAGE = language
+    config.TARGET_COUNTRY = country
+
+def callbackSelectedTabNo2():
+    config.SELECTED_TAB_NO = "tab_2"
+    vrct_gui.YOUR_LANGUAGE = config.SELECTED_TAB_YOUR_LANGUAGES[config.SELECTED_TAB_NO]
+    vrct_gui.TARGET_LANGUAGE = config.SELECTED_TAB_TARGET_LANGUAGES[config.SELECTED_TAB_NO]
+
+    languages = config.SELECTED_TAB_YOUR_LANGUAGES
+    select = languages[config.SELECTED_TAB_NO]
+    language, country = getLanguageAndState(select)
+    config.SOURCE_LANGUAGE = language
+    config.SOURCE_COUNTRY = country
+    languages = config.SELECTED_TAB_TARGET_LANGUAGES
+    select = languages[config.SELECTED_TAB_NO]
+    language, country = getLanguageAndState(select)
+    config.TARGET_LANGUAGE = language
+    config.TARGET_COUNTRY = country
+
+def callbackSelectedTabNo3():
+    config.SELECTED_TAB_NO = "tab_3"
+    vrct_gui.YOUR_LANGUAGE = config.SELECTED_TAB_YOUR_LANGUAGES[config.SELECTED_TAB_NO]
+    vrct_gui.TARGET_LANGUAGE = config.SELECTED_TAB_TARGET_LANGUAGES[config.SELECTED_TAB_NO]
+
+    languages = config.SELECTED_TAB_YOUR_LANGUAGES
+    select = languages[config.SELECTED_TAB_NO]
+    language, country = getLanguageAndState(select)
+    config.SOURCE_LANGUAGE = language
+    config.SOURCE_COUNTRY = country
+    languages = config.SELECTED_TAB_TARGET_LANGUAGES
+    select = languages[config.SELECTED_TAB_NO]
+    language, country = getLanguageAndState(select)
+    config.TARGET_LANGUAGE = language
+    config.TARGET_COUNTRY = country
+
 # func print textbox
 def logTranslationStatusChange():
     textbox_all = getattr(vrct_gui, "textbox_all")
@@ -250,5 +332,18 @@ entry_message_box.bind("<Any-KeyPress>", messageBoxPressKeyAny)
 entry_message_box.bind("<FocusIn>", foregroundOffForcefully)
 entry_message_box.bind("<FocusOut>", foregroundOnForcefully)
 
+sqls__optionmenu_your_language = getattr(vrct_gui, "sqls__optionmenu_your_language")
+sqls__optionmenu_your_language.configure(values=getListLanguageAndCountry())
+sqls__optionmenu_your_language.configure(command=setYourLanguageAndCountry)
+
+sqls__optionmenu_target_language = getattr(vrct_gui, "sqls__optionmenu_target_language")
+sqls__optionmenu_target_language.configure(values=getListLanguageAndCountry())
+sqls__optionmenu_target_language.configure(command=setTargetLanguageAndCountry)
+
+vrct_gui.CALLBACK_SELECTED_TAB_NO_1 = callbackSelectedTabNo1
+vrct_gui.CALLBACK_SELECTED_TAB_NO_2 = callbackSelectedTabNo2
+vrct_gui.CALLBACK_SELECTED_TAB_NO_3 = callbackSelectedTabNo3
+
+
 if __name__ == "__main__":
     vrct_gui.startMainLoop()

model.py

@@ -29,6 +29,15 @@ class threadFnc(Thread):
             self.fnc(*self._args, **self._kwargs)
 
 class Model:
+    # Languages available for both transcription and translation
+    SUPPORTED_LANGUAGES = [
+        'Afrikaans', 'Arabic', 'Basque', 'Bulgarian', 'Catalan', 'Chinese', 'Croatian',
+        'Czech', 'Danish', 'Dutch', 'English', 'Filipino', 'Finnish', 'French', 'German',
+        'Greek', 'Hebrew', 'Hindi', 'Hungarian', 'Indonesian', 'Italian', 'Japanese',
+        'Korean', 'Lithuanian', 'Malay', 'Norwegian', 'Polish', 'Portuguese', 'Romanian',
+        'Russian', 'Serbian', 'Slovak', 'Slovenian', 'Spanish', 'Swedish', 'Thai', 'Turkish',
+        'Ukrainian', 'Vietnamese'
+        ]
     _instance = None
 
     def __new__(cls):
@@ -75,8 +84,8 @@ class Model:
     def getInputTranslate(self, message):
         translation = self.translator.translate(
                         translator_name=config.CHOICE_TRANSLATOR,
-                        source_language=config.INPUT_SOURCE_LANG,
+                        source_language=config.SOURCE_LANGUAGE,
-                        target_language=config.INPUT_TARGET_LANG,
+                        target_language=config.TARGET_LANGUAGE,
                         message=message
                 )
         return translation
@@ -170,7 +179,7 @@ class Model:
             max_phrases=config.INPUT_MIC_MAX_PHRASES,
         )
         def sendMicTranscript():
-            mic_transcriber.transcribeAudioQueue(mic_audio_queue, config.INPUT_MIC_VOICE_LANGUAGE)
+            mic_transcriber.transcribeAudioQueue(mic_audio_queue, config.SOURCE_LANGUAGE, config.SOURCE_COUNTRY)
             message = mic_transcriber.getTranscript()
             fnc(message)
 
@@ -222,7 +231,7 @@ class Model:
             max_phrases=config.INPUT_SPEAKER_MAX_PHRASES,
         )
         def sendSpkTranscript():
-            spk_transcriber.transcribeAudioQueue(spk_audio_queue, config.INPUT_SPEAKER_VOICE_LANGUAGE)
+            spk_transcriber.transcribeAudioQueue(spk_audio_queue, config.TARGET_LANGUAGE, config.TARGET_COUNTRY)
             message = spk_transcriber.getTranscript()
             fnc(message)
 

models/transcription/transcription_transcriber.py

@@ -27,7 +27,7 @@ class AudioTranscriber:
                 "process_data_func": self.processSpeakerData if speaker else self.processSpeakerData
         }
 
-    def transcribeAudioQueue(self, audio_queue, language):
+    def transcribeAudioQueue(self, audio_queue, language, country):
         # while True:
         audio, time_spoken = audio_queue.get()
         self.updateLastSampleAndPhraseStatus(audio, time_spoken)
@@ -37,7 +37,7 @@ class AudioTranscriber:
             # fd, path = tempfile.mkstemp(suffix=".wav")
             # os.close(fd)
             audio_data = self.audio_sources["process_data_func"]()
-            text = self.audio_recognizer.recognize_google(audio_data, language=transcription_lang[language])
+            text = self.audio_recognizer.recognize_google(audio_data, language=transcription_lang[language][country])
         except Exception as e:
             pass
         finally:

vrct_gui/main_window/widgets/create_sidebar.py

@@ -120,22 +120,28 @@ def createSidebar(settings, main_window):
 
     def switchToPreset1(e):
         print("1")
-        main_window.YOUR_LANGUAGE = "Japanese\n(Japan)"
+        if callable(main_window.CALLBACK_SELECTED_TAB_NO_1) is True:
-        main_window.TARGET_LANGUAGE = "English\n(United States)"
+            main_window.CALLBACK_SELECTED_TAB_NO_1()
+        # main_window.YOUR_LANGUAGE = "Japanese\n(Japan)"
+        # main_window.TARGET_LANGUAGE = "English\n(United States)"
         target_active_widget = getattr(main_window, "sqls__presets_button_1")
         switchPresetTabFunction(target_active_widget)
 
     def switchToPreset2(e):
         print("2")
-        main_window.YOUR_LANGUAGE = "English\n(United States)"
+        if callable(main_window.CALLBACK_SELECTED_TAB_NO_2) is True:
-        main_window.TARGET_LANGUAGE = "Japanese\n(Japan)"
+            main_window.CALLBACK_SELECTED_TAB_NO_2()
+        # main_window.YOUR_LANGUAGE = "English\n(United States)"
+        # main_window.TARGET_LANGUAGE = "Japanese\n(Japan)"
         target_active_widget = getattr(main_window, "sqls__presets_button_2")
         switchPresetTabFunction(target_active_widget)
 
     def switchToPreset3(e):
         print("3")
-        main_window.YOUR_LANGUAGE = "Japanese\n(Japan)"
+        if callable(main_window.CALLBACK_SELECTED_TAB_NO_3) is True:
-        main_window.TARGET_LANGUAGE = "Chinese, Cantonese\n(Traditional Hong Kong)"
+            main_window.CALLBACK_SELECTED_TAB_NO_3()
+        # main_window.YOUR_LANGUAGE = "Japanese\n(Japan)"
+        # main_window.TARGET_LANGUAGE = "Chinese, Cantonese\n(Traditional Hong Kong)"
         target_active_widget = getattr(main_window, "sqls__presets_button_3")
         switchPresetTabFunction(target_active_widget)
 

vrct_gui/vrct_gui.py

@@ -47,6 +47,9 @@ class VRCT_GUI(CTk):
         self.YOUR_LANGUAGE = "Japanese\n(Japan)"
         self.TARGET_LANGUAGE = "English\n(United States)"
 
+        self.CALLBACK_SELECTED_TAB_NO_1 = None
+        self.CALLBACK_SELECTED_TAB_NO_2 = None
+        self.CALLBACK_SELECTED_TAB_NO_3 = None
 
         self.config_window = ConfigWindow(vrct_gui=self, settings=self.settings.config_window)
         # self.information_window = ToplevelWindowInformation(self)