GameSentenceMiner 2.18.20__py3-none-any.whl → 2.19.0__py3-none-any.whl

GameSentenceMiner/gametext.py

@@ -1,7 +1,8 @@
 import asyncio
 import json
 import re
-from datetime import datetime
+from datetime import datetime, timedelta
+from collections import defaultdict, deque
 
 import pyperclip
 import requests
@@ -17,7 +18,7 @@ from GameSentenceMiner.util.gsm_utils import add_srt_line
 from GameSentenceMiner.util.text_log import add_line, get_text_log
 from GameSentenceMiner.web.texthooking_page import add_event_to_texthooker, overlay_server_thread
 
-from GameSentenceMiner.util.get_overlay_coords import overlay_processor
+from GameSentenceMiner.util.get_overlay_coords import get_overlay_processor
 
 
 current_line = ''
@@ -34,6 +35,61 @@ last_clipboard = ''
 reconnecting = False
 websocket_connected = {}
 
+# Rate-based spam detection globals
+message_timestamps = defaultdict(lambda: deque(maxlen=60))  # Store last 60 message timestamps per source
+rate_limit_active = defaultdict(bool)  # Track if rate limiting is active per source
+
+
+def is_message_rate_limited(source="clipboard"):
+    """
+    Aggressive rate-based spam detection optimized for game texthookers.
+    Uses multiple time windows for faster detection and recovery.
+    
+    Args:
+        source (str): The source of the message (clipboard, websocket, etc.)
+    
+    Returns:
+        bool: True if message should be dropped due to rate limiting
+    """
+    current_time = datetime.now()
+    timestamps = message_timestamps[source]
+    
+    # Add current message timestamp
+    timestamps.append(current_time)
+    
+    # Check multiple time windows for aggressive detection
+    half_second_ago = current_time - timedelta(milliseconds=500)
+    one_second_ago = current_time - timedelta(seconds=1)
+    
+    # Count messages in different time windows
+    last_500ms = sum(1 for ts in timestamps if ts > half_second_ago)
+    last_1s = sum(1 for ts in timestamps if ts > one_second_ago)
+    
+    # Very aggressive thresholds for game texthookers:
+    # - 5+ messages in 500ms = instant spam detection
+    # - 8+ messages in 1 second = spam detection
+    spam_detected = last_500ms >= 5 or last_1s >= 8
+    
+    if spam_detected:
+        if not rate_limit_active[source]:
+            logger.warning(f"Rate limiting activated for {source}: {last_500ms} msgs/500ms, {last_1s} msgs/1s")
+            rate_limit_active[source] = True
+        return True
+    
+    # If rate limiting is active, check if we can deactivate it immediately
+    if rate_limit_active[source]:
+        # Very fast recovery: allow if current 500ms window has <= 2 messages
+        if last_500ms <= 2:
+            logger.info(f"Rate limiting deactivated for {source}: rate normalized ({last_500ms} msgs/500ms)")
+            rate_limit_active[source] = False
+            return False  # Allow this message through
+        else:
+            # Still too fast, keep dropping
+            return True
+    
+    return False
+
+
 async def monitor_clipboard():
     global current_line, last_clipboard
     current_line = pyperclip.paste()
@@ -55,6 +111,9 @@ async def monitor_clipboard():
         current_clipboard = pyperclip.paste()
 
         if current_clipboard and current_clipboard != current_line and current_clipboard != last_clipboard:
+            # Check for rate limiting before processing
+            if is_message_rate_limited("clipboard"):
+                continue  # Drop message due to rate limiting
             last_clipboard = current_clipboard
             await handle_new_text_event(current_clipboard)
 
@@ -65,6 +124,7 @@ async def listen_websockets():
     async def listen_on_websocket(uri):
         global current_line, current_line_time, reconnecting, websocket_connected
         try_other = False
+        rated_limited = False
         websocket_connected[uri] = False
         websocket_names = {
             "9002": "GSM OCR",
@@ -82,17 +142,19 @@ async def listen_websockets():
                 websocket_url = f'ws://{uri}/api/ws/text/origin'
             try:
                 async with websockets.connect(websocket_url, ping_interval=None) as websocket:
+                    websocket_source = f"websocket_{uri}"
                     gsm_status.websockets_connected.append(websocket_url)
-                    if reconnecting:
-                        logger.info(f"Texthooker WebSocket {uri}{likely_websocket_name} connected Successfully!" + " Disabling Clipboard Monitor." if (get_config().general.use_clipboard and not get_config().general.use_both_clipboard_and_websocket) else "")
-                        reconnecting = False
+                    logger.info(f"Texthooker WebSocket {uri}{likely_websocket_name} connected Successfully!" + " Disabling Clipboard Monitor." if (get_config().general.use_clipboard and not get_config().general.use_both_clipboard_and_websocket) else "")
                     websocket_connected[uri] = True
                     line_time = None
-                    while True:
-                        message = await websocket.recv()
+                    async for message in websocket:
                         message_received_time = datetime.now()
                         if not message:
                             continue
+                        # Check for rate limiting before processing
+                        if is_message_rate_limited(websocket_source):
+                            rated_limited = True
+                            continue  # Drop message due to rate limiting
                         if is_dev:
                             logger.debug(message)
                         try:
@@ -101,14 +163,10 @@ async def listen_websockets():
                                 current_clipboard = data["sentence"]
                             if "time" in data:
                                 line_time = datetime.fromisoformat(data["time"])
-                        except json.JSONDecodeError or TypeError:
+                        except (json.JSONDecodeError, TypeError):
                             current_clipboard = message
-                        logger.info
                         if current_clipboard != current_line:
-                            try:
-                                await handle_new_text_event(current_clipboard, line_time if line_time else message_received_time)
-                            except Exception as e: 
-                                logger.error(f"Error handling new text event: {e}", exc_info=True)
+                            await handle_new_text_event(current_clipboard, line_time if line_time else message_received_time)
             except (websockets.ConnectionClosed, ConnectionError, InvalidStatus, ConnectionResetError, Exception) as e:
                 if websocket_url in gsm_status.websockets_connected:
                     gsm_status.websockets_connected.remove(websocket_url)
@@ -201,8 +259,8 @@ async def add_line_to_text_log(line, line_time=None):
     if len(get_text_log().values) > 0:
         await add_event_to_texthooker(get_text_log()[-1])
     if get_config().overlay.websocket_port and overlay_server_thread.has_clients():
-        if overlay_processor.ready:
-            await overlay_processor.find_box_and_send_to_overlay(current_line_after_regex)
+        if get_overlay_processor().ready:
+            await get_overlay_processor().find_box_and_send_to_overlay(current_line_after_regex)
     add_srt_line(line_time, new_line)
     if 'nostatspls' not in new_line.scene.lower():
         GameLinesTable.add_line(new_line)

GameSentenceMiner/gsm.py

@@ -1,7 +1,5 @@
 # There should be no imports here, as any error will crash the program.
 # All imports should be done in the try/except block below.
-
-
 def handle_error_in_initialization(e):
     """Handle errors that occur during initialization."""
     logger.exception(e, exc_info=True)
@@ -49,7 +47,7 @@ try:
     logger.debug(f"[Import] configuration: {time.time() - start_time:.3f}s")
     
     start_time = time.time()
-    from GameSentenceMiner.util.get_overlay_coords import OverlayThread
+    from GameSentenceMiner.util.get_overlay_coords import init_overlay_processor
     from GameSentenceMiner.util.gsm_utils import remove_html_and_cloze_tags, add_srt_line
     logger.debug(f"[Import] get_overlay_coords (OverlayThread, remove_html_and_cloze_tags): {time.time() - start_time:.3f}s")
 
@@ -62,7 +60,7 @@ try:
     logger.debug(f"[Import] vad_processor: {time.time() - start_time:.3f}s")
 
     start_time = time.time()
-    from GameSentenceMiner.util.downloader.download_tools import download_obs_if_needed, download_ffmpeg_if_needed
+    from GameSentenceMiner.util.downloader.download_tools import download_obs_if_needed, download_ffmpeg_if_needed, write_obs_configs, download_oneocr_dlls_if_needed
     logger.debug(
         f"[Import] download_tools (download_obs_if_needed, download_ffmpeg_if_needed): {time.time() - start_time:.3f}s")
 
@@ -191,9 +189,6 @@ class VideoToAudioHandler(FileSystemEventHandler):
             if anki.card_queue and len(anki.card_queue) > 0:
                 last_note, anki_card_creation_time, selected_lines = anki.card_queue.pop(
                     0)
-            elif get_config().features.backfill_audio:
-                last_note = anki.get_cards_by_sentence(
-                    gametext.current_line_after_regex)
             else:
                 logger.info(
                     "Replay buffer initiated externally. Skipping processing.")
@@ -204,9 +199,6 @@ class VideoToAudioHandler(FileSystemEventHandler):
             if not last_note:
                 if get_config().anki.update_anki:
                     last_note = anki.get_last_anki_card()
-                if get_config().features.backfill_audio:
-                    last_note = anki.get_cards_by_sentence(
-                        gametext.current_line_after_regex)
 
             note, last_note = anki.get_initial_card_info(
                 last_note, selected_lines)
@@ -362,6 +354,7 @@ def initial_checks():
     try:
         subprocess.run(GameSentenceMiner.util.configuration.ffmpeg_base_command_list)
         logger.debug("FFMPEG is installed and accessible.")
+        
     except FileNotFoundError:
         logger.error(
             "FFmpeg not found, please install it and add it to your PATH.")
@@ -381,48 +374,11 @@ def register_hotkeys():
 
 
 def get_screenshot():
-    # try:
     last_note = anki.get_last_anki_card()
     gsm_state.anki_note_for_screenshot = last_note
     gsm_state.line_for_screenshot = get_mined_line(last_note, get_all_lines())
     obs.save_replay_buffer()
-    #     image = obs.get_screenshot()
-    #     wait_for_stable_file(image, timeout=3)
-    #     if not image:
-    #         raise Exception("Failed to get Screenshot from OBS")
-    #     encoded_image = ffmpeg.process_image(image)
-    #     if get_config().anki.update_anki and get_config().screenshot.screenshot_hotkey_updates_anki:
-    #         last_note = anki.get_last_anki_card()
-    #         if get_config().features.backfill_audio:
-    #             last_note = anki.get_cards_by_sentence(gametext.current_line)
-    #         if last_note:
-    #             anki.add_image_to_card(last_note, encoded_image)
-    #             notification.send_screenshot_updated(last_note.get_field(get_config().anki.word_field))
-    #             if get_config().features.open_anki_edit:
-    #                 notification.open_anki_card(last_note.noteId)
-    #         else:
-    #             notification.send_screenshot_saved(encoded_image)
-    #     else:
-    #         notification.send_screenshot_saved(encoded_image)
-    # except Exception as e:
-    #     logger.error(f"Failed to get Screenshot: {e}")
-
-
-# def create_image():
-#     """Create a simple pickaxe icon."""
-#     width, height = 64, 64
-#     image = Image.new("RGBA", (width, height), (0, 0, 0, 0))  # Transparent background
-#     draw = ImageDraw.Draw(image)
-#
-#     # Handle (rectangle)
-#     handle_color = (139, 69, 19)  # Brown color
-#     draw.rectangle([(30, 15), (34, 50)], fill=handle_color)
-#
-#     # Blade (triangle-like shape)
-#     blade_color = (192, 192, 192)  # Silver color
-#     draw.polygon([(15, 15), (49, 15), (32, 5)], fill=blade_color)
-#
-#     return image
+
 
 def create_image():
     image_path = os.path.join(os.path.dirname(
@@ -673,6 +629,8 @@ def initialize(reloading=False):
         if is_windows():
             download_obs_if_needed()
             download_ffmpeg_if_needed()
+            download_oneocr_dlls_if_needed()
+            write_obs_configs(obs.get_base_obs_dir())
             if shutil.which("ffmpeg") is None:
                 os.environ["PATH"] += os.pathsep + \
                     os.path.dirname(get_ffmpeg_path())
@@ -746,7 +704,7 @@ def async_loop():
         await register_scene_switcher_callback()
         await check_obs_folder_is_correct()
         vad_processor.init()
-        OverlayThread().start()
+        await init_overlay_processor()
 
         # Keep loop alive
         # if is_beangate:

GameSentenceMiner/obs.py

@@ -8,6 +8,7 @@ import time
 import logging
 import contextlib
 import shutil
+import queue
 
 import psutil
 
@@ -18,6 +19,21 @@ from GameSentenceMiner.util import configuration
 from GameSentenceMiner.util.configuration import get_app_directory, get_config, get_master_config, is_windows, save_full_config, reload_config, logger, gsm_status, gsm_state
 from GameSentenceMiner.util.gsm_utils import sanitize_filename, make_unique_file_name, make_unique_temp_file
 
+# Thread-safe queue for GUI error messages
+_gui_error_queue = queue.Queue()
+
+def _queue_error_for_gui(title, message, recheck_function=None):
+    _gui_error_queue.put((title, message, recheck_function))
+
+def get_queued_gui_errors():
+    errors = []
+    try:
+        while True:
+            errors.append(_gui_error_queue.get_nowait())
+    except queue.Empty:
+        pass
+    return errors
+
 connection_pool: 'OBSConnectionPool' = None
 event_client: obs.EventClient = None
 obs_process_pid = None
@@ -100,7 +116,6 @@ class OBSConnectionPool:
         if not hasattr(self, '_healthcheck_client') or self._healthcheck_client is None:
             try:
                 self._healthcheck_client = obs.ReqClient(**self.connection_kwargs)
-                logger.info("Initialized dedicated healthcheck client.")
             except Exception as e:
                 logger.error(f"Failed to create healthcheck client: {e}")
                 self._healthcheck_client = None
@@ -161,6 +176,11 @@ class OBSConnectionManager(threading.Thread):
 
         buffer_seconds, error_message = self.check_replay_buffer_enabled()
         
+        if not buffer_seconds:
+            # Queue the error message to be shown safely in the main thread
+            _queue_error_for_gui("OBS Replay Buffer Error", error_message + "\n\nTo disable this message, turn off 'Automatically Manage Replay Buffer' in GSM settings.", recheck_function=get_replay_buffer_output)
+            return errors
+
         gsm_state.replay_buffer_length = buffer_seconds or 300
 
         if not buffer_seconds:
@@ -176,7 +196,7 @@ class OBSConnectionManager(threading.Thread):
             return errors
 
         if current_status != self.last_replay_buffer_status:
-            self.last_replay_buffer_status = current_status
+            errors.append("Replay Buffer Changed Externally, Not Managing Automatically.")
             self.no_output_timestamp = None
             return errors
         
@@ -231,6 +251,9 @@ class OBSConnectionManager(threading.Thread):
 
     def stop(self):
         self.running = False
+        
+def get_base_obs_dir():
+    return os.path.join(configuration.get_app_directory(), 'obs-studio')
     
 def get_obs_path():
     return os.path.join(configuration.get_app_directory(), 'obs-studio/bin/64bit/obs64.exe')

GameSentenceMiner/ui/config_gui.py

@@ -251,6 +251,26 @@ class ConfigApp:
         self.window.update_idletasks()
         self.window.geometry("")
         self.window.withdraw()
+        
+        # Start checking for OBS error messages
+        self.check_obs_errors()
+    
+    def check_obs_errors(self):
+        """Check for queued error messages from OBS and display them."""
+        try:
+            from GameSentenceMiner import obs
+            errors = obs.get_queued_gui_errors()
+            for title, message, recheck_func in errors:
+                if recheck_func is not None:
+                    if recheck_func():
+                        continue  # Issue resolved, don't show error
+                messagebox.showerror(title, message)
+        except Exception as e:
+            # Don't let error checking crash the GUI
+            logger.debug(f"Error checking OBS error queue: {e}")
+        
+        # Schedule the next check in 1 second
+        self.window.after(1000, self.check_obs_errors)
     
     def change_locale(self):
         """Change the locale of the application."""
@@ -414,7 +434,6 @@ class ConfigApp:
         self.notify_on_update_value = tk.BooleanVar(value=self.settings.features.notify_on_update)
         self.open_anki_edit_value = tk.BooleanVar(value=self.settings.features.open_anki_edit)
         self.open_anki_browser_value = tk.BooleanVar(value=self.settings.features.open_anki_in_browser)
-        self.backfill_audio_value = tk.BooleanVar(value=self.settings.features.backfill_audio)
         self.browser_query_value = tk.StringVar(value=self.settings.features.browser_query)
         self.generate_longplay_value = tk.BooleanVar(value=self.settings.features.generate_longplay)
         
@@ -544,7 +563,7 @@ class ConfigApp:
         self.create_vars()  # Recreate variables to reflect default values
         recreate_tab()
         self.save_settings(profile_change=False)
-        self.reload_settings()
+        self.reload_settings(force_refresh=True)
 
     def show_scene_selection(self, matched_configs):
         selected_scene = None
@@ -645,7 +664,6 @@ class ConfigApp:
                 notify_on_update=self.notify_on_update_value.get(),
                 open_anki_edit=self.open_anki_edit_value.get(),
                 open_anki_in_browser=self.open_anki_browser_value.get(),
-                backfill_audio=self.backfill_audio_value.get(),
                 browser_query=self.browser_query_value.get(),
                 generate_longplay=self.generate_longplay_value.get(),
             ),
@@ -1536,6 +1554,14 @@ class ConfigApp:
         ttk.Checkbutton(anki_frame, variable=self.multi_overwrites_sentence_value, bootstyle="round-toggle").grid(
             row=self.current_row, column=1, sticky='W', pady=2)
         self.current_row += 1
+        
+        advanced_i18n = anki_i18n.get('advanced_settings', {})
+        linebreak_i18n = advanced_i18n.get('multiline_linebreak', {})
+        HoverInfoLabelWidget(anki_frame, text=linebreak_i18n.get('label', '...'),
+                             tooltip=linebreak_i18n.get('tooltip', '...'),
+                             row=self.current_row, column=0)
+        ttk.Entry(anki_frame, textvariable=self.multi_line_line_break_value).grid(row=self.current_row, column=1, sticky='EW', pady=2)
+        self.current_row += 1
 
         self.add_reset_button(anki_frame, "anki", self.current_row, 0, self.create_anki_tab)
 
@@ -1595,13 +1621,6 @@ class ConfigApp:
         ttk.Entry(features_frame, width=50, textvariable=self.browser_query_value).grid(row=self.current_row, column=1, sticky='EW', pady=2)
         self.current_row += 1
 
-        backfill_i18n = features_i18n.get('backfill_audio', {})
-        HoverInfoLabelWidget(features_frame, text=backfill_i18n.get('label', '...'), tooltip=backfill_i18n.get('tooltip', '...'),
-                             row=self.current_row, column=0)
-        ttk.Checkbutton(features_frame, variable=self.backfill_audio_value, bootstyle="round-toggle").grid(
-            row=self.current_row, column=1, sticky='W', pady=2)
-        self.current_row += 1
-
         HoverInfoLabelWidget(features_frame, text="Generate LongPlay", tooltip="Generate a LongPlay video using OBS recording, and write to a .srt file with all the text coming into gsm. RESTART REQUIRED FOR SETTING TO TAKE EFFECT.",
                              row=self.current_row, column=0)
         ttk.Checkbutton(features_frame, variable=self.generate_longplay_value, bootstyle="round-toggle").grid(
@@ -2063,13 +2082,6 @@ class ConfigApp:
         ttk.Entry(advanced_frame, textvariable=self.play_latest_audio_hotkey_value).grid(row=self.current_row, column=1, sticky='EW', pady=2)
         self.current_row += 1
 
-        linebreak_i18n = advanced_i18n.get('multiline_linebreak', {})
-        HoverInfoLabelWidget(advanced_frame, text=linebreak_i18n.get('label', '...'),
-                             tooltip=linebreak_i18n.get('tooltip', '...'),
-                             row=self.current_row, column=0)
-        ttk.Entry(advanced_frame, textvariable=self.multi_line_line_break_value).grid(row=self.current_row, column=1, sticky='EW', pady=2)
-        self.current_row += 1
-
         storage_field_i18n = advanced_i18n.get('multiline_storage_field', {})
         HoverInfoLabelWidget(advanced_frame, text=storage_field_i18n.get('label', '...'),
                              tooltip=storage_field_i18n.get('tooltip', '...'),

GameSentenceMiner/util/communication/send.py

@@ -4,4 +4,16 @@ from GameSentenceMiner.util.communication.websocket import websocket, Message
 
 async def send_restart_signal():
     if websocket:
-        await websocket.send(json.dumps(Message(function="restart").to_json()))
+        await websocket.send(json.dumps(Message(function="restart").to_json()))
+        
+        
+async def send_notification_signal(title: str, message: str, timeout: int):
+    if websocket:
+        await websocket.send(json.dumps(Message(
+            function="notification",
+            data={
+                "title": title,
+                "message": message,
+                "timeout": timeout
+            }
+        ).to_json()))

GameSentenceMiner/util/communication/websocket.py

@@ -7,11 +7,11 @@ from enum import Enum
 
 from websocket import WebSocket
 
-from GameSentenceMiner.util.communication import Message
+from GameSentenceMiner.util.communication import Message, websocket
 from GameSentenceMiner.util.configuration import get_app_directory, logger
 
 CONFIG_FILE = os.path.join(get_app_directory(), "shared_config.json")
-websocket: WebSocket = None
+# websocket: WebSocket = None
 handle_websocket_message = None
 
 

GameSentenceMiner/util/configuration.py

@@ -470,7 +470,6 @@ class Features:
     open_anki_edit: bool = False
     open_anki_in_browser: bool = True
     browser_query: str = ''
-    backfill_audio: bool = False
     generate_longplay: bool = False
 
 
@@ -761,9 +760,7 @@ class ProfileConfig:
             'notify_on_update', self.features.notify_on_update)
         self.features.open_anki_edit = config_data['features'].get(
             'open_anki_edit', self.features.open_anki_edit)
-        self.features.backfill_audio = config_data['features'].get(
-            'backfill_audio', self.features.backfill_audio)
-
+        
         self.screenshot.width = config_data['screenshot'].get(
             'width', self.screenshot.width)
         self.screenshot.height = config_data['screenshot'].get(
@@ -1176,31 +1173,22 @@ def get_config():
     global config_instance
     if config_instance is None:
         config_instance = load_config()
-        config = config_instance.get_config()
-
-        if config.features.backfill_audio and config.features.full_auto:
-            logger.warning(
-                "Backfill audio is enabled, but full auto is also enabled. Disabling backfill...")
-            config.features.backfill_audio = False
 
     # print(config_instance.get_config())
     return config_instance.get_config()
 
+
 def get_overlay_config():
     global config_instance
     if config_instance is None:
         config_instance = load_config()
     return config_instance.overlay
 
+
 def reload_config():
     global config_instance
     config_instance = load_config()
-    config = config_instance.get_config()
 
-    if config.features.backfill_audio and config.features.full_auto:
-        logger.warning(
-            "Backfill is enabled, but full auto is also enabled. Disabling backfill...")
-        config.features.backfill_audio = False
         
 def get_stats_config():
     global config_instance

GameSentenceMiner/util/db.py

@@ -512,7 +512,7 @@ class GameLinesTable(SQLiteDBTable):
     def update(cls, line_id: str, audio_in_anki: Optional[str] = None, screenshot_in_anki: Optional[str] = None, audio_path: Optional[str] = None, screenshot_path: Optional[str] = None, replay_path: Optional[str] = None, translation: Optional[str] = None):
         line = cls.get(line_id)
         if not line:
-            logger.warning(f"GameLine with id {line_id} not found for update.")
+            logger.warning(f"GameLine with id {line_id} not found for update, maybe testing?")
             return
         if screenshot_path is not None:
             line.screenshot_path = screenshot_path

GameSentenceMiner/util/downloader/download_tools.py

@@ -7,9 +7,10 @@ import platform
 import zipfile
 
 from GameSentenceMiner.util.downloader.Untitled_json import scenes
-from GameSentenceMiner.util.configuration import get_app_directory, get_ffmpeg_path, logger
+from GameSentenceMiner.util.configuration import get_app_directory, get_config, get_ffmpeg_path, logger
 from GameSentenceMiner.util.configuration import get_ffprobe_path
 from GameSentenceMiner.obs import get_obs_path
+from GameSentenceMiner.util.downloader.oneocr_dl import Downloader
 import tempfile
 
 script_dir = os.path.dirname(os.path.abspath(__file__))
@@ -110,41 +111,61 @@ def download_obs_if_needed():
         open(os.path.join(obs_path, "portable_mode"), 'a').close()
         # websocket_config_path = os.path.join(obs_path, 'config', 'obs-studio')
         # if not copy_obs_settings(os.path.join(os.getenv('APPDATA'), 'obs-studio'), websocket_config_path):
-        websocket_config_path = os.path.join(obs_path, 'config', 'obs-studio', 'plugin_config', 'obs-websocket')
-        os.makedirs(websocket_config_path, exist_ok=True)
-
+        write_obs_configs(obs_path)
+        logger.info(f"OBS extracted to {obs_path}.")
+        
+        # remove zip
+        os.unlink(obs_installer)
+    else:
+        logger.error(f"Please install OBS manually from {obs_installer}")
+        
+def write_websocket_configs(obs_path):
+    websocket_config_path = os.path.join(obs_path, 'config', 'obs-studio', 'plugin_config', 'obs-websocket')
+    os.makedirs(websocket_config_path, exist_ok=True)
+    obs_config = get_config().obs
+    
+    if os.path.exists(os.path.join(websocket_config_path, 'config.json')):
+        with open(os.path.join(websocket_config_path, 'config.json'), 'r') as existing_config_file:
+            existing_config = json.load(existing_config_file)
+            if obs_config.port != existing_config.get('server_port', 7274):
+                logger.info(f"OBS WebSocket port changed from {existing_config.get('server_port', 7274)} to {obs_config.port}. Updating config.")
+                existing_config['server_port'] = obs_config.port
+                existing_config['server_password'] = obs_config.password
+                existing_config['auth_required'] = False
+                existing_config['server_enabled'] = True
+                with open(os.path.join(websocket_config_path, 'config.json'), 'w') as config_file:
+                    json.dump(existing_config, config_file, indent=4)
+    else:
         websocket_config = {
             "alerts_enabled": False,
             "auth_required": False,
             "first_load": False,
             "server_enabled": True,
             "server_password": secrets.token_urlsafe(16),
-            "server_port": 7274
+            "server_port": obs_config.port
         }
         with open(os.path.join(websocket_config_path, 'config.json'), 'w') as config_file:
             json.dump(websocket_config, config_file, indent=4)
-        basic_ini_path = os.path.join(obs_path, 'config', 'obs-studio', 'basic', 'profiles', 'Untitled')
-        os.makedirs(basic_ini_path, exist_ok=True)
-        with open(os.path.join(basic_ini_path, 'basic.ini'), 'w') as basic_ini_file:
-            basic_ini_file.write(
-                "[SimpleOutput]\n"
-                f"FilePath={os.path.expanduser('~')}/Videos/GSM\n"
-                "RecRB=true\n"
-                "RecRBTime=300\n"
-                "RecRBSize=512\n"
-                "RecRBPrefix=GSM\n"
-                "RecAudioEncoder=opus\n"
-            )
-        scene_json_path = os.path.join(obs_path, 'config', 'obs-studio', 'basic', 'scenes')
-        os.makedirs(scene_json_path, exist_ok=True)
-        with open(os.path.join(scene_json_path, 'Untitled.json'), 'w') as scene_file:
-            scene_file.write(scenes)
-        logger.info(f"OBS extracted to {obs_path}.")
-        
-        # remove zip
-        os.unlink(obs_installer)
-    else:
-        logger.error(f"Please install OBS manually from {obs_installer}")
+            
+def write_replay_buffer_configs(obs_path):
+    basic_ini_path = os.path.join(obs_path, 'config', 'obs-studio', 'basic', 'profiles', 'GSM')
+    if os.path.exists(os.path.join(basic_ini_path, 'basic.ini')):
+        return
+    os.makedirs(basic_ini_path, exist_ok=True)
+    with open(os.path.join(basic_ini_path, 'basic.ini'), 'w') as basic_ini_file:
+        basic_ini_file.write(
+            "[SimpleOutput]\n"
+            f"FilePath={os.path.expanduser('~')}/Videos/GSM\n"
+            "RecRB=true\n"
+            "RecRBTime=300\n"
+            "RecRBSize=512\n"
+            "RecAudioEncoder=opus\n"
+            "RecRBPrefix=GSM\n"
+        )
+
+def write_obs_configs(obs_path):
+    write_websocket_configs(obs_path)
+    write_replay_buffer_configs(obs_path)
 
 def download_ffmpeg_if_needed():
     ffmpeg_dir = os.path.join(get_app_directory(), 'ffmpeg')
@@ -261,10 +282,15 @@ def download_ocenaudio_if_needed():
     logger.info(f"Ocenaudio extracted to {ocenaudio_dir}.")
     return ocenaudio_exe_path
 
+def download_oneocr_dlls_if_needed():
+    downloader = Downloader()
+    downloader.download_and_extract()
+
 def main():
     download_obs_if_needed()
     download_ffmpeg_if_needed()
     download_ocenaudio_if_needed()
+    download_oneocr_dlls_if_needed()
 
 if __name__ == "__main__":
     main()