[Update] config.pyの設定を他ファイルに適応した

VRCT.py

@@ -1,10 +1,7 @@
 from time import sleep
 from os import path as os_path
-from json import load as json_load
-from json import dump as json_dump
 from requests import get as requests_get
 from queue import Queue
-import tkinter as tk
 import customtkinter
 from customtkinter import CTk, CTkFrame, CTkCheckBox, CTkFont, CTkButton, CTkImage, CTkTabview, CTkTextbox, CTkEntry
 from PIL.Image import open as Image_open
@@ -15,11 +12,12 @@ from utils import print_textbox, thread_fnc, get_localized_text, widget_main_win
 from osc_tools import send_typing, send_message, send_test_action, receive_osc_parameters
 from window_config import ToplevelWindowConfig
 from window_information import ToplevelWindowInformation
-from languages import transcription_lang, translators, translation_lang, selectable_languages
-from audio_utils import get_input_device_list, get_output_device_list, get_default_input_device, get_default_output_device
+from languages import transcription_lang
+from audio_utils import get_input_device_list, get_output_device_list
 from audio_recorder import SelectedMicRecorder, SelectedSpeakerRecorder
 from audio_transcriber import AudioTranscriber
 from translation import Translator
+from config import config
 from notification import notification_xsoverlay_for_vrct
 
 __version__ = "1.3.2"
@@ -32,238 +30,14 @@ class App(CTk):
         self.translator = Translator()
         self.keyword_processor = KeywordProcessor()
 
-        # init config
-        self.PATH_CONFIG = "./config.json"
-
-        ## main window
-        # self.ENABLE_TRANSLATION = False
-        # self.ENABLE_TRANSCRIPTION_SEND = False
-        # self.ENABLE_TRANSCRIPTION_RECEIVE = False
-        # self.ENABLE_FOREGROUND = False
-
-        ## UI
-        self.TRANSPARENCY = 100
-        self.APPEARANCE_THEME = "System"
-        self.UI_SCALING = "100%"
-        self.FONT_FAMILY = "Yu Gothic UI"
-        self.UI_LANGUAGE = "en"
-        ## Translation
-        self.CHOICE_TRANSLATOR = translators[0]
-        self.INPUT_SOURCE_LANG = list(translation_lang[self.CHOICE_TRANSLATOR]["source"].keys())[0]
-        self.INPUT_TARGET_LANG = list(translation_lang[self.CHOICE_TRANSLATOR]["target"].keys())[1]
-        self.OUTPUT_SOURCE_LANG = list(translation_lang[self.CHOICE_TRANSLATOR]["source"].keys())[1]
-        self.OUTPUT_TARGET_LANG = list(translation_lang[self.CHOICE_TRANSLATOR]["target"].keys())[0]
-        ## Transcription Send
-        self.CHOICE_MIC_HOST = get_default_input_device()["host"]["name"]
-        self.CHOICE_MIC_DEVICE = get_default_input_device()["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
-        self.INPUT_MIC_PHRASE_TIMEOUT = 3
-        self.INPUT_MIC_MAX_PHRASES = 10
-        self.INPUT_MIC_WORD_FILTER = []
-        ## Transcription Receive
-        self.CHOICE_SPEAKER_DEVICE = get_default_output_device()["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
-        self.INPUT_SPEAKER_PHRASE_TIMEOUT = 3
-        self.INPUT_SPEAKER_MAX_PHRASES = 10
-
-        ## Parameter
-        self.OSC_IP_ADDRESS = "127.0.0.1"
-        self.OSC_PORT = 9000
-        self.AUTH_KEYS = {
-            "DeepL(web)": None,
-            "DeepL(auth)": None,
-            "Bing(web)": None,
-            "Google(web)": None,
-        }
-        self.MESSAGE_FORMAT = "[message]([translation])"
-        # Others
-        self.ENABLE_AUTO_CLEAR_CHATBOX = False
-        self.ENABLE_OSC = False
-        self.ENABLE_NOTICE_XSOVERLAY =False
-        self.UPDATE_FLAG = False
-
-        # load config
-        if os_path.isfile(self.PATH_CONFIG) is not False:
-            with open(self.PATH_CONFIG, 'r') as fp:
-                config = json_load(fp)
-            # main window
-            # main windowは初期はすべてOFFにする
-            # if "ENABLE_TRANSLATION" in config.keys():
-            #     if type(config["ENABLE_TRANSLATION"]) is bool:
-            #         self.ENABLE_TRANSLATION = config["ENABLE_TRANSLATION"]
-
-            # 環境に依ってマイクとスピーカーを同時起動するとエラーが発生するため、起動時は強制的にOFFにする
-            # if "ENABLE_TRANSCRIPTION_SEND" in config.keys():
-            #     if type(config["ENABLE_TRANSCRIPTION_SEND"]) is bool:
-            #         self.ENABLE_TRANSCRIPTION_SEND = config["ENABLE_TRANSCRIPTION_SEND"]
-            # if "ENABLE_TRANSCRIPTION_RECEIVE" in config.keys():
-            #     if type(config["ENABLE_TRANSCRIPTION_RECEIVE"]) is bool:
-            #         self.ENABLE_TRANSCRIPTION_RECEIVE = config["ENABLE_TRANSCRIPTION_RECEIVE"]
-
-            # if "ENABLE_FOREGROUND" in config.keys():
-            #     if type(config["ENABLE_FOREGROUND"]) is bool:
-            #         self.ENABLE_FOREGROUND = config["ENABLE_FOREGROUND"]
-
-            # tab ui
-            if "TRANSPARENCY" in config.keys():
-                if type(config["TRANSPARENCY"]) is int:
-                    if 0 <= config["TRANSPARENCY"] <= 100:
-                        self.TRANSPARENCY = config["TRANSPARENCY"]
-            if "APPEARANCE_THEME" in config.keys():
-                if config["APPEARANCE_THEME"] in ["Light", "Dark", "System"]:
-                    self.APPEARANCE_THEME = config["APPEARANCE_THEME"]
-            if "UI_SCALING" in config.keys():
-                if config["UI_SCALING"] in ["80%", "90%", "100%", "110%", "120%"]:
-                    self.UI_SCALING = config["UI_SCALING"]
-            if "FONT_FAMILY" in config.keys():
-                if config["FONT_FAMILY"] in list(tk.font.families()):
-                    self.FONT_FAMILY = config["FONT_FAMILY"]
-            if "UI_LANGUAGE" in config.keys():
-                if config["UI_LANGUAGE"] in list(selectable_languages.keys()):
-                    self.UI_LANGUAGE = config["UI_LANGUAGE"]
-
-            # translation
-            if "CHOICE_TRANSLATOR" in config.keys():
-                if config["CHOICE_TRANSLATOR"] in list(self.translator.translator_status.keys()):
-                    self.CHOICE_TRANSLATOR = config["CHOICE_TRANSLATOR"]
-            if "INPUT_SOURCE_LANG" in config.keys():
-                if config["INPUT_SOURCE_LANG"] in list(translation_lang[self.CHOICE_TRANSLATOR]["source"].keys()):
-                    self.INPUT_SOURCE_LANG = config["INPUT_SOURCE_LANG"]
-            if "INPUT_TARGET_LANG" in config.keys():
-                if config["INPUT_TARGET_LANG"] in list(translation_lang[self.CHOICE_TRANSLATOR]["target"].keys()):
-                    self.INPUT_TARGET_LANG = config["INPUT_TARGET_LANG"]
-            if "OUTPUT_SOURCE_LANG" in config.keys():
-                if config["OUTPUT_SOURCE_LANG"] in list(translation_lang[self.CHOICE_TRANSLATOR]["source"].keys()):
-                    self.OUTPUT_SOURCE_LANG = config["OUTPUT_SOURCE_LANG"]
-            if "OUTPUT_TARGET_LANG" in config.keys():
-                if config["OUTPUT_TARGET_LANG"] in list(translation_lang[self.CHOICE_TRANSLATOR]["target"].keys()):
-                    self.OUTPUT_TARGET_LANG = config["OUTPUT_TARGET_LANG"]
-
-            # Transcription
-            if "CHOICE_MIC_HOST" in config.keys():
-                if config["CHOICE_MIC_HOST"] in [host for host in get_input_device_list().keys()]:
-                    self.CHOICE_MIC_HOST = config["CHOICE_MIC_HOST"]
-            if "CHOICE_MIC_DEVICE" in config.keys():
-                if config["CHOICE_MIC_DEVICE"] in [device["name"] for device in get_input_device_list()[self.CHOICE_MIC_HOST]]:
-                    self.CHOICE_MIC_DEVICE = config["CHOICE_MIC_DEVICE"]
-            if "INPUT_MIC_VOICE_LANGUAGE" in config.keys():
-                if config["INPUT_MIC_VOICE_LANGUAGE"] in list(transcription_lang.keys()):
-                    self.INPUT_MIC_VOICE_LANGUAGE = config["INPUT_MIC_VOICE_LANGUAGE"]
-            if "INPUT_MIC_ENERGY_THRESHOLD" in config.keys():
-                if type(config["INPUT_MIC_ENERGY_THRESHOLD"]) is int:
-                    self.INPUT_MIC_ENERGY_THRESHOLD = config["INPUT_MIC_ENERGY_THRESHOLD"]
-            if "INPUT_MIC_DYNAMIC_ENERGY_THRESHOLD" in config.keys():
-                if type(config["INPUT_MIC_DYNAMIC_ENERGY_THRESHOLD"]) is bool:
-                    self.INPUT_MIC_DYNAMIC_ENERGY_THRESHOLD = config["INPUT_MIC_DYNAMIC_ENERGY_THRESHOLD"]
-            if "INPUT_MIC_RECORD_TIMEOUT" in config.keys():
-                if type(config["INPUT_MIC_RECORD_TIMEOUT"]) is int:
-                    self.INPUT_MIC_RECORD_TIMEOUT = config["INPUT_MIC_RECORD_TIMEOUT"]
-            if "INPUT_MIC_PHRASE_TIMEOUT" in config.keys():
-                if type(config["INPUT_MIC_PHRASE_TIMEOUT"]) is int:
-                    self.INPUT_MIC_PHRASE_TIMEOUT = config["INPUT_MIC_PHRASE_TIMEOUT"]
-            if "INPUT_MIC_MAX_PHRASES" in config.keys():
-                if type(config["INPUT_MIC_MAX_PHRASES"]) is int:
-                    self.INPUT_MIC_MAX_PHRASES = config["INPUT_MIC_MAX_PHRASES"]
-            if "INPUT_MIC_WORD_FILTER" in config.keys():
-                if type(config["INPUT_MIC_WORD_FILTER"]) is list:
-                    self.INPUT_MIC_WORD_FILTER = config["INPUT_MIC_WORD_FILTER"]
-
-            if "CHOICE_SPEAKER_DEVICE" in config.keys():
-                if config["CHOICE_SPEAKER_DEVICE"] in [device["name"] for device in get_output_device_list()]:
-                    speaker_device = [device for device in get_output_device_list() if device["name"] == config["CHOICE_SPEAKER_DEVICE"]][0]
-                    if get_default_output_device()["index"] == speaker_device["index"]:
-                        self.CHOICE_SPEAKER_DEVICE = config["CHOICE_SPEAKER_DEVICE"]
-            if "INPUT_SPEAKER_VOICE_LANGUAGE" in config.keys():
-                if config["INPUT_SPEAKER_VOICE_LANGUAGE"] in list(transcription_lang.keys()):
-                    self.INPUT_SPEAKER_VOICE_LANGUAGE = config["INPUT_SPEAKER_VOICE_LANGUAGE"]
-            if "INPUT_SPEAKER_ENERGY_THRESHOLD" in config.keys():
-                if type(config["INPUT_SPEAKER_ENERGY_THRESHOLD"]) is int:
-                    self.INPUT_SPEAKER_ENERGY_THRESHOLD = config["INPUT_SPEAKER_ENERGY_THRESHOLD"]
-            if "INPUT_SPEAKER_DYNAMIC_ENERGY_THRESHOLD" in config.keys():
-                if type(config["INPUT_SPEAKER_DYNAMIC_ENERGY_THRESHOLD"]) is bool:
-                    self.INPUT_SPEAKER_DYNAMIC_ENERGY_THRESHOLD = config["INPUT_SPEAKER_DYNAMIC_ENERGY_THRESHOLD"]
-            if "INPUT_SPEAKER_RECORD_TIMEOUT" in config.keys():
-                if type(config["INPUT_SPEAKER_RECORD_TIMEOUT"]) is int:
-                    self.INPUT_SPEAKER_RECORD_TIMEOUT = config["INPUT_SPEAKER_RECORD_TIMEOUT"]
-            if "INPUT_SPEAKER_PHRASE_TIMEOUT" in config.keys():
-                if type(config["INPUT_SPEAKER_PHRASE_TIMEOUT"]) is int:
-                    self.INPUT_SPEAKER_PHRASE_TIMEOUT = config["INPUT_SPEAKER_PHRASE_TIMEOUT"]
-            if "INPUT_SPEAKER_MAX_PHRASES" in config.keys():
-                if type(config["INPUT_SPEAKER_MAX_PHRASES"]) is int:
-                    self.INPUT_MIC_MAX_PHRASES = config["INPUT_SPEAKER_MAX_PHRASES"]
-
-            # Parameter
-            if "OSC_IP_ADDRESS" in config.keys():
-                if type(config["OSC_IP_ADDRESS"]) is str:
-                    self.OSC_IP_ADDRESS = config["OSC_IP_ADDRESS"]
-            if "OSC_PORT" in config.keys():
-                if type(config["OSC_PORT"]) is int:
-                    self.OSC_PORT = config["OSC_PORT"]
-            if "AUTH_KEYS" in config.keys():
-                if type(config["AUTH_KEYS"]) is dict:
-                    if set(config["AUTH_KEYS"].keys()) == set(self.AUTH_KEYS.keys()):
-                        for key, value in config["AUTH_KEYS"].items():
-                            if type(value) is str:
-                                self.AUTH_KEYS[key] = config["AUTH_KEYS"][key]
-            if "MESSAGE_FORMAT" in config.keys():
-                if type(config["MESSAGE_FORMAT"]) is str:
-                    self.MESSAGE_FORMAT = config["MESSAGE_FORMAT"]
-
-            # Others
-            if "ENABLE_AUTO_CLEAR_CHATBOX" in config.keys():
-                if type(config["ENABLE_AUTO_CLEAR_CHATBOX"]) is bool:
-                    self.ENABLE_AUTO_CLEAR_CHATBOX = config["ENABLE_AUTO_CLEAR_CHATBOX"]
-            if "ENABLE_NOTICE_XSOVERLAY" in config.keys():
-                if type(config["ENABLE_NOTICE_XSOVERLAY"]) is bool:
-                    self.ENABLE_NOTICE_XSOVERLAY = config["ENABLE_NOTICE_XSOVERLAY"]
-
-        with open(self.PATH_CONFIG, 'w') as fp:
-            config = {
-                "TRANSPARENCY": self.TRANSPARENCY,
-                "APPEARANCE_THEME": self.APPEARANCE_THEME,
-                "UI_SCALING": self.UI_SCALING,
-                "UI_LANGUAGE": self.UI_LANGUAGE,
-                "FONT_FAMILY": self.FONT_FAMILY,
-                "CHOICE_TRANSLATOR": self.CHOICE_TRANSLATOR,
-                "INPUT_SOURCE_LANG": self.INPUT_SOURCE_LANG,
-                "INPUT_TARGET_LANG": self.INPUT_TARGET_LANG,
-                "OUTPUT_SOURCE_LANG": self.OUTPUT_SOURCE_LANG,
-                "OUTPUT_TARGET_LANG": self.OUTPUT_TARGET_LANG,
-                "CHOICE_MIC_HOST": self.CHOICE_MIC_HOST,
-                "CHOICE_MIC_DEVICE": self.CHOICE_MIC_DEVICE,
-                "INPUT_MIC_VOICE_LANGUAGE": self.INPUT_MIC_VOICE_LANGUAGE,
-                "INPUT_MIC_ENERGY_THRESHOLD": self.INPUT_MIC_ENERGY_THRESHOLD,
-                "INPUT_MIC_DYNAMIC_ENERGY_THRESHOLD": self.INPUT_MIC_DYNAMIC_ENERGY_THRESHOLD,
-                "INPUT_MIC_RECORD_TIMEOUT": self.INPUT_MIC_RECORD_TIMEOUT,
-                "INPUT_MIC_PHRASE_TIMEOUT": self.INPUT_MIC_PHRASE_TIMEOUT,
-                "INPUT_MIC_MAX_PHRASES": self.INPUT_MIC_MAX_PHRASES,
-                "INPUT_MIC_WORD_FILTER": self.INPUT_MIC_WORD_FILTER,
-                "CHOICE_SPEAKER_DEVICE": self.CHOICE_SPEAKER_DEVICE,
-                "INPUT_SPEAKER_VOICE_LANGUAGE": self.INPUT_SPEAKER_VOICE_LANGUAGE,
-                "INPUT_SPEAKER_ENERGY_THRESHOLD": self.INPUT_SPEAKER_ENERGY_THRESHOLD,
-                "INPUT_SPEAKER_DYNAMIC_ENERGY_THRESHOLD": self.INPUT_SPEAKER_DYNAMIC_ENERGY_THRESHOLD,
-                "INPUT_SPEAKER_RECORD_TIMEOUT": self.INPUT_SPEAKER_RECORD_TIMEOUT,
-                "INPUT_SPEAKER_PHRASE_TIMEOUT": self.INPUT_SPEAKER_PHRASE_TIMEOUT,
-                "INPUT_SPEAKER_MAX_PHRASES": self.INPUT_SPEAKER_MAX_PHRASES,
-                "OSC_IP_ADDRESS": self.OSC_IP_ADDRESS,
-                "OSC_PORT": self.OSC_PORT,
-                "AUTH_KEYS": self.AUTH_KEYS,
-                "MESSAGE_FORMAT": self.MESSAGE_FORMAT,
-                "ENABLE_AUTO_CLEAR_CHATBOX": self.ENABLE_AUTO_CLEAR_CHATBOX,
-                "ENABLE_NOTICE_XSOVERLAY": self.ENABLE_NOTICE_XSOVERLAY,
-            }
-            json_dump(config, fp, indent=4)
-
         ## set UI theme
-        customtkinter.set_appearance_mode(self.APPEARANCE_THEME)
+        customtkinter.set_appearance_mode(config.APPEARANCE_THEME)
         customtkinter.set_default_color_theme("blue")
 
+        ## flags
+        self.ENABLE_OSC = False
+        self.UPDATE_FLAG = False
+
         # init main window
         self.iconbitmap(os_path.join(os_path.dirname(__file__), "img", "app.ico"))
         self.title("VRCT")
@@ -286,7 +60,7 @@ class App(CTk):
             onvalue=True,
             offvalue=False,
             command=self.checkbox_translation_callback,
-            font=CTkFont(family=self.FONT_FAMILY)
+            font=CTkFont(family=config.FONT_FAMILY)
         )
         self.checkbox_translation.grid(row=0, column=0, columnspan=2, padx=10, pady=(5, 5), sticky="we")
 
@@ -297,7 +71,7 @@ class App(CTk):
             onvalue=True,
             offvalue=False,
             command=self.checkbox_transcription_send_callback,
-            font=CTkFont(family=self.FONT_FAMILY)
+            font=CTkFont(family=config.FONT_FAMILY)
         )
         self.checkbox_transcription_send.grid(row=1, column=0, columnspan=2, padx=10, pady=(5, 5), sticky="we")
 
@@ -308,7 +82,7 @@ class App(CTk):
             onvalue=True,
             offvalue=False,
             command=self.checkbox_transcription_receive_callback,
-            font=CTkFont(family=self.FONT_FAMILY)
+            font=CTkFont(family=config.FONT_FAMILY)
         )
         self.checkbox_transcription_receive.grid(row=2, column=0, columnspan=2, padx=10, pady=(5, 5), sticky="we")
 
@@ -319,7 +93,7 @@ class App(CTk):
             onvalue=True,
             offvalue=False,
             command=self.checkbox_foreground_callback,
-            font=CTkFont(family=self.FONT_FAMILY)
+            font=CTkFont(family=config.FONT_FAMILY)
         )
         self.checkbox_foreground.grid(row=3, column=0, columnspan=2, padx=10, pady=(5, 5), sticky="we")
 
@@ -344,7 +118,7 @@ class App(CTk):
         self.button_config.grid(row=5, column=1, padx=(5, 10), pady=(5, 5), sticky="wse")
 
         # load ui language data
-        language_yaml_data = get_localized_text(f"{self.UI_LANGUAGE}")
+        language_yaml_data = get_localized_text(f"{config.UI_LANGUAGE}")
         # add tabview textbox
         self.add_tabview_logs(language_yaml_data)
 
@@ -352,13 +126,13 @@ class App(CTk):
         self.entry_message_box = CTkEntry(
             self,
             placeholder_text="message",
-            font=CTkFont(family=self.FONT_FAMILY),
+            font=CTkFont(family=config.FONT_FAMILY),
         )
         self.entry_message_box.grid(row=1, column=1, columnspan=2, padx=5, pady=(5, 10), sticky="nsew")
 
         # set default values
         ## set translator
-        if self.translator.authentication(self.CHOICE_TRANSLATOR, self.AUTH_KEYS[self.CHOICE_TRANSLATOR]) is False:
+        if self.translator.authentication(config.CHOICE_TRANSLATOR, config.AUTH_KEYS[config.CHOICE_TRANSLATOR]) is False:
             # error update Auth key
             print_textbox(self.textbox_message_log, "Auth Key or language setting is incorrect", "ERROR")
             print_textbox(self.textbox_message_system_log, "Auth Key or language setting is incorrect", "ERROR")
@@ -392,7 +166,7 @@ class App(CTk):
         #     self.checkbox_foreground.deselect()
 
         ## set word filter
-        for f in self.INPUT_MIC_WORD_FILTER:
+        for f in config.INPUT_MIC_WORD_FILTER:
             self.keyword_processor.add_keyword(f)
 
         ## set bind entry message box
@@ -401,10 +175,10 @@ class App(CTk):
         self.entry_message_box.bind("<Leave>", self.entry_message_box_leave)
 
         ## set transparency for main window
-        self.wm_attributes("-alpha", self.TRANSPARENCY/100)
+        self.wm_attributes("-alpha", config.TRANSPARENCY/100)
 
         ## set UI scale
-        new_scaling_float = int(self.UI_SCALING.replace("%", "")) / 100
+        new_scaling_float = int(config.UI_SCALING.replace("%", "")) / 100
         customtkinter.set_widget_scaling(new_scaling_float)
 
         # delete window
@@ -462,22 +236,22 @@ class App(CTk):
 
     def transcription_send_start(self):
         self.mic_audio_queue = Queue()
-        mic_device = [device for device in get_input_device_list()[self.CHOICE_MIC_HOST] if device["name"] == self.CHOICE_MIC_DEVICE][0]
+        mic_device = [device for device in get_input_device_list()[config.CHOICE_MIC_HOST] if device["name"] == config.CHOICE_MIC_DEVICE][0]
         self.mic_audio_recorder = SelectedMicRecorder(
             mic_device,
-            self.INPUT_MIC_ENERGY_THRESHOLD,
-            self.INPUT_MIC_DYNAMIC_ENERGY_THRESHOLD,
-            self.INPUT_MIC_RECORD_TIMEOUT,
+            config.INPUT_MIC_ENERGY_THRESHOLD,
+            config.INPUT_MIC_DYNAMIC_ENERGY_THRESHOLD,
+            config.INPUT_MIC_RECORD_TIMEOUT,
         )
         self.mic_audio_recorder.record_into_queue(self.mic_audio_queue)
         self.mic_transcriber = AudioTranscriber(
             speaker=False,
             source=self.mic_audio_recorder.source,
-            phrase_timeout=self.INPUT_MIC_PHRASE_TIMEOUT,
-            max_phrases=self.INPUT_MIC_MAX_PHRASES,
+            phrase_timeout=config.INPUT_MIC_PHRASE_TIMEOUT,
+            max_phrases=config.INPUT_MIC_MAX_PHRASES,
         )
         def mic_transcript_to_chatbox():
-            self.mic_transcriber.transcribe_audio_queue(self.mic_audio_queue, transcription_lang[self.INPUT_MIC_VOICE_LANGUAGE])
+            self.mic_transcriber.transcribe_audio_queue(self.mic_audio_queue, transcription_lang[config.INPUT_MIC_VOICE_LANGUAGE])
             message = self.mic_transcriber.get_transcript()
             if len(message) > 0:
                 # word filter
@@ -489,23 +263,23 @@ class App(CTk):
                 # translate
                 if self.checkbox_translation.get() is False:
                     voice_message = f"{message}"
-                elif self.translator.translator_status[self.CHOICE_TRANSLATOR] is False:
+                elif self.translator.translator_status[config.CHOICE_TRANSLATOR] is False:
                     print_textbox(self.textbox_message_log,  "Auth Key or language setting is incorrect", "ERROR")
                     print_textbox(self.textbox_message_system_log, "Auth Key or language setting is incorrect", "ERROR")
                     voice_message = f"{message}"
                 else:
                     result = self.translator.translate(
-                        translator_name=self.CHOICE_TRANSLATOR,
-                        source_language=self.INPUT_SOURCE_LANG,
-                        target_language=self.INPUT_TARGET_LANG,
+                        translator_name=config.CHOICE_TRANSLATOR,
+                        source_language=config.INPUT_SOURCE_LANG,
+                        target_language=config.INPUT_TARGET_LANG,
                         message=message
                     )
-                    voice_message = self.MESSAGE_FORMAT.replace("[message]", message).replace("[translation]", result)
+                    voice_message = config.MESSAGE_FORMAT.replace("[message]", message).replace("[translation]", result)
 
                 if self.checkbox_transcription_send.get() is True:
                     if self.ENABLE_OSC is True:
                         # send OSC message
-                        send_message(voice_message, self.OSC_IP_ADDRESS, self.OSC_PORT)
+                        send_message(voice_message, config.OSC_IP_ADDRESS, config.OSC_PORT)
                     else:
                         print_textbox(self.textbox_message_log, "OSC is not enabled, please enable OSC and rejoin.", "ERROR")
                         print_textbox(self.textbox_message_system_log, "OSC is not enabled, please enable OSC and rejoin.", "ERROR")
@@ -560,48 +334,48 @@ class App(CTk):
 
     def transcription_receive_start(self):
         self.spk_audio_queue = Queue()
-        spk_device = [device for device in get_output_device_list() if device["name"] == self.CHOICE_SPEAKER_DEVICE][0]
+        spk_device = [device for device in get_output_device_list() if device["name"] == config.CHOICE_SPEAKER_DEVICE][0]
         self.spk_audio_recorder = SelectedSpeakerRecorder(
             spk_device,
-            self.INPUT_SPEAKER_ENERGY_THRESHOLD,
-            self.INPUT_SPEAKER_DYNAMIC_ENERGY_THRESHOLD,
-            self.INPUT_SPEAKER_RECORD_TIMEOUT,
+            config.INPUT_SPEAKER_ENERGY_THRESHOLD,
+            config.INPUT_SPEAKER_DYNAMIC_ENERGY_THRESHOLD,
+            config.INPUT_SPEAKER_RECORD_TIMEOUT,
         )
         self.spk_audio_recorder.record_into_queue(self.spk_audio_queue)
         self.spk_transcriber = AudioTranscriber(
             speaker=True,
             source=self.spk_audio_recorder.source,
-            phrase_timeout=self.INPUT_SPEAKER_PHRASE_TIMEOUT,
-            max_phrases=self.INPUT_SPEAKER_MAX_PHRASES,
+            phrase_timeout=config.INPUT_SPEAKER_PHRASE_TIMEOUT,
+            max_phrases=config.INPUT_SPEAKER_MAX_PHRASES,
         )
 
         def spk_transcript_to_textbox():
-            self.spk_transcriber.transcribe_audio_queue(self.spk_audio_queue, transcription_lang[self.INPUT_SPEAKER_VOICE_LANGUAGE])
+            self.spk_transcriber.transcribe_audio_queue(self.spk_audio_queue, transcription_lang[config.INPUT_SPEAKER_VOICE_LANGUAGE])
             message = self.spk_transcriber.get_transcript()
             if len(message) > 0:
                 # translate
                 if self.checkbox_translation.get() is False:
                     voice_message = f"{message}"
-                elif self.translator.translator_status[self.CHOICE_TRANSLATOR] is False:
+                elif self.translator.translator_status[config.CHOICE_TRANSLATOR] is False:
                     print_textbox(self.textbox_message_log, "Auth Key or language setting is incorrect", "ERROR")
                     print_textbox(self.textbox_message_system_log, "Auth Key or language setting is incorrect", "ERROR")
                     voice_message = f"{message}"
                 else:
                     result = self.translator.translate(
-                        translator_name=self.CHOICE_TRANSLATOR,
-                        source_language=self.OUTPUT_SOURCE_LANG,
-                        target_language=self.OUTPUT_TARGET_LANG,
+                        translator_name=config.CHOICE_TRANSLATOR,
+                        source_language=config.OUTPUT_SOURCE_LANG,
+                        target_language=config.OUTPUT_TARGET_LANG,
                         message=message
                     )
-                    voice_message = self.MESSAGE_FORMAT.replace("[message]", message).replace("[translation]", result)
+                    voice_message = config.MESSAGE_FORMAT.replace("[message]", message).replace("[translation]", result)
                 # send OSC message
-                # send_message(voice_message, self.OSC_IP_ADDRESS, self.OSC_PORT)
+                # send_message(voice_message, config.OSC_IP_ADDRESS, self.OSC_PORT)
 
                 if self.checkbox_transcription_receive.get() is True:
                     # update textbox message receive log
                     print_textbox(self.textbox_message_log,  f"{voice_message}", "RECEIVE")
                     print_textbox(self.textbox_message_receive_log, f"{voice_message}", "RECEIVE")
-                    if self.ENABLE_NOTICE_XSOVERLAY is True:
+                    if config.ENABLE_NOTICE_XSOVERLAY is True:
                         notification_xsoverlay_for_vrct(content=f"{voice_message}")
 
         self.spk_print_transcript = thread_fnc(spk_transcript_to_textbox)
@@ -694,7 +468,7 @@ class App(CTk):
 
     def entry_message_box_press_key_enter(self, event):
         # send OSC typing
-        send_typing(False, self.OSC_IP_ADDRESS, self.OSC_PORT)
+        send_typing(False, config.OSC_IP_ADDRESS, config.OSC_PORT)
 
         if self.checkbox_foreground.get():
             self.attributes("-topmost", True)
@@ -704,22 +478,22 @@ class App(CTk):
             # translate
             if self.checkbox_translation.get() is False:
                 chat_message = f"{message}"
-            elif self.translator.translator_status[self.CHOICE_TRANSLATOR] is False:
+            elif self.translator.translator_status[config.CHOICE_TRANSLATOR] is False:
                 print_textbox(self.textbox_message_log,  "Auth Key or language setting is incorrect", "ERROR")
                 print_textbox(self.textbox_message_system_log, "Auth Key or language setting is incorrect", "ERROR")
                 chat_message = f"{message}"
             else:
                 result = self.translator.translate(
-                    translator_name=self.CHOICE_TRANSLATOR,
-                    source_language=self.INPUT_SOURCE_LANG,
-                    target_language=self.INPUT_TARGET_LANG,
+                    translator_name=config.CHOICE_TRANSLATOR,
+                    source_language=config.INPUT_SOURCE_LANG,
+                    target_language=config.INPUT_TARGET_LANG,
                     message=message
                 )
-                chat_message = self.MESSAGE_FORMAT.replace("[message]", message).replace("[translation]", result)
+                chat_message = config.MESSAGE_FORMAT.replace("[message]", message).replace("[translation]", result)
 
             # send OSC message
             if self.ENABLE_OSC is True:
-                send_message(chat_message, self.OSC_IP_ADDRESS, self.OSC_PORT)
+                send_message(chat_message, config.OSC_IP_ADDRESS, config.OSC_PORT)
             else:
                 print_textbox(self.textbox_message_log, "OSC is not enabled, please enable OSC and rejoin.", "ERROR")
                 print_textbox(self.textbox_message_system_log, "OSC is not enabled, please enable OSC and rejoin.", "ERROR")
@@ -729,7 +503,7 @@ class App(CTk):
             print_textbox(self.textbox_message_send_log, f"{chat_message}", "SEND")
 
             # delete message in entry message box
-            if self.ENABLE_AUTO_CLEAR_CHATBOX is True:
+            if config.ENABLE_AUTO_CLEAR_CHATBOX is True:
                 self.entry_message_box.delete(0, customtkinter.END)
 
     BREAK_KEYSYM_LIST = [
@@ -738,7 +512,7 @@ class App(CTk):
     ]
     def entry_message_box_press_key_any(self, event):
         # send OSC typing
-        send_typing(True, self.OSC_IP_ADDRESS, self.OSC_PORT)
+        send_typing(True, config.OSC_IP_ADDRESS, config.OSC_PORT)
         if self.checkbox_foreground.get():
             self.attributes("-topmost", False)
 
@@ -749,7 +523,7 @@ class App(CTk):
 
     def entry_message_box_leave(self, event):
         # send OSC typing
-        send_typing(False, self.OSC_IP_ADDRESS, self.OSC_PORT)
+        send_typing(False, config.OSC_IP_ADDRESS, config.OSC_PORT)
         if self.checkbox_foreground.get():
             self.attributes("-topmost", True)
 
@@ -776,7 +550,7 @@ class App(CTk):
         self.tabview_logs.add(main_tab_title_receive)
         self.tabview_logs.add(main_tab_title_system)
         self.tabview_logs.grid(row=0, column=1, padx=0, pady=0, sticky="nsew")
-        self.tabview_logs._segmented_button.configure(font=CTkFont(family=self.FONT_FAMILY))
+        self.tabview_logs._segmented_button.configure(font=CTkFont(family=config.FONT_FAMILY))
         self.tabview_logs._segmented_button.grid(sticky="W")
         self.tabview_logs.tab(main_tab_title_log).grid_rowconfigure(0, weight=1)
         self.tabview_logs.tab(main_tab_title_log).grid_columnconfigure(0, weight=1)
@@ -791,7 +565,7 @@ class App(CTk):
         # add textbox message log
         self.textbox_message_log = CTkTextbox(
             self.tabview_logs.tab(main_tab_title_log),
-            font=CTkFont(family=self.FONT_FAMILY)
+            font=CTkFont(family=config.FONT_FAMILY)
         )
         self.textbox_message_log.grid(row=0, column=0, padx=0, pady=0, sticky="nsew")
         self.textbox_message_log.configure(state='disabled')
@@ -799,7 +573,7 @@ class App(CTk):
         # add textbox message send log
         self.textbox_message_send_log = CTkTextbox(
             self.tabview_logs.tab(main_tab_title_send),
-            font=CTkFont(family=self.FONT_FAMILY)
+            font=CTkFont(family=config.FONT_FAMILY)
         )
         self.textbox_message_send_log.grid(row=0, column=0, padx=0, pady=0, sticky="nsew")
         self.textbox_message_send_log.configure(state='disabled')
@@ -807,7 +581,7 @@ class App(CTk):
         # add textbox message receive log
         self.textbox_message_receive_log = CTkTextbox(
             self.tabview_logs.tab(main_tab_title_receive),
-            font=CTkFont(family=self.FONT_FAMILY)
+            font=CTkFont(family=config.FONT_FAMILY)
         )
         self.textbox_message_receive_log.grid(row=0, column=0, padx=0, pady=0, sticky="nsew")
         self.textbox_message_receive_log.configure(state='disabled')
@@ -815,7 +589,7 @@ class App(CTk):
         # add textbox message system log
         self.textbox_message_system_log = CTkTextbox(
             self.tabview_logs.tab(main_tab_title_system),
-            font=CTkFont(family=self.FONT_FAMILY)
+            font=CTkFont(family=config.FONT_FAMILY)
         )
         self.textbox_message_system_log.grid(row=0, column=0, padx=0, pady=0, sticky="nsew")
         self.textbox_message_system_log.configure(state='disabled')

config.py

@@ -339,16 +339,6 @@ class Config:
             self._ENABLE_AUTO_CLEAR_CHATBOX = value
             save_json(self.PATH_CONFIG, inspect.currentframe().f_code.co_name, value)
 
-    @property
-    def ENABLE_OSC(self):
-        return self._ENABLE_OSC
-
-    @ENABLE_OSC.setter
-    def ENABLE_OSC(self, value):
-        if type(value) is bool:
-            self._ENABLE_OSC = value
-            save_json(self.PATH_CONFIG, inspect.currentframe().f_code.co_name, value)
-
     @property
     def ENABLE_NOTICE_XSOVERLAY(self):
         return self._ENABLE_NOTICE_XSOVERLAY
@@ -359,16 +349,6 @@ class Config:
             self._ENABLE_NOTICE_XSOVERLAY = value
             save_json(self.PATH_CONFIG, inspect.currentframe().f_code.co_name, value)
 
-    @property
-    def UPDATE_FLAG(self):
-        return self._UPDATE_FLAG
-
-    @UPDATE_FLAG.setter
-    def UPDATE_FLAG(self, value):
-        if type(value) is bool:
-            self._UPDATE_FLAG = value
-            save_json(self.PATH_CONFIG, inspect.currentframe().f_code.co_name, value)
-
     def init_config(self):
         self._PATH_CONFIG = "./config.json"
         self._TRANSPARENCY = 100
@@ -407,9 +387,7 @@ class Config:
         }
         self._MESSAGE_FORMAT = "[message]([translation])"
         self._ENABLE_AUTO_CLEAR_CHATBOX = False
-        self._ENABLE_OSC = False
         self._ENABLE_NOTICE_XSOVERLAY = False
-        self._UPDATE_FLAG = False
 
     def load_config(self):
         if os_path.isfile(self.PATH_CONFIG) is not False:
@@ -429,5 +407,4 @@ class Config:
                 config[method] = getattr(self, method)
             json_dump(config, fp, indent=4)
 
-if __name__ == "__main__":
-    instance = Config()
+config = Config()

window_information.py

@@ -1,5 +1,6 @@
 import os
 from customtkinter import CTkToplevel, CTkTextbox, CTkFont
+from config import config
 
 class ToplevelWindowInformation(CTkToplevel):
     def __init__(self, parent, *args, **kwargs):
@@ -16,7 +17,7 @@ class ToplevelWindowInformation(CTkToplevel):
         # create textbox information
         self.textbox_information = CTkTextbox(
             self,
-            font=CTkFont(family=self.parent.FONT_FAMILY)
+            font=CTkFont(family=config.FONT_FAMILY)
         )
         self.textbox_information.grid(row=0, column=0, padx=(10, 10), pady=(10, 10), sticky="nsew")
         textbox_information_message = """VRCT(v1.3.2)