GameSentenceMiner 2.8.54__py3-none-any.whl → 2.9.1__py3-none-any.whl

GameSentenceMiner/anki.py

@@ -75,7 +75,7 @@ def update_anki_card(last_note: AnkiCard, note=None, audio_path='', video_path='
         logger.info(f"AI prompt Result: {translation}")
         note['fields'][get_config().ai.anki_field] = translation
 
-    if prev_screenshot_in_anki:
+    if prev_screenshot_in_anki and get_config().anki.previous_image_field != get_config().anki.picture_field:
         note['fields'][get_config().anki.previous_image_field] = prev_screenshot_html
 
     if get_config().anki.anki_custom_fields:

GameSentenceMiner/communication/websocket.py

@@ -21,6 +21,13 @@ class FunctionName(Enum):
     STOP = "stop"
     QUIT_OBS = "quit_obs"
     START_OBS = "start_obs"
+    OPEN_SETTINGS = "open_settings"
+    OPEN_TEXTHOOKER = "open_texthooker"
+    OPEN_LOG = "open_log"
+    TOGGLE_REPLAY_BUFFER = "toggle_replay_buffer"
+    RESTART_OBS = "restart_obs"
+    EXIT = "exit"
+
 
 async def do_websocket_connection(port):
     """

GameSentenceMiner/config_gui.py

@@ -41,7 +41,7 @@ class HoverInfoWidget:
         self.tooltip.wm_overrideredirect(True)
         self.tooltip.wm_geometry(f"+{x}+{y}")
         label = tk.Label(self.tooltip, text=text, background="yellow", relief="solid", borderwidth=1,
-                         font=("tahoma", "8", "normal"))
+                         font=("tahoma", "12", "normal"))
         label.pack(ipadx=1)
 
     def hide_info_box(self):
@@ -58,6 +58,7 @@ class ConfigApp:
         # self.window = ttk.Window(themename='darkly')
         self.window.title('GameSentenceMiner Configuration')
         self.window.protocol("WM_DELETE_WINDOW", self.hide)
+        self.obs_scene_listbox_changed = False
 
         self.current_row = 0
 
@@ -83,7 +84,11 @@ class ConfigApp:
 
         self.notebook.bind("<<NotebookTabChanged>>", self.on_profiles_tab_selected)
 
-        ttk.Button(self.window, text="Save Settings", command=self.save_settings).pack(pady=20)
+        button_frame = ttk.Frame(self.window)
+        button_frame.pack(side="top", pady=20, anchor="center")
+
+        ttk.Button(button_frame, text="Save Settings", command=self.save_settings).grid(row=0, column=0, padx=10)
+        ttk.Button(button_frame, text="Save and Sync Changes", command=lambda: self.save_settings(profile_change=False, sync_changes=True)).grid(row=0, column=1, padx=10)
 
         self.window.withdraw()
 
@@ -118,12 +123,12 @@ class ConfigApp:
         if self.window is not None:
             self.window.withdraw()
 
-    def save_settings(self, profile_change=False):
+    def save_settings(self, profile_change=False, sync_changes=False):
         global settings_saved
 
         # Create a new Config instance
         config = ProfileConfig(
-            scenes=[self.obs_scene_listbox.get(i) for i in self.obs_scene_listbox.curselection()],
+            scenes=[self.obs_scene_listbox.get(i) for i in self.obs_scene_listbox.curselection()] if self.obs_scene_listbox_changed else self.settings.scenes,
             general=General(
                 use_websocket=self.websocket_enabled.get(),
                 use_clipboard=self.clipboard_enabled.get(),
@@ -131,7 +136,8 @@ class ConfigApp:
                 open_config_on_startup=self.open_config_on_startup.get(),
                 open_multimine_on_startup=self.open_multimine_on_startup.get(),
                 texthook_replacement_regex=self.texthook_replacement_regex.get(),
-                use_both_clipboard_and_websocket=self.use_both_clipboard_and_websocket.get()
+                use_both_clipboard_and_websocket=self.use_both_clipboard_and_websocket.get(),
+                use_old_texthooker=self.use_old_texthooker.get()
             ),
             paths=Paths(
                 folder_to_watch=self.folder_to_watch.get(),
@@ -220,11 +226,12 @@ class ConfigApp:
             advanced=Advanced(
                 audio_player_path=self.audio_player_path.get(),
                 video_player_path=self.video_player_path.get(),
-                # show_screenshot_buttons=self.show_screenshot_button.get(),
                 multi_line_line_break=self.multi_line_line_break.get(),
                 multi_line_sentence_storage_field=self.multi_line_sentence_storage_field.get(),
                 ocr_sends_to_clipboard=self.ocr_sends_to_clipboard.get(),
                 use_anki_note_creation_time=self.use_anki_note_creation_time.get(),
+                ocr_websocket_port=int(self.ocr_websocket_port.get()),
+                texthooker_communication_websocket_port=int(self.texthooker_communication_websocket_port.get()),
             ),
             ai=Ai(
                 enabled=self.ai_enabled.get(),
@@ -261,10 +268,11 @@ class ConfigApp:
             self.master_config.current_profile = current_profile
             self.master_config.set_config_for_profile(current_profile, config)
 
-
-
         self.master_config = self.master_config.sync_shared_fields()
 
+        if sync_changes:
+            self.master_config.sync_changed_fields(prev_config)
+
         # Serialize the config instance to JSON
         with open(get_config_path(), 'w') as file:
             file.write(self.master_config.to_json(indent=4))
@@ -348,11 +356,11 @@ class ConfigApp:
         self.add_label_and_increment_row(general_frame, "Enable to allow GSM to accept both clipboard and websocket input at the same time.",
                                             row=self.current_row, column=2)
 
-        ttk.Label(general_frame, text="Websocket URI:").grid(row=self.current_row, column=0, sticky='W')
-        self.websocket_uri = ttk.Entry(general_frame)
+        ttk.Label(general_frame, text="Websocket URI(s):").grid(row=self.current_row, column=0, sticky='W')
+        self.websocket_uri = ttk.Entry(general_frame, width=50)
         self.websocket_uri.insert(0, self.settings.general.websocket_uri)
         self.websocket_uri.grid(row=self.current_row, column=1)
-        self.add_label_and_increment_row(general_frame, "WebSocket URI for connecting.", row=self.current_row,
+        self.add_label_and_increment_row(general_frame, "WebSocket URI for connecting. Allows Comma Seperated Values for Connecting Multiple.", row=self.current_row,
                                          column=2)
 
         ttk.Label(general_frame, text="TextHook Replacement Regex:").grid(row=self.current_row, column=0, sticky='W')
@@ -383,6 +391,13 @@ class ConfigApp:
         self.add_label_and_increment_row(general_frame, "Port for the Texthooker to run on. Only change if you know what you are doing", row=self.current_row,
                                             column=2)
 
+        ttk.Label(general_frame, text="Use Old Texthooker").grid(row=self.current_row, column=0, sticky='W')
+        self.use_old_texthooker = tk.BooleanVar(value=self.settings.general.use_old_texthooker)
+        ttk.Checkbutton(general_frame, variable=self.use_old_texthooker).grid(row=self.current_row, column=1,
+                                                                                sticky='W')
+        self.add_label_and_increment_row(general_frame, "Use the old Texthooker page, this option will be removed at a later date.", row=self.current_row,
+                                            column=2)
+
 
         ttk.Label(general_frame, text="Current Version:").grid(row=self.current_row, column=0, sticky='W')
         self.current_version = ttk.Label(general_frame, text=get_current_version())
@@ -417,6 +432,13 @@ class ConfigApp:
         self.add_label_and_increment_row(vad_frame, "Enable post-processing of audio to trim just the voiceline.",
                                          row=self.current_row, column=2)
 
+        ttk.Label(vad_frame, text="Language:").grid(row=self.current_row, column=0, sticky='W')
+        self.language = ttk.Combobox(vad_frame, values=AVAILABLE_LANGUAGES)
+        self.language.set(self.settings.vad.language)
+        self.language.grid(row=self.current_row, column=1)
+        self.add_label_and_increment_row(vad_frame, "Select the language for VAD. This is used for Whisper and Groq (if i implemented it)", row=self.current_row,
+                                            column=2)
+
         ttk.Label(vad_frame, text="Whisper Model:").grid(row=self.current_row, column=0, sticky='W')
         self.whisper_model = ttk.Combobox(vad_frame, values=[WHISPER_TINY, WHISPER_BASE, WHISPER_SMALL, WHISPER_MEDIUM,
                                                              WHSIPER_LARGE])
@@ -434,13 +456,13 @@ class ConfigApp:
                                          column=2)
 
         ttk.Label(vad_frame, text="Select VAD Model:").grid(row=self.current_row, column=0, sticky='W')
-        self.selected_vad_model = ttk.Combobox(vad_frame, values=[VOSK, SILERO, WHISPER])
+        self.selected_vad_model = ttk.Combobox(vad_frame, values=[VOSK, SILERO, WHISPER, GROQ])
         self.selected_vad_model.set(self.settings.vad.selected_vad_model)
         self.selected_vad_model.grid(row=self.current_row, column=1)
         self.add_label_and_increment_row(vad_frame, "Select which VAD model to use.", row=self.current_row, column=2)
 
         ttk.Label(vad_frame, text="Backup VAD Model:").grid(row=self.current_row, column=0, sticky='W')
-        self.backup_vad_model = ttk.Combobox(vad_frame, values=[OFF, VOSK, SILERO, WHISPER])
+        self.backup_vad_model = ttk.Combobox(vad_frame, values=[OFF, VOSK, SILERO, WHISPER, GROQ])
         self.backup_vad_model.set(self.settings.vad.backup_vad_model)
         self.backup_vad_model.grid(row=self.current_row, column=1)
         self.add_label_and_increment_row(vad_frame, "Select which model to use as a backup if no audio is found.",
@@ -595,14 +617,14 @@ class ConfigApp:
                                          column=2)
 
         ttk.Label(anki_frame, text="Custom Tags:").grid(row=self.current_row, column=0, sticky='W')
-        self.custom_tags = ttk.Entry(anki_frame)
+        self.custom_tags = ttk.Entry(anki_frame, width=50)
         self.custom_tags.insert(0, ', '.join(self.settings.anki.custom_tags))
         self.custom_tags.grid(row=self.current_row, column=1)
         self.add_label_and_increment_row(anki_frame, "Comma-separated custom tags for the Anki cards.",
                                          row=self.current_row, column=2)
 
         ttk.Label(anki_frame, text="Tags to work on:").grid(row=self.current_row, column=0, sticky='W')
-        self.tags_to_check = ttk.Entry(anki_frame)
+        self.tags_to_check = ttk.Entry(anki_frame, width=50)
         self.tags_to_check.insert(0, ', '.join(self.settings.anki.tags_to_check))
         self.tags_to_check.grid(row=self.current_row, column=1)
         self.add_label_and_increment_row(anki_frame,
@@ -1014,14 +1036,18 @@ class ConfigApp:
 
         ttk.Button(profiles_frame, text="Add Profile", command=self.add_profile).grid(row=self.current_row, column=0, pady=5)
         ttk.Button(profiles_frame, text="Copy Profile", command=self.copy_profile).grid(row=self.current_row, column=1, pady=5)
+        self.delete_profile_button = ttk.Button(profiles_frame, text="Delete Config", command=self.delete_profile)
         if self.master_config.current_profile != DEFAULT_CONFIG:
-            ttk.Button(profiles_frame, text="Delete Config", command=self.delete_profile).grid(row=self.current_row, column=2, pady=5)
+            self.delete_profile_button.grid(row=1, column=2, pady=5)
+        else:
+            self.delete_profile_button.grid_remove()
         self.current_row += 1
 
         ttk.Label(profiles_frame, text="OBS Scene:").grid(row=self.current_row, column=0, sticky='W')
         self.obs_scene_var = tk.StringVar(value="")
-        self.obs_scene_listbox = tk.Listbox(profiles_frame, listvariable=self.obs_scene_var, selectmode=tk.MULTIPLE, height=10)
+        self.obs_scene_listbox = tk.Listbox(profiles_frame, listvariable=self.obs_scene_var, selectmode=tk.MULTIPLE, height=10, width=50)
         self.obs_scene_listbox.grid(row=self.current_row, column=1)
+        self.obs_scene_listbox.bind("<<ListboxSelect>>", self.on_obs_scene_select)
         ttk.Button(profiles_frame, text="Refresh Scenes", command=self.refresh_obs_scenes).grid(row=self.current_row, column=2, pady=5)
         self.add_label_and_increment_row(profiles_frame, "Select an OBS scene to associate with this profile. (Optional)", row=self.current_row, column=3)
 
@@ -1030,6 +1056,8 @@ class ConfigApp:
         ttk.Checkbutton(profiles_frame, variable=self.switch_to_default_if_not_found).grid(row=self.current_row, column=1, sticky='W')
         self.add_label_and_increment_row(profiles_frame, "Enable to switch to the default profile if the selected OBS scene is not found.", row=self.current_row, column=2)
 
+    def on_obs_scene_select(self, event):
+        self.obs_scene_listbox_changed = True
 
     def refresh_obs_scenes(self):
         scenes = obs.get_obs_scenes()
@@ -1088,6 +1116,17 @@ class ConfigApp:
         ttk.Checkbutton(advanced_frame, variable=self.ocr_sends_to_clipboard).grid(row=self.current_row, column=1, sticky='W')
         self.add_label_and_increment_row(advanced_frame, "Enable to send OCR results to clipboard.", row=self.current_row, column=2)
 
+        self.ocr_websocket_port = ttk.Entry(advanced_frame)
+        self.ocr_websocket_port.insert(0, str(self.settings.advanced.ocr_websocket_port))
+        self.ocr_websocket_port.grid(row=self.current_row, column=1)
+        self.add_label_and_increment_row(advanced_frame, "Port for OCR WebSocket communication. GSM will also listen on this port", row=self.current_row, column=2)
+
+        ttk.Label(advanced_frame, text="Texthooker Communication WebSocket Port:").grid(row=self.current_row, column=0, sticky='W')
+        self.texthooker_communication_websocket_port = ttk.Entry(advanced_frame)
+        self.texthooker_communication_websocket_port.insert(0, str(self.settings.advanced.texthooker_communication_websocket_port))
+        self.texthooker_communication_websocket_port.grid(row=self.current_row, column=1)
+        self.add_label_and_increment_row(advanced_frame, "Port for GSM Texthooker WebSocket communication. Does nothing right now, hardcoded to 55001", row=self.current_row, column=2)
+
 
         ttk.Label(advanced_frame, text="Use Anki Creation Date for Audio Timing:").grid(row=self.current_row, column=0, sticky='W')
         self.use_anki_note_creation_time = tk.BooleanVar(value=self.settings.advanced.use_anki_note_creation_time)
@@ -1113,7 +1152,7 @@ class ConfigApp:
         self.add_label_and_increment_row(ai_frame, "Select the AI provider.", row=self.current_row, column=2)
 
         ttk.Label(ai_frame, text="Gemini AI Model:").grid(row=self.current_row, column=0, sticky='W')
-        self.gemini_model = ttk.Combobox(ai_frame, values=['gemini-2.0-flash', 'gemini-2.0-flash-lite', 'gemini-2.5-pro-preview-03-25', 'gemini-2.5-flash-preview-04-17'])
+        self.gemini_model = ttk.Combobox(ai_frame, values=['gemini-2.0-flash', 'gemini-2.0-flash-lite', 'gemini-2.5-pro-preview-05-06', 'gemini-2.5-flash-preview-05-20'])
         self.gemini_model.set(self.settings.ai.gemini_model)
         self.gemini_model.grid(row=self.current_row, column=1)
         self.add_label_and_increment_row(ai_frame, "Select the AI model to use.", row=self.current_row, column=2)
@@ -1180,10 +1219,13 @@ class ConfigApp:
 
 
     def on_profile_change(self, event):
-        print("profile Changed!")
         self.save_settings(profile_change=True)
         self.reload_settings()
         self.refresh_obs_scenes()
+        if self.master_config.current_profile != DEFAULT_CONFIG:
+            self.delete_profile_button.grid(row=1, column=2, pady=5)
+        else:
+            self.delete_profile_button.grid_remove()
 
     def add_profile(self):
         new_profile_name = simpledialog.askstring("Input", "Enter new profile name:")
@@ -1216,7 +1258,8 @@ class ConfigApp:
                 del self.master_config.configs[profile_to_delete]
                 self.profile_combobox['values'] = list(self.master_config.configs.keys())
                 self.profile_combobox.set("Default")
-                self.save_settings()
+                self.master_config.current_profile = "Default"
+                save_full_config(self.master_config)
                 self.reload_settings()
 
 

GameSentenceMiner/configuration.py

@@ -1,23 +1,24 @@
+import dataclasses
 import json
 import logging
 import os
 import shutil
-import socket
 from dataclasses import dataclass, field
 from logging.handlers import RotatingFileHandler
 from os.path import expanduser
 from sys import platform
 from typing import List, Dict
 import sys
+from enum import Enum
 
 import toml
 from dataclasses_json import dataclass_json
 
-
 OFF = 'OFF'
 VOSK = 'VOSK'
 SILERO = 'SILERO'
 WHISPER = 'WHISPER'
+GROQ = 'GROQ'
 
 VOSK_BASE = 'BASE'
 VOSK_SMALL = 'SMALL'
@@ -38,17 +39,36 @@ DEFAULT_CONFIG = 'Default'
 
 current_game = ''
 
+
+class Language(Enum):
+    JAPANESE = "ja"
+    ENGLISH = "en"
+    KOREAN = "ko"
+    CHINESE = "zh"
+    SPANISH = "es"
+    FRENCH = "fr"
+    GERMAN = "de"
+    ITALIAN = "it"
+    RUSSIAN = "ru"
+    PORTUGUESE = "pt"
+    HINDI = "hi"
+    ARABIC = "ar"
+
+AVAILABLE_LANGUAGES = [lang.value for lang in Language]
+AVAILABLE_LANGUAGES_DICT = {lang.value: lang for lang in Language}
+
 @dataclass_json
 @dataclass
 class General:
     use_websocket: bool = True
     use_clipboard: bool = True
     use_both_clipboard_and_websocket: bool = False
-    websocket_uri: str = 'localhost:6677'
+    websocket_uri: str = 'localhost:6677,localhost:9001,localhost:2333'
     open_config_on_startup: bool = False
     open_multimine_on_startup: bool = True
     texthook_replacement_regex: str = ""
     texthooker_port: int = 55000
+    use_old_texthooker: bool = False
 
 
 @dataclass_json
@@ -167,6 +187,7 @@ class Hotkeys:
 class VAD:
     whisper_model: str = WHISPER_BASE
     do_vad_postprocessing: bool = True
+    language: str = 'ja'
     vosk_url: str = VOSK_BASE
     selected_vad_model: str = SILERO
     backup_vad_model: str = OFF
@@ -183,6 +204,9 @@ class VAD:
     def is_vosk(self):
         return self.selected_vad_model == VOSK or self.backup_vad_model == VOSK
 
+    def is_groq(self):
+        return self.selected_vad_model == GROQ or self.backup_vad_model == GROQ
+
 
 @dataclass_json
 @dataclass
@@ -193,6 +217,8 @@ class Advanced:
     multi_line_line_break: str = '<br>'
     multi_line_sentence_storage_field: str = ''
     ocr_sends_to_clipboard: bool = True
+    ocr_websocket_port: int = 9002
+    texthooker_communication_websocket_port: int = 55001
     use_anki_note_creation_time: bool = False
 
 @dataclass_json
@@ -346,6 +372,9 @@ class Config:
         return self
 
     def get_config(self) -> ProfileConfig:
+        if self.current_profile not in self.configs:
+            logger.warning(f"Profile '{self.current_profile}' not found. Switching to default profile.")
+            self.current_profile = DEFAULT_CONFIG
         return self.configs[self.current_profile]
 
     def set_config_for_profile(self, profile: str, config: ProfileConfig):
@@ -361,6 +390,27 @@ class Config:
     def get_default_config(self):
         return self.configs[DEFAULT_CONFIG]
 
+    def sync_changed_fields(self, previous_config: ProfileConfig):
+        current_config = self.get_config()
+
+        for section in current_config.to_dict():
+            if dataclasses.is_dataclass(getattr(current_config, section, None)):
+                for field_name in getattr(current_config, section, None).to_dict():
+                    config_section = getattr(current_config, section, None)
+                    previous_config_section = getattr(previous_config, section, None)
+                    current_value = getattr(config_section, field_name, None)
+                    previous_value = getattr(previous_config_section, field_name, None)
+                    if str(current_value).strip() != str(previous_value).strip():
+                        logger.info(f"Syncing changed field '{field_name}' from '{previous_value}' to '{current_value}'")
+                        for profile in self.configs.values():
+                            if profile != current_config:
+                                profile_section = getattr(profile, section, None)
+                                if profile_section:
+                                    setattr(profile_section, field_name, current_value)
+                                    logger.info(f"Updated '{field_name}' in profile '{profile.name}'")
+
+        return self
+
     def sync_shared_fields(self):
         config = self.get_config()
         for profile in self.configs.values():
@@ -386,8 +436,12 @@ class Config:
             self.sync_shared_field(config.general, profile.general, "open_multimine_on_startup")
             self.sync_shared_field(config.general, profile.general, "websocket_uri")
             self.sync_shared_field(config.general, profile.general, "texthooker_port")
+            self.sync_shared_field(config.general, profile.general, "use_old_texthooker")
             self.sync_shared_field(config.audio, profile.audio, "external_tool")
             self.sync_shared_field(config.audio, profile.audio, "anki_media_collection")
+            self.sync_shared_field(config.audio, profile.audio, "external_tool_enabled")
+            self.sync_shared_field(config.audio, profile.audio, "custom_encode_settings")
+            self.sync_shared_field(config.screenshot, profile.screenshot, "custom_ffmpeg_settings")
             self.sync_shared_field(config, profile, "advanced")
             self.sync_shared_field(config, profile, "paths")
             self.sync_shared_field(config, profile, "obs")
@@ -573,3 +627,15 @@ if 'gsm' in sys.argv[0]:
 
 DB_PATH = os.path.join(get_app_directory(), 'gsm.db')
 
+class GsmAppState:
+    def __init__(self):
+        self.line_for_audio = None
+        self.line_for_screenshot = None
+        self.previous_line_for_audio = None
+        self.previous_line_for_screenshot = None
+        self.previous_audio = None
+        self.previous_screenshot = None
+        self.previous_replay = None
+
+gsm_state = GsmAppState()
+

GameSentenceMiner/ffmpeg.py

@@ -396,8 +396,8 @@ def trim_audio_by_end_time(input_audio, end_time, output_audio):
 def convert_audio_to_wav(input_audio, output_wav):
     command = ffmpeg_base_command_list + [
         "-i", input_audio,
-        "-ar", "16000",
-        "-ac", "1",
+        "-ar", "16000",  # Resample to 16kHz
+        "-ac", "1",      # Convert to mono
         "-af", "afftdn,dialoguenhance" if not util.is_linux() else "afftdn",
         output_wav
     ]

GameSentenceMiner/gametext.py

@@ -17,82 +17,91 @@ current_line_after_regex = ''
 current_line_time = datetime.now()
 
 reconnecting = False
-websocket_connected = False
-
-    # def remove_old_events(self, cutoff_time: datetime):
-    #     self.values = [line for line in self.values if line.time >= cutoff_time]
+websocket_connected = {}
 
 async def monitor_clipboard():
-    # Initial clipboard content
-    current_clipboard = pyperclip.paste()
-
-    skip_next_clipboard = False
+    global current_line
+    current_line = pyperclip.paste()
+    send_message_on_resume = False
     while True:
         if not get_config().general.use_clipboard:
-            await asyncio.sleep(1)
+            await asyncio.sleep(5)
             continue
-        if not get_config().general.use_both_clipboard_and_websocket and websocket_connected:
+        if not get_config().general.use_both_clipboard_and_websocket and any(websocket_connected.values()):
             await asyncio.sleep(1)
-            skip_next_clipboard = True
+            send_message_on_resume = True
             continue
+        elif send_message_on_resume:
+            logger.info("No Websocket Connections, resuming Clipboard Monitoring.")
+            send_message_on_resume = False
         current_clipboard = pyperclip.paste()
 
-        if current_clipboard and current_clipboard != current_line and not skip_next_clipboard:
+        if current_clipboard and current_clipboard != current_line:
             await handle_new_text_event(current_clipboard)
-            skip_next_clipboard = False
 
         await asyncio.sleep(0.05)
 
 
-async def listen_websocket():
-    global current_line, current_line_time, reconnecting, websocket_connected
-    try_other = False
-    while True:
-        if not get_config().general.use_websocket:
-            await asyncio.sleep(1)
-            continue
-        websocket_url = f'ws://{get_config().general.websocket_uri}/gsm'
-        if try_other:
-            websocket_url = f'ws://{get_config().general.websocket_uri}/api/ws/text/origin'
-        try:
-            async with websockets.connect(websocket_url, ping_interval=None) as websocket:
-                logger.info("TextHooker Websocket Connected!")
-                if reconnecting:
-                    logger.info(f"Texthooker WebSocket connected Successfully!" + " Disabling Clipboard Monitor." if (get_config().general.use_clipboard and not get_config().general.use_both_clipboard_and_websocket) else "")
-                    reconnecting = False
-                websocket_connected = True
-                try_other = True
-                line_time = None
-                while True:
-                    message = await websocket.recv()
-                    if not message:
-                        continue
-                    logger.debug(message)
-                    try:
-                        data = json.loads(message)
-                        if "sentence" in data:
-                            current_clipboard = data["sentence"]
-                        if "time" in data:
-                            line_time = datetime.fromisoformat(data["time"])
-                    except json.JSONDecodeError or TypeError:
-                        current_clipboard = message
-                    if current_clipboard != current_line:
-                        await handle_new_text_event(current_clipboard, line_time if line_time else None)
-        except (websockets.ConnectionClosed, ConnectionError, InvalidStatus, ConnectionResetError, Exception) as e:
-            if isinstance(e, InvalidStatus):
-                e: InvalidStatus
-                if e.response.status_code == 404:
-                    logger.info("Texthooker WebSocket connection failed. Attempting some fixes...")
+async def listen_websockets():
+    async def listen_on_websocket(uri):
+        global current_line, current_line_time, reconnecting, websocket_connected
+        try_other = False
+        websocket_connected[uri] = False
+        while True:
+            if not get_config().general.use_websocket:
+                await asyncio.sleep(1)
+                continue
+            websocket_url = f'ws://{uri}'
+            if try_other:
+                websocket_url = f'ws://{uri}/api/ws/text/origin'
+            try:
+                async with websockets.connect(websocket_url, ping_interval=None) as websocket:
+                    logger.info(f"TextHooker Websocket {uri} Connected!")
+                    if reconnecting:
+                        logger.info(f"Texthooker WebSocket {uri} connected Successfully!" + " Disabling Clipboard Monitor." if (get_config().general.use_clipboard and not get_config().general.use_both_clipboard_and_websocket) else "")
+                        reconnecting = False
+                    websocket_connected[uri] = True
                     try_other = True
-                    await asyncio.sleep(0.1)
-            else:
-                if not (isinstance(e, ConnectionResetError) or isinstance(e, ConnectionError) or isinstance(e, InvalidStatus) or isinstance(e, websockets.ConnectionClosed)):
-                    logger.error(f"Unexpected error in Texthooker WebSocket connection: {e}")
-                websocket_connected = False
-                if not reconnecting:
-                    logger.warning(f"Texthooker WebSocket connection lost, Defaulting to clipboard if enabled. Attempting to Reconnect...")
-                reconnecting = True
-                await asyncio.sleep(5)
+                    line_time = None
+                    while True:
+                        message = await websocket.recv()
+                        if not message:
+                            continue
+                        logger.debug(message)
+                        try:
+                            data = json.loads(message)
+                            if "sentence" in data:
+                                current_clipboard = data["sentence"]
+                            if "time" in data:
+                                line_time = datetime.fromisoformat(data["time"])
+                        except json.JSONDecodeError or TypeError:
+                            current_clipboard = message
+                        if current_clipboard != current_line:
+                            await handle_new_text_event(current_clipboard, line_time if line_time else None)
+            except (websockets.ConnectionClosed, ConnectionError, InvalidStatus, ConnectionResetError, Exception) as e:
+                if isinstance(e, InvalidStatus):
+                    e: InvalidStatus
+                    if e.response.status_code == 404:
+                        logger.info(f"Texthooker WebSocket: {uri} connection failed. Attempting some fixes...")
+                        try_other = True
+                else:
+                    if not (isinstance(e, ConnectionResetError) or isinstance(e, ConnectionError) or isinstance(e, InvalidStatus) or isinstance(e, websockets.ConnectionClosed)):
+                        logger.error(f"Unexpected error in Texthooker WebSocket {uri} connection: {e}")
+                    if websocket_connected[uri]:
+                        logger.warning(f"Texthooker WebSocket {uri} disconnected. Attempting to reconnect...")
+                    websocket_connected[uri] = False
+                    await asyncio.sleep(1)
+
+    websocket_tasks = []
+    if ',' in get_config().general.websocket_uri:
+        for uri in get_config().general.websocket_uri.split(','):
+            websocket_tasks.append(listen_on_websocket(uri))
+    else:
+        websocket_tasks.append(listen_on_websocket(get_config().general.websocket_uri))
+
+    websocket_tasks.append(listen_on_websocket(f"localhost:{get_config().advanced.ocr_websocket_port}"))
+
+    await asyncio.gather(*websocket_tasks)
 
 async def handle_new_text_event(current_clipboard, line_time=None):
     global current_line, current_line_time, current_line_after_regex
@@ -116,7 +125,7 @@ def reset_line_hotkey_pressed():
 
 
 def run_websocket_listener():
-    asyncio.run(listen_websocket())
+    asyncio.run(listen_websockets())
 
 
 async def start_text_monitor():