GameSentenceMiner 2.8.36__py3-none-any.whl → 2.8.37__py3-none-any.whl

GameSentenceMiner/communication/send.py

@@ -2,6 +2,6 @@ import json
 
 from GameSentenceMiner.communication.websocket import websocket, Message
 
-def send_restart_signal():
-    if websocket and websocket.connected:
-        websocket.send(json.dumps(Message(function="restart").to_json()))
+async def send_restart_signal():
+    if websocket:
+        await websocket.send(json.dumps(Message(function="restart").to_json()))

GameSentenceMiner/config_gui.py

@@ -1,3 +1,4 @@
+import asyncio
 import tkinter as tk
 from tkinter import filedialog, messagebox, simpledialog, scrolledtext
 
@@ -7,6 +8,7 @@ from GameSentenceMiner import obs, configuration
 from GameSentenceMiner.communication.send import send_restart_signal
 from GameSentenceMiner.configuration import *
 from GameSentenceMiner.downloader.download_tools import download_ocenaudio_if_needed
+from GameSentenceMiner.model import SceneItem, SceneInfo
 from GameSentenceMiner.package import get_current_version, get_latest_version
 
 settings_saved = False
@@ -79,10 +81,27 @@ class ConfigApp:
         self.create_advanced_tab()
         self.create_ai_tab()
 
+        self.notebook.bind("<<NotebookTabChanged>>", self.on_profiles_tab_selected)
+
         ttk.Button(self.window, text="Save Settings", command=self.save_settings).pack(pady=20)
 
         self.window.withdraw()
 
+    def show_scene_selection(self, matched_configs):
+        selected_scene = None
+        if matched_configs:
+            selection_window = tk.Toplevel(self.window)
+            selection_window.title("Select Profile")
+            ttk.Label(selection_window, text="Multiple profiles match the current scene. Please select the profile:").pack(pady=10)
+            profile_var = tk.StringVar(value=matched_configs[0])
+            profile_dropdown = ttk.Combobox(selection_window, textvariable=profile_var, values=matched_configs, state="readonly")
+            profile_dropdown.pack(pady=5)
+            ttk.Button(selection_window, text="OK", command=lambda: [selection_window.destroy(), setattr(self, 'selected_scene', profile_var.get())]).pack(pady=10)
+            self.window.wait_window(selection_window)
+            selected_scene = self.selected_scene
+        return selected_scene
+
+
     def add_save_hook(self, func):
         on_save.append(func)
 
@@ -104,6 +123,7 @@ class ConfigApp:
 
         # Create a new Config instance
         config = ProfileConfig(
+            scenes=[self.obs_scene_listbox.get(i) for i in self.obs_scene_listbox.curselection()],
             general=General(
                 use_websocket=self.websocket_enabled.get(),
                 use_clipboard=self.clipboard_enabled.get(),
@@ -234,12 +254,15 @@ class ConfigApp:
 
         current_profile = self.profile_combobox.get()
         prev_config = self.master_config.get_config()
+        self.master_config.switch_to_default_if_not_found=self.switch_to_default_if_not_found.get()
         if profile_change:
             self.master_config.current_profile = current_profile
         else:
             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()
 
         # Serialize the config instance to JSON
@@ -250,7 +273,7 @@ class ConfigApp:
 
         if self.master_config.get_config().restart_required(prev_config):
             logger.info("Restart Required for some settings to take affect!")
-            send_restart_signal()
+            asyncio.run(send_restart_signal())
 
         settings_saved = True
         configuration.reload_config()
@@ -684,6 +707,13 @@ class ConfigApp:
         #         ve.grid_configure(row=ve.grid_info()['row'] - 1)
         #         db.grid_configure(row=db.grid_info()['row'] - 1)
 
+    def on_profiles_tab_selected(self, event):
+        try:
+            if self.window.state() != "withdrawn" and self.notebook.tab(self.notebook.select(), "text") == "Profiles":
+                self.refresh_obs_scenes()
+        except Exception as e:
+            logger.debug(e)
+
     @new_tab
     def create_features_tab(self):
         features_frame = ttk.Frame(self.notebook)
@@ -967,16 +997,11 @@ class ConfigApp:
         self.take_screenshot_hotkey.grid(row=self.current_row, column=1)
         self.add_label_and_increment_row(hotkeys_frame, "Hotkey to take a screenshot.", row=self.current_row, column=2)
 
-        ttk.Label(hotkeys_frame, text="Open Utility Hotkey:").grid(row=self.current_row, column=0, sticky='W')
-        self.open_utility_hotkey = ttk.Entry(hotkeys_frame)
-        self.open_utility_hotkey.insert(0, self.settings.hotkeys.open_utility)
-        self.open_utility_hotkey.grid(row=self.current_row, column=1)
-        self.add_label_and_increment_row(hotkeys_frame, "Hotkey to open the text utility.", row=self.current_row, column=2)
-
 
     @new_tab
     def create_profiles_tab(self):
         profiles_frame = ttk.Frame(self.notebook)
+
         self.notebook.add(profiles_frame, text='Profiles')
 
         ttk.Label(profiles_frame, text="Select Profile:").grid(row=self.current_row, column=0, sticky='W')
@@ -990,6 +1015,32 @@ class ConfigApp:
         ttk.Button(profiles_frame, text="Copy Profile", command=self.copy_profile).grid(row=self.current_row, column=1, pady=5)
         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.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.grid(row=self.current_row, column=1)
+        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)
+
+        ttk.Label(profiles_frame, text="Switch To Default If Not Found:").grid(row=self.current_row, column=0, sticky='W')
+        self.switch_to_default_if_not_found = tk.BooleanVar(value=self.master_config.switch_to_default_if_not_found)
+        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 refresh_obs_scenes(self):
+        scenes = obs.get_obs_scenes()
+        obs_scene_names = [scene['sceneName'] for scene in scenes]
+        self.obs_scene_listbox.delete(0, tk.END)  # Clear existing items
+        for scene_name in obs_scene_names:
+            self.obs_scene_listbox.insert(tk.END, scene_name)  # Add each scene to the Listbox
+        for i, scene in enumerate(eval(self.obs_scene_var.get())):  # Parse the string as a tuple
+            if scene.strip() in self.settings.scenes:  # Use strip() to remove extra spaces
+                self.obs_scene_listbox.select_set(i)  # Select the item in the Listbox
+                self.obs_scene_listbox.activate(i)
+                self.obs_scene_listbox.update_idletasks()  # Ensure the GUI reflects the changes
 
     @new_tab
     def create_advanced_tab(self):
@@ -1013,7 +1064,6 @@ class ConfigApp:
         ttk.Button(advanced_frame, text="Browse", command=lambda: self.browse_file(self.video_player_path)).grid(row=self.current_row, column=2)
         self.add_label_and_increment_row(advanced_frame, "Path to the video player executable. Will seek to the location of the line in the replay", row=self.current_row, column=3)
 
-
         ttk.Label(advanced_frame, text="Play Latest Video/Audio Hotkey:").grid(row=self.current_row, column=0, sticky='W')
         self.play_latest_audio_hotkey = ttk.Entry(advanced_frame)
         self.play_latest_audio_hotkey.insert(0, self.settings.hotkeys.play_latest_audio)
@@ -1132,6 +1182,7 @@ class ConfigApp:
         print("profile Changed!")
         self.save_settings(profile_change=True)
         self.reload_settings()
+        self.refresh_obs_scenes()
 
     def add_profile(self):
         new_profile_name = simpledialog.askstring("Input", "Enter new profile name:")

GameSentenceMiner/configuration.py

@@ -222,6 +222,7 @@ class Ai:
 @dataclass
 class ProfileConfig:
     name: str = 'Default'
+    scenes: List[str] = field(default_factory=list)
     general: General = field(default_factory=General)
     paths: Paths = field(default_factory=Paths)
     anki: Anki = field(default_factory=Anki)
@@ -304,10 +305,7 @@ class ProfileConfig:
 
     def restart_required(self, previous):
         previous: ProfileConfig
-        if any([previous.general.use_websocket != self.general.use_websocket,
-                previous.general.use_clipboard != self.general.use_clipboard,
-                previous.general.websocket_uri != self.general.websocket_uri,
-                previous.paths.folder_to_watch != self.paths.folder_to_watch,
+        if any([previous.paths.folder_to_watch != self.paths.folder_to_watch,
                 previous.obs.open_obs != self.obs.open_obs,
                 previous.obs.host != self.obs.host,
                 previous.obs.port != self.obs.port
@@ -325,6 +323,7 @@ class ProfileConfig:
 class Config:
     configs: Dict[str, ProfileConfig] = field(default_factory=dict)
     current_profile: str = DEFAULT_CONFIG
+    switch_to_default_if_not_found: bool = True
 
     @classmethod
     def new(cls):

GameSentenceMiner/gametext.py

@@ -28,6 +28,9 @@ async def monitor_clipboard():
 
     skip_next_clipboard = False
     while True:
+        if not get_config().general.use_clipboard:
+            await asyncio.sleep(1)
+            continue
         if not get_config().general.use_both_clipboard_and_websocket and websocket_connected:
             await asyncio.sleep(1)
             skip_next_clipboard = True
@@ -44,8 +47,11 @@ async def monitor_clipboard():
 async def listen_websocket():
     global current_line, current_line_time, reconnecting, websocket_connected
     try_other = False
-    websocket_url = f'ws://{get_config().general.websocket_uri}/gsm'
     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:
@@ -114,13 +120,11 @@ def run_websocket_listener():
 
 
 async def start_text_monitor():
+    util.run_new_thread(run_websocket_listener)
     if get_config().general.use_websocket:
-        util.run_new_thread(run_websocket_listener)
-    if get_config().general.use_clipboard:
-        if get_config().general.use_websocket:
-            if get_config().general.use_both_clipboard_and_websocket:
-                logger.info("Listening for Text on both WebSocket and Clipboard.")
-            else:
-                logger.info("Both WebSocket and Clipboard monitoring are enabled. WebSocket will take precedence if connected.")
-        await monitor_clipboard()
+        if get_config().general.use_both_clipboard_and_websocket:
+            logger.info("Listening for Text on both WebSocket and Clipboard.")
+        else:
+            logger.info("Both WebSocket and Clipboard monitoring are enabled. WebSocket will take precedence if connected.")
+    await monitor_clipboard()
     await asyncio.sleep(1)

GameSentenceMiner/gsm.py

@@ -67,6 +67,7 @@ class VideoToAudioHandler(FileSystemEventHandler):
 
     @staticmethod
     def convert_to_audio(video_path):
+        vad_trimmed_audio = ''
         try:
             if texthooking_page.event_manager.line_for_audio:
                 line: GameLine = texthooking_page.event_manager.line_for_audio
@@ -174,9 +175,9 @@ class VideoToAudioHandler(FileSystemEventHandler):
             logger.debug(f"Some error was hit catching to allow further work to be done: {e}", exc_info=True)
             notification.send_error_no_anki_update()
         finally:
-            if get_config().paths.remove_video and os.path.exists(video_path):
+            if video_path and get_config().paths.remove_video and os.path.exists(video_path):
                 os.remove(video_path)  # Optionally remove the video after conversion
-            if get_config().paths.remove_audio and os.path.exists(vad_trimmed_audio):
+            if vad_trimmed_audio and get_config().paths.remove_audio and os.path.exists(vad_trimmed_audio):
                 os.remove(vad_trimmed_audio)  # Optionally remove the screenshot after conversion
 
 
@@ -289,8 +290,6 @@ def register_hotkeys():
         keyboard.add_hotkey(get_config().hotkeys.take_screenshot, get_screenshot)
     if get_config().hotkeys.play_latest_audio:
         keyboard.add_hotkey(get_config().hotkeys.play_latest_audio, play_most_recent_audio)
-    if get_config().hotkeys.open_utility:
-        keyboard.add_hotkey(get_config().hotkeys.open_utility, texthooking_page.open_texthooker)
 
 
 def get_screenshot():
@@ -386,7 +385,7 @@ def open_multimine(icon, item):
     texthooking_page.open_texthooker()
 
 
-def update_icon():
+def update_icon(profile=None):
     global menu, icon
     # Recreate the menu with the updated button text
     profile_menu = Menu(
@@ -483,7 +482,6 @@ def restart_obs():
         close_obs()
         time.sleep(1)
         obs.start_obs()
-        obs.connect_to_obs()
 
 
 def cleanup():
@@ -558,25 +556,6 @@ def initialize_async():
         threads.append(util.run_new_thread(task))
     return threads
 
-
-def post_init():
-    def do_post_init():
-        global silero_trim, whisper_helper, vosk_helper
-        logger.info("Post-Initialization started.")
-        if get_config().obs.enabled:
-            obs.connect_to_obs()
-            check_obs_folder_is_correct()
-            from GameSentenceMiner.vad import vosk_helper
-            from GameSentenceMiner.vad import whisper_helper
-            if get_config().vad.is_vosk():
-                vosk_helper.get_vosk_model()
-            if get_config().vad.is_whisper():
-                whisper_helper.initialize_whisper_model()
-            if get_config().vad.is_silero():
-                from GameSentenceMiner.vad import silero_trim
-
-    util.run_new_thread(do_post_init)
-
 def handle_websocket_message(message: Message):
     match FunctionName(message.function):
         case FunctionName.QUIT:
@@ -586,19 +565,67 @@ def handle_websocket_message(message: Message):
             close_obs()
         case FunctionName.START_OBS:
             obs.start_obs()
-            obs.connect_to_obs()
         case _:
             logger.debug(f"unknown message from electron websocket: {message.to_json()}")
 
 def post_init2():
     asyncio.run(gametext.start_text_monitor())
 
+
+def async_loop():
+    async def loop():
+        await obs.connect_to_obs()
+        if get_config().obs.enabled:
+            await register_scene_switcher_callback()
+            await check_obs_folder_is_correct()
+        logger.info("Post-Initialization started.")
+        if get_config().vad.is_vosk():
+            from GameSentenceMiner.vad import vosk_helper
+            vosk_helper.get_vosk_model()
+        if get_config().vad.is_whisper():
+            from GameSentenceMiner.vad import whisper_helper
+            whisper_helper.initialize_whisper_model()
+        if get_config().vad.is_silero():
+            from GameSentenceMiner.vad import silero_trim
+
+    asyncio.run(loop())
+
+
+async def register_scene_switcher_callback():
+    def scene_switcher_callback(scene):
+        logger.info(f"Scene changed to: {scene}")
+        all_configured_scenes = [config.scenes for config in get_master_config().configs.values()]
+        print(all_configured_scenes)
+        matching_configs = [name.strip() for name, config in config_instance.configs.items() if scene.strip() in config.scenes]
+        switch_to = None
+
+        if len(matching_configs) > 1:
+            selected_scene = settings_window.show_scene_selection(matched_configs=matching_configs)
+            if selected_scene:
+                switch_to = selected_scene
+            else:
+                return
+        elif matching_configs:
+            switch_to = matching_configs[0]
+        elif get_master_config().switch_to_default_if_not_found:
+            switch_to = configuration.DEFAULT_CONFIG
+
+        if switch_to and switch_to != get_master_config().current_profile:
+            logger.info(f"Switching to profile: {switch_to}")
+            get_master_config().current_profile = switch_to
+            switch_profile_and_save(switch_to)
+            settings_window.reload_settings()
+            update_icon()
+
+    logger.info("Registering scene switcher callback")
+    await obs.register_scene_change_callback(scene_switcher_callback)
+
 async def main(reloading=False):
     global root, settings_window
+    initialize(reloading)
     logger.info("Script started.")
     root = ttk.Window(themename='darkly')
     settings_window = config_gui.ConfigApp(root)
-    initialize(reloading)
     initialize_async()
     observer = Observer()
     observer.schedule(VideoToAudioHandler(), get_config().paths.folder_to_watch, recursive=False)
@@ -608,6 +635,7 @@ async def main(reloading=False):
 
     util.run_new_thread(post_init2)
     util.run_new_thread(run_text_hooker_page)
+    util.run_new_thread(async_loop)
 
     # Register signal handlers for graceful shutdown
     signal.signal(signal.SIGTERM, handle_exit())  # Handle `kill` commands
@@ -619,7 +647,6 @@ async def main(reloading=False):
     try:
         # if get_config().general.open_config_on_startup:
         #     root.after(0, settings_window.show)
-        root.after(50, post_init)
         settings_window.add_save_hook(update_icon)
         settings_window.on_exit = exit_program
         root.mainloop()

GameSentenceMiner/model.py

@@ -83,6 +83,24 @@ class SceneItemsResponse:
 class RecordDirectory:
     recordDirectory: str
 
+
+@dataclass_json
+@dataclass
+class SceneItemInfo:
+    sceneIndex: int
+    sceneName: str
+    sceneUuid: str
+
+
+@dataclass_json
+@dataclass
+class SceneListResponse:
+    scenes: List[SceneItemInfo]
+    currentProgramSceneName: Optional[str] = None
+    currentProgramSceneUuid: Optional[str] = None
+    currentPreviewSceneName: Optional[str] = None
+    currentPreviewSceneUuid: Optional[str] = None
+
 #
 # @dataclass_json
 # @dataclass

GameSentenceMiner/obs.py

@@ -1,21 +1,39 @@
+import asyncio
+import logging
 import os.path
 import subprocess
+import threading
 import time
 import psutil
 
-from obswebsocket import obsws, requests
+import obsws_python as obs
 
 from GameSentenceMiner import util, configuration
 from GameSentenceMiner.configuration import *
 from GameSentenceMiner.model import *
 
-client: obsws = None
+client: obs.ReqClient = None
+event_client: obs.EventClient = None
 obs_process_pid = None
-logging.getLogger('obswebsocket').setLevel(logging.CRITICAL)
 OBS_PID_FILE = os.path.join(configuration.get_app_directory(), 'obs-studio', 'obs_pid.txt')
+obs_connection_manager = None
+logging.getLogger("obsws_python").setLevel(logging.CRITICAL)
 
-# REFERENCE: https://github.com/obsproject/obs-websocket/blob/master/docs/generated/protocol.md
+class OBSConnectionManager(threading.Thread):
+    def __init__(self):
+        super().__init__()
+        self.daemon = True
+        self.running = True
 
+    def run(self):
+        while self.running:
+            time.sleep(5)
+            if not client.get_version():
+                logger.info("OBS WebSocket not connected. Attempting to reconnect...")
+                connect_to_obs()
+
+    def stop(self):
+        self.running = False
 
 def get_obs_path():
     return os.path.join(configuration.get_app_directory(), 'obs-studio/bin/64bit/obs64.exe')
@@ -37,7 +55,6 @@ def start_obs():
                 obs_process_pid = int(f.read().strip())
                 if is_process_running(obs_process_pid):
                     print(f"OBS is already running with PID: {obs_process_pid}")
-                    connect_to_obs()
                     return obs_process_pid
             except ValueError:
                 print("Invalid PID found in file. Launching new OBS instance.")
@@ -59,36 +76,49 @@ def start_obs():
         print(f"Error launching OBS: {e}")
         return None
 
-def check_obs_folder_is_correct():
-    obs_record_directory = get_record_directory()
-    if obs_record_directory and os.path.normpath(obs_record_directory) != os.path.normpath(
-            get_config().paths.folder_to_watch):
-        logger.info("OBS Path Setting wrong, OBS Recording folder in GSM Config")
-        get_config().paths.folder_to_watch = os.path.normpath(obs_record_directory)
-        get_master_config().sync_shared_fields()
-        save_full_config(get_master_config())
+async def wait_for_obs_connected():
+    global client
+    if not client:
+        return False
+    for _ in range(10):
+        try:
+            response = client.get_version()
+            if response:
+                return True
+        except Exception as e:
+            logger.debug(f"Waiting for OBS connection: {e}")
+            await asyncio.sleep(1)
+    return False
+
+async def check_obs_folder_is_correct():
+    if await wait_for_obs_connected():
+        obs_record_directory = get_record_directory()
+        if obs_record_directory and os.path.normpath(obs_record_directory) != os.path.normpath(
+                get_config().paths.folder_to_watch):
+            logger.info("OBS Path Setting wrong, OBS Recording folder in GSM Config")
+            get_config().paths.folder_to_watch = os.path.normpath(obs_record_directory)
+            get_master_config().sync_shared_fields()
+            save_full_config(get_master_config())
+        else:
+            logger.info("OBS Recording path looks correct")
 
 
 def get_obs_websocket_config_values():
     config_path = os.path.join(get_app_directory(), 'obs-studio', 'config', 'obs-studio', 'plugin_config', 'obs-websocket', 'config.json')
 
-        # Check if config file exists
     if not os.path.isfile(config_path):
         raise FileNotFoundError(f"OBS WebSocket config not found at {config_path}")
 
-    # Read the JSON configuration
     with open(config_path, 'r') as file:
         config = json.load(file)
 
-    # Extract values
     server_enabled = config.get("server_enabled", False)
-    server_port = config.get("server_port", 7274)  # Default to 4455 if not set
+    server_port = config.get("server_port", 7274)
     server_password = config.get("server_password", None)
 
     if not server_enabled:
         logger.info("OBS WebSocket server is not enabled. Enabling it now... Restart OBS for changes to take effect.")
         config["server_enabled"] = True
-
         with open(config_path, 'w') as file:
             json.dump(config, file, indent=4)
 
@@ -101,49 +131,69 @@ def get_obs_websocket_config_values():
         full_config.save()
         reload_config()
 
+async def connect_to_obs(retry_count=0):
+    global client, obs_connection_manager, event_client
+    if not get_config().obs.enabled or client:
+        return
 
-connected = False
-
-def on_connect(obs):
-    global connected
-    logger.info("Reconnected to OBS WebSocket.")
-    start_replay_buffer()
-    connected = True
-
-
-def on_disconnect(obs):
-    global connected
-    logger.error("OBS Connection Lost!")
-    connected = False
-
+    if util.is_windows():
+        get_obs_websocket_config_values()
 
-def connect_to_obs(retry_count=0):
-    global client
+    while True:
+        try:
+            client = obs.ReqClient(
+                host=get_config().obs.host,
+                port=get_config().obs.port,
+                password=get_config().obs.password,
+                timeout=1,
+            )
+            event_client = obs.EventClient(
+                host=get_config().obs.host,
+                port=get_config().obs.port,
+                password=get_config().obs.password,
+                timeout=1,
+            )
+            if not obs_connection_manager:
+                obs_connection_manager = OBSConnectionManager()
+                obs_connection_manager.start()
+            update_current_game()
+            break  # Exit the loop once connected
+        except Exception as e:
+            await asyncio.sleep(1)
+            retry_count += 1
+
+def connect_to_obs_sync(retry_count=0):
+    global client, obs_connection_manager, event_client
     if not get_config().obs.enabled or client:
         return
 
     if util.is_windows():
         get_obs_websocket_config_values()
 
-    try:
-        client = obsws(
-            host=get_config().obs.host,
-            port=get_config().obs.port,
-            password=get_config().obs.password,
-            authreconnect=1,
-            on_connect=on_connect,
-            on_disconnect=on_disconnect
-        )
-        client.connect()
-        update_current_game()
-    except Exception as e:
-        if retry_count % 5 == 0:
-            logger.error(f"Failed to connect to OBS WebSocket: {e}. Retrying...")
-        time.sleep(1)
-        connect_to_obs(retry_count=retry_count + 1)
+    while True:
+        try:
+            client = obs.ReqClient(
+                host=get_config().obs.host,
+                port=get_config().obs.port,
+                password=get_config().obs.password,
+                timeout=1,
+            )
+            event_client = obs.EventClient(
+                host=get_config().obs.host,
+                port=get_config().obs.port,
+                password=get_config().obs.password,
+                timeout=1,
+            )
+            if not obs_connection_manager:
+                obs_connection_manager = OBSConnectionManager()
+                obs_connection_manager.start()
+            update_current_game()
+            break  # Exit the loop once connected
+        except Exception as e:
+            time.sleep(1)
+            retry_count += 1
 
 
-# Disconnect from OBS WebSocket
 def disconnect_from_obs():
     global client
     if client:
@@ -151,136 +201,160 @@ def disconnect_from_obs():
         client = None
         logger.info("Disconnected from OBS WebSocket.")
 
-def do_obs_call(request, from_dict = None, retry=10):
-    try:
-        if not client:
-            time.sleep(1)
-            return do_obs_call(request, from_dict, retry - 1)
-        logger.debug("Sending obs call: " + str(request))
-        response = client.call(request)
-        if not response.status and retry > 0:
-            time.sleep(1)
-            return do_obs_call(request, from_dict, retry - 1)
-        if from_dict:
-            return from_dict(response.datain)
-        else:
-            return response.datain
-    except Exception as e:
-        if "socket is already closed" in str(e) or "object has no attribute" in str(e):
-            if retry > 0:
-                time.sleep(1)
-                return do_obs_call(request, from_dict, retry - 1)
-            else:
-                raise e
+def do_obs_call(request, *args, from_dict=None, retry=3):
+    connect_to_obs()
+    if not client:
         return None
+    for _ in range(retry + 1):
+        try:
+            response = request(*args)
+            if response and response.ok:
+                return from_dict(response.datain) if from_dict else response.datain
+            time.sleep(0.3)
+        except Exception as e:
+            logger.error(f"Error calling OBS: {e}")
+            if "socket is already closed" in str(e) or "object has no attribute" in str(e):
+                time.sleep(0.3)
+            else:
+                return None
+    return None
 
 def toggle_replay_buffer():
     try:
-        do_obs_call(requests.ToggleReplayBuffer())
-        logger.info("Replay buffer Toggled.")
+        response = client.toggle_replay_buffer()
+        if response:
+            logger.info("Replay buffer Toggled.")
     except Exception as e:
         logger.error(f"Error toggling buffer: {e}")
 
-
-# Start replay buffer
-def start_replay_buffer(retry=5):
+def start_replay_buffer():
     try:
-        if not get_replay_buffer_status()['outputActive']:
-            do_obs_call(requests.StartReplayBuffer(), retry=0)
+        status = get_replay_buffer_status()
+        if status:
+            client.start_replay_buffer()
     except Exception as e:
-        if "socket is already closed" in str(e):
-            if retry > 0:
-                time.sleep(1)
-                start_replay_buffer(retry - 1)
-            else:
-                logger.error(f"Error starting replay buffer: {e}")
+        logger.error(f"Error starting replay buffer: {e}")
 
 def get_replay_buffer_status():
     try:
-        return do_obs_call(requests.GetReplayBufferStatus())
+        return client.get_replay_buffer_status().output_active
     except Exception as e:
-        logger.error(f"Error getting replay buffer status: {e}")
-
+        logger.warning(f"Error getting replay buffer status: {e}")
+        return None
 
-# Stop replay buffer
 def stop_replay_buffer():
     try:
-        client.call(requests.StopReplayBuffer())
-        logger.error("Replay buffer stopped.")
+        client.stop_replay_buffer()
     except Exception as e:
-        logger.error(f"Error stopping replay buffer: {e}")
+        logger.warning(f"Error stopping replay buffer: {e}")
 
-# Save the current replay buffer
 def save_replay_buffer():
-    replay_buffer_started = do_obs_call(requests.GetReplayBufferStatus())['outputActive']
-    if replay_buffer_started:
-        client.call(requests.SaveReplayBuffer())
-        logger.info("Replay buffer saved. If your log stops bere, make sure your obs output path matches \"Path To Watch\" in GSM settings.")
+    status = get_replay_buffer_status()
+    if status:
+        response = client.save_replay_buffer()
+        if response and response.ok:
+            logger.info("Replay buffer saved. If your log stops here, make sure your obs output path matches \"Path To Watch\" in GSM settings.")
     else:
-        logger.error("Replay Buffer is not active, could not save Replay Buffer!")
-
+        logger.warning("Replay Buffer is not active, could not save Replay Buffer!")
 
 def get_current_scene():
     try:
-        return do_obs_call(requests.GetCurrentProgramScene(), SceneInfo.from_dict, retry=0).sceneName
+        response = client.get_current_program_scene()
+        return response.scene_name if response else ''
     except Exception as e:
         logger.debug(f"Couldn't get scene: {e}")
-    return ''
-
+        return ''
 
 def get_source_from_scene(scene_name):
     try:
-        return do_obs_call(requests.GetSceneItemList(sceneName=scene_name), SceneItemsResponse.from_dict).sceneItems[0]
+        response = client.get_scene_item_list(name=scene_name)
+        return response.scene_items[0] if response and response.scene_items else ''
     except Exception as e:
         logger.error(f"Error getting source from scene: {e}")
         return ''
 
 def get_record_directory():
     try:
-        return do_obs_call(requests.GetRecordDirectory(), RecordDirectory.from_dict).recordDirectory
+        response = client.get_record_directory()
+        return response.record_directory if response else ''
     except Exception as e:
         logger.error(f"Error getting recording folder: {e}")
         return ''
 
+def get_obs_scenes():
+    try:
+        response = client.get_scene_list()
+        return response.scenes if response else None
+    except Exception as e:
+        logger.error(f"Error getting scenes: {e}")
+        return None
+
+async def register_scene_change_callback(callback):
+    global client
+    if await wait_for_obs_connected():
+        if not client:
+            logger.error("OBS client is not connected.")
+            return
+
+        def on_current_program_scene_changed(data):
+            scene_name = data.scene_name
+            if scene_name:
+                callback(scene_name)
+
+        event_client.callback.register(on_current_program_scene_changed)
+
+        logger.info("Scene change callback registered.")
 
 def get_screenshot(compression=-1):
     try:
         screenshot = util.make_unique_file_name(os.path.abspath(
             configuration.get_temporary_directory()) + '/screenshot.png')
         update_current_game()
-        current_source = get_source_from_scene(get_current_game())
-        current_source_name = current_source.sourceName
+        if not configuration.current_game:
+            logger.error("No active game scene found.")
+            return None
+        current_source = get_source_from_scene(configuration.current_game)
+        current_source_name = current_source.get('sourceName') if isinstance(current_source, dict) else None
         if not current_source_name:
-            logger.error("No active scene found.")
-            return
+            logger.error("No active source found in the current scene.")
+            return None
         start = time.time()
         logger.debug(f"Current source name: {current_source_name}")
-        response = client.call(requests.SaveSourceScreenshot(sourceName=current_source_name, imageFormat='png', imageFilePath=screenshot, imageCompressionQuality=compression))
+        response = client.save_source_screenshot(name=current_source_name, img_format='png', width=None, height=None, file_path=screenshot, quality=compression)
         logger.debug(f"Screenshot response: {response}")
         logger.debug(f"Screenshot took {time.time() - start:.3f} seconds to save")
         return screenshot
     except Exception as e:
         logger.error(f"Error getting screenshot: {e}")
+        return None
 
 def get_screenshot_base64():
     try:
-        update_current_game()
-        current_source = get_source_from_scene(get_current_game())
-        current_source_name = current_source.sourceName
+        # update_current_game()
+        current_game = get_current_game()
+        if not current_game:
+            logger.error("No active game scene found.")
+            return None
+        current_source = get_source_from_scene(current_game)
+        current_source_name = current_source.get('sourceName') if isinstance(current_source, dict) else None
         if not current_source_name:
-            logger.error("No active scene found.")
-            return
-        response = do_obs_call(requests.GetSourceScreenshot(sourceName=current_source_name, imageFormat='png', imageCompressionQuality=0))
-        with open('screenshot_response.txt', 'wb') as f:
-            f.write(str(response).encode())
-        return response['imageData']
+            logger.error("No active source found in the current scene.")
+            return None
+        response = client.get_source_screenshot(name=current_source_name, img_format='png', quality=0, width=None, height=None)
+        if response and response.image_data:
+            with open('screenshot_response.txt', 'wb') as f:
+                f.write(str(response).encode())
+            return response.image_data
+        else:
+            logger.error(f"Error getting base64 screenshot: {response}")
+            return None
     except Exception as e:
         logger.error(f"Error getting screenshot: {e}")
+        return None
 
 def update_current_game():
     configuration.current_game = get_current_scene()
 
-
 def get_current_game(sanitize=False):
     if not configuration.current_game:
         update_current_game()
@@ -288,3 +362,44 @@ def get_current_game(sanitize=False):
     if sanitize:
         return util.sanitize_filename(configuration.current_game)
     return configuration.current_game
+
+
+def main():
+    start_obs()
+    connect_to_obs()
+    # Test each method
+    print("Testing `get_obs_path`:", get_obs_path())
+    print("Testing `is_process_running` with PID 1:", is_process_running(1))
+    print("Testing `check_obs_folder_is_correct`:")
+    check_obs_folder_is_correct()
+    print("Testing `get_obs_websocket_config_values`:")
+    try:
+        get_obs_websocket_config_values()
+    except FileNotFoundError as e:
+        print(e)
+    print("Testing `toggle_replay_buffer`:")
+    toggle_replay_buffer()
+    print("Testing `start_replay_buffer`:")
+    start_replay_buffer()
+    print("Testing `get_replay_buffer_status`:", get_replay_buffer_status())
+    print("Testing `stop_replay_buffer`:")
+    stop_replay_buffer()
+    print("Testing `save_replay_buffer`:")
+    save_replay_buffer()
+    current_scene = get_current_scene()
+    print("Testing `get_current_scene`:", current_scene)
+    print("Testing `get_source_from_scene` with dummy scene:", get_source_from_scene(current_scene))
+    print("Testing `get_record_directory`:", get_record_directory())
+    print("Testing `get_obs_scenes`:", get_obs_scenes())
+    print("Testing `get_screenshot`:", get_screenshot())
+    print("Testing `get_screenshot_base64`:")
+    get_screenshot_base64()
+    print("Testing `update_current_game`:")
+    update_current_game()
+    print("Testing `get_current_game`:", get_current_game())
+    disconnect_from_obs()
+
+if __name__ == '__main__':
+    logging.basicConfig(level=logging.INFO)
+    main()
+

GameSentenceMiner/ocr/gsm_ocr_config.py

@@ -50,7 +50,7 @@ class OCRConfig:
         if self.coordinate_system and self.coordinate_system == "percentage" and self.window:
             import pygetwindow as gw
             try:
-                ctypes.windll.shcore.SetProcessDpiAwareness(2)
+                set_dpi_awareness()
                 window = gw.getWindowsWithTitle(self.window)[0]
                 self.window_geometry = WindowGeometry(
                     left=window.left,
@@ -69,3 +69,11 @@ class OCRConfig:
                     ceil(rectangle.coordinates[3] * self.window_geometry.height),
                 ]
 
+# try w10+, fall back to w8.1+
+def set_dpi_awareness():
+    try:
+        awareness_context = -4
+        ctypes.windll.user32.SetProcessDpiAwarenessContext(awareness_context)
+    except AttributeError:
+        per_monitor_awareness = 2
+        ctypes.windll.shcore.SetProcessDpiAwareness(per_monitor_awareness)

GameSentenceMiner/ocr/owocr_area_selector.py

@@ -8,6 +8,7 @@ import mss
 from PIL import Image, ImageTk, ImageDraw
 
 from GameSentenceMiner import obs  # Import your actual obs module
+from GameSentenceMiner.ocr.gsm_ocr_config import set_dpi_awareness
 from GameSentenceMiner.util import sanitize_filename  # Import your actual util module
 
 try:
@@ -42,7 +43,7 @@ class ScreenSelector:
         if not gw:
             raise ImportError("pygetwindow is required but not installed.")
 
-        obs.connect_to_obs()  # Connect to OBS (using mock or real)
+        obs.connect_to_obs_sync()  # Connect to OBS (using mock or real)
         self.window_name = window_name
         print(f"Target window name: {window_name or 'None (Absolute Mode)'}")
         self.sct = mss.mss()
@@ -857,7 +858,7 @@ def get_screen_selection(window_name):
 if __name__ == "__main__":
     target_window_title = None  # Default to absolute coordinates
     # Check for command line arguments to specify window title
-    ctypes.windll.shcore.SetProcessDpiAwareness(2)
+    set_dpi_awareness()
     if len(sys.argv) > 1:
         target_window_title = sys.argv[1]
         print(f"Attempting to target window title from args: '{target_window_title}'")

GameSentenceMiner/ocr/owocr_helper.py

@@ -19,7 +19,7 @@ from rapidfuzz import fuzz
 from GameSentenceMiner import obs, util
 from GameSentenceMiner.configuration import get_config, get_app_directory, get_temporary_directory
 from GameSentenceMiner.electron_config import get_ocr_scan_rate, get_requires_open_window
-from GameSentenceMiner.ocr.gsm_ocr_config import OCRConfig, Rectangle
+from GameSentenceMiner.ocr.gsm_ocr_config import OCRConfig, Rectangle, set_dpi_awareness
 from GameSentenceMiner.owocr.owocr import screen_coordinate_picker, run
 from GameSentenceMiner.owocr.owocr.run import TextFiltering
 from GameSentenceMiner.util import do_text_replacements, OCR_REPLACEMENTS_FILE
@@ -65,7 +65,7 @@ def get_new_game_cords():
     app_dir = Path.home() / "AppData" / "Roaming" / "GameSentenceMiner"
     ocr_config_dir = app_dir / "ocr_config"
     ocr_config_dir.mkdir(parents=True, exist_ok=True)
-    obs.connect_to_obs()
+    obs.connect_to_obs_sync()
     scene = util.sanitize_filename(obs.get_current_scene())
     config_path = ocr_config_dir / f"{scene}.json"
     with open(config_path, 'w') as f:
@@ -79,7 +79,7 @@ def get_ocr_config() -> OCRConfig:
     app_dir = Path.home() / "AppData" / "Roaming" / "GameSentenceMiner"
     ocr_config_dir = app_dir / "ocr_config"
     os.makedirs(ocr_config_dir, exist_ok=True)
-    obs.connect_to_obs()
+    obs.connect_to_obs_sync()
     scene = util.sanitize_filename(obs.get_current_scene())
     config_path = ocr_config_dir / f"{scene}.json"
     if not config_path.exists():
@@ -215,16 +215,25 @@ def do_second_ocr(ocr1_text, rectangle_index, time, img):
         if fuzz.ratio(previous_ocr2_text, text) >= 80:
             logger.info("Seems like the same text from previous ocr2 result, not sending")
             return
-        img.save(os.path.join(get_temporary_directory(), "last_successful_ocr.png"))
+        save_result_image(img)
         last_ocr2_results[rectangle_index] = text
         send_result(text, time)
-        img.close()
     except json.JSONDecodeError:
         print("Invalid JSON received.")
     except Exception as e:
         logger.exception(e)
         print(f"Error processing message: {e}")
 
+
+def save_result_image(img):
+    if isinstance(img, bytes):
+        with open(os.path.join(get_temporary_directory(), "last_successful_ocr.png"), "wb") as f:
+            f.write(img)
+    else:
+        img.save(os.path.join(get_temporary_directory(), "last_successful_ocr.png"))
+        img.close()
+
+
 def send_result(text, time):
     if text:
         text = do_text_replacements(text, OCR_REPLACEMENTS_FILE)
@@ -241,10 +250,14 @@ previous_imgs = {}
 orig_text_results = {} # Store original text results for each rectangle
 TEXT_APPEARENCE_DELAY = get_ocr_scan_rate() * 1000 + 500  # Adjust as needed
 
-def text_callback(text, orig_text, rectangle_index, time, img=None):
+def text_callback(text, orig_text, rectangle_index, time, img=None, came_from_ss=False):
     global twopassocr, ocr2, last_oneocr_results_to_check, last_oneocr_times, text_stable_start_times, orig_text_results
     orig_text_string = ''.join([item for item in orig_text if item is not None]) if orig_text else ""
     # logger.debug(orig_text_string)
+    if came_from_ss:
+        save_result_image(img)
+        send_result(text, time)
+        return
 
     current_time = time if time else datetime.now()
 
@@ -258,10 +271,11 @@ def text_callback(text, orig_text, rectangle_index, time, img=None):
         if previous_orig_text and fuzz.ratio(orig_text_string, previous_orig_text) >= 80:
             logger.info("Seems like Text we already sent, not doing anything.")
             return
-        img.save(os.path.join(get_temporary_directory(), "last_successful_ocr.png"))
+        save_result_image(img)
         send_result(text, time)
         orig_text_results[rectangle_index] = orig_text_string
         last_ocr1_results[rectangle_index] = previous_text
+        return
     if not text:
         if previous_text:
             if rectangle_index in text_stable_start_times:
@@ -312,7 +326,9 @@ def run_oneocr(ocr_config: OCRConfig, i, area=False):
         monitor_config = rect_config.monitor
         screen_area = ",".join(str(c) for c in coords) if area else None
     exclusions = list(rect.coordinates for rect in list(filter(lambda x: x.is_excluded, ocr_config.rectangles)))
-    run.run(read_from="screencapture", write_to="callback",
+    run.run(read_from="screencapture",
+            read_from_secondary="clipboard" if i == 0 else None,
+            write_to="callback",
             screen_capture_area=screen_area,
             # screen_capture_monitor=monitor_config['index'],
             screen_capture_window=ocr_config.window,
@@ -321,7 +337,9 @@ def run_oneocr(ocr_config: OCRConfig, i, area=False):
             text_callback=text_callback,
             screen_capture_exclusions=exclusions,
             rectangle=i,
-            language=language)
+            language=language,
+            monitor_index=ocr_config.window,
+            ocr2=ocr2)
     done = True
 
 
@@ -367,7 +385,7 @@ if __name__ == "__main__":
     logger.info(f"Received arguments: ocr1={ocr1}, ocr2={ocr2}, twopassocr={twopassocr}")
     global ocr_config
     ocr_config: OCRConfig = get_ocr_config()
-    ctypes.windll.shcore.SetProcessDpiAwareness(2)
+    set_dpi_awareness()
     if ocr_config:
         if ocr_config.window:
             start_time = time.time()

GameSentenceMiner/owocr/owocr/run.py

@@ -512,7 +512,7 @@ class ScreenshotClass:
                 if not self.window_handle:
                     raise ValueError(area_invalid_error)
 
-                ctypes.windll.shcore.SetProcessDpiAwareness(2)
+                self.set_dpi_awareness()
 
                 self.windows_window_tracker_instance = threading.Thread(target=self.windows_window_tracker)
                 self.windows_window_tracker_instance.start()
@@ -526,6 +526,25 @@ class ScreenshotClass:
         elif self.windows_window_tracker_instance:
             self.windows_window_tracker_instance.join()
 
+    @staticmethod
+    def set_dpi_awareness():
+        try:
+            # Try Windows 10+ API first
+            awareness_context = -4
+            success = ctypes.windll.user32.SetProcessDpiAwarenessContext(awareness_context)
+            if success:
+                print("Set DPI awareness: PER_MONITOR_AWARE_V2")
+            else:
+                print("Failed to set DPI awareness context (-4); falling back.")
+        except AttributeError:
+            # Fallback for older Windows versions (8.1+)
+            try:
+                per_monitor_awareness = 2
+                ctypes.windll.shcore.SetProcessDpiAwareness(per_monitor_awareness)
+                print("Set DPI awareness: PER_MONITOR_DPI_AWARE")
+            except Exception as e:
+                print("Could not set DPI awareness:", e)
+
     def get_windows_window_handle(self, window_title):
         def callback(hwnd, window_title_part):
             window_title = win32gui.GetWindowText(hwnd)
@@ -881,7 +900,7 @@ def process_and_write_results(img_or_path, write_to=None, last_result=None, filt
         elif write_to == 'clipboard':
             pyperclipfix.copy(text)
         elif write_to == "callback":
-            txt_callback(text, orig_text, rectangle, ocr_start_time, img_or_path)
+            txt_callback(text, orig_text, rectangle, ocr_start_time, img_or_path, bool(engine))
         elif write_to:
             with Path(write_to).open('a', encoding='utf-8') as f:
                 f.write(text + '\n')
@@ -907,6 +926,7 @@ def init_config(parse_args=True):
 
 
 def run(read_from=None,
+        read_from_secondary=None,
         write_to=None,
         engine=None,
         pause_at_startup=None,
@@ -927,6 +947,8 @@ def run(read_from=None,
         rectangle=None,
         text_callback=None,
         language=None,
+        monitor_index=None,
+        ocr2=None,
         ):
     """
     Japanese OCR client
@@ -955,6 +977,9 @@ def run(read_from=None,
     if read_from is None:
         read_from = config.get_general('read_from')
 
+    if read_from_secondary is None:
+        read_from_secondary = config.get_general('read_from_secondary')
+
     if screen_capture_area is None:
         screen_capture_area = config.get_general('screen_capture_area')
 
@@ -1054,7 +1079,6 @@ def run(read_from=None,
     delay_secs = config.get_general('delay_secs')
 
     non_path_inputs = ('screencapture', 'clipboard', 'websocket', 'unixsocket')
-    read_from_secondary = config.get_general('read_from_secondary')
     read_from_path = None
     read_from_readable = []
     terminated = False
@@ -1181,7 +1205,7 @@ def run(read_from=None,
                 if res:
                     last_result = (res, engine_index)
             else:
-                process_and_write_results(img, None, None, notify)
+                process_and_write_results(img, write_to, None, notify=notify, rectangle=rectangle, ocr_start_time=ocr_start_time, engine=ocr2)
             if isinstance(img, Path):
                 if delete_images:
                     Path.unlink(img)

{gamesentenceminer-2.8.36.dist-info → gamesentenceminer-2.8.37.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: GameSentenceMiner
-Version: 2.8.36
+Version: 2.8.37
 Summary: A tool for mining sentences from games. Update: Multi-Line Mining! Fixed!
 Author-email: Beangate <bpwhelan95@gmail.com>
 License: MIT License

{gamesentenceminer-2.8.36.dist-info → gamesentenceminer-2.8.37.dist-info}/RECORD

@@ -1,37 +1,37 @@
 GameSentenceMiner/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 GameSentenceMiner/anki.py,sha256=fu59gdyp1en_yKTK1WOVZX5lwGzGFKvhccXffgkoYlY,14190
-GameSentenceMiner/config_gui.py,sha256=2klOj2DmHhmvtURp4JjhDJ1vn0hN-uWoUu1lS0xDl3s,74246
-GameSentenceMiner/configuration.py,sha256=ndnxuQbLfhMruHld-yK3UjWt1DcXlVhaLRZD8l6SJ0E,22562
+GameSentenceMiner/config_gui.py,sha256=anp13ryjZhZuBcD8JrAffHpqB3yfDKE3SkETvnwAFnk,77372
+GameSentenceMiner/configuration.py,sha256=5XdL7ZBEouj6Rz8pHvWKyTmhdDNs5p6UkdNng589n7Y,22428
 GameSentenceMiner/electron_config.py,sha256=dGcPYCISPehXubYSzsDuI2Gl092MYK0u3bTnkL9Jh1Y,9787
 GameSentenceMiner/ffmpeg.py,sha256=pNgBRaaZ_efvUnqOapMiJbsl8ZbL3eWPwjZPiJH8DhE,14558
-GameSentenceMiner/gametext.py,sha256=VogQDs-VQ4dorqy8uvoklweeS58r3Th_yP-zn36e0u4,5556
-GameSentenceMiner/gsm.py,sha256=WmVhcC_CGjFmqV75NMMVm9hOiiv-ER4Lu5DUF-6IULo,26012
-GameSentenceMiner/model.py,sha256=JdnkT4VoPOXmOpRgFdvERZ09c9wLN6tUJxdrKlGZcqo,5305
+GameSentenceMiner/gametext.py,sha256=hcyZQ69B7xB5ZG85wLzM5au7ZPKxmeUXsmUD26oyk_0,5660
+GameSentenceMiner/gsm.py,sha256=KsFj49e6XtoTDVT3_wTfq_YNkuPqRTkZgWM9PPSnq20,27176
+GameSentenceMiner/model.py,sha256=1lRyJFf_LND_4O16h8CWVqDfosLgr0ZS6ufBZ3qJHpY,5699
 GameSentenceMiner/notification.py,sha256=FY39ChSRK0Y8TQ6lBGsLnpZUFPtFpSy2tweeXVoV7kc,2809
-GameSentenceMiner/obs.py,sha256=-tzVHejaGDXyERaDrRqrKmbgwT13oJKxTivGwfUij7Y,10284
+GameSentenceMiner/obs.py,sha256=m0z9FoHGJIlG2Ol4UR5PpgZjTkag6TssXQC0rhOrsoQ,14485
 GameSentenceMiner/package.py,sha256=YlS6QRMuVlm6mdXx0rlXv9_3erTGS21jaP3PNNWfAH0,1250
 GameSentenceMiner/text_log.py,sha256=MD7LB5D-v4G0Bnm3uGvZQ0aV38Fcj4E0vgq7mmyQ7_4,5157
 GameSentenceMiner/util.py,sha256=LzWGIDZb8NLv-RyrE_d6ycoQEwM1zpaDhWp0LKb6_Zc,8928
 GameSentenceMiner/ai/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 GameSentenceMiner/ai/ai_prompting.py,sha256=O1QBgCL6AkkDyhzxZuW8FPCKgUDfkl_ZlKGcEUfbRnk,9508
 GameSentenceMiner/communication/__init__.py,sha256=_jGn9PJxtOAOPtJ2rI-Qu9hEHVZVpIvWlxKvqk91_zI,638
-GameSentenceMiner/communication/send.py,sha256=oOJdCS6-LNX90amkRn5FL2xqx6THGm56zHR2ntVIFTE,229
+GameSentenceMiner/communication/send.py,sha256=X0MytGv5hY-uUvkfvdCqQA_ljZFmV6UkJ6in1TA1bUE,217
 GameSentenceMiner/communication/websocket.py,sha256=pTcUe_ZZRp9REdSU4qalhPmbT_1DKa7w18j6RfFLELA,3074
 GameSentenceMiner/downloader/Untitled_json.py,sha256=RUUl2bbbCpUDUUS0fP0tdvf5FngZ7ILdA_J5TFYAXUQ,15272
 GameSentenceMiner/downloader/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 GameSentenceMiner/downloader/download_tools.py,sha256=aRfpCqEmKUFRVsGipwY-7PhY6AeWiFJanW4ZCB9e2iE,8124
 GameSentenceMiner/downloader/oneocr_dl.py,sha256=o3ANp5IodEQoQ8GPcJdg9Y8JzA_lictwnebFPwwUZVk,10144
 GameSentenceMiner/ocr/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-GameSentenceMiner/ocr/gsm_ocr_config.py,sha256=-tw5l2wvv_sqUcGS0Y5X9LlXqmFxcCHcwZ76Q93T3I4,2127
+GameSentenceMiner/ocr/gsm_ocr_config.py,sha256=WFTGg2J8FAqoILVbJaMt5XWhF-btXeDnj38Iuz-kf8k,2410
 GameSentenceMiner/ocr/ocrconfig.py,sha256=_tY8mjnzHMJrLS8E5pHqYXZjMuLoGKYgJwdhYgN-ny4,6466
-GameSentenceMiner/ocr/owocr_area_selector.py,sha256=gHvhsgvYmIMKmkq0cDOLzBTnmBAvVyP9JKNlTZouJk8,47141
-GameSentenceMiner/ocr/owocr_helper.py,sha256=_mRqQ8928ovdF5o_4qpK2DGWMmu3cGBYsmpgMtc0adU,17418
+GameSentenceMiner/ocr/owocr_area_selector.py,sha256=Q8ETMHL7BKMA1mbtjrntDLyqCQB0lZ5T4RCZsodjH7Y,47186
+GameSentenceMiner/ocr/owocr_helper.py,sha256=actkNPsLGmhW0n1LGpgqsbiCc98MMRrStXXTsfGSyfI,17871
 GameSentenceMiner/owocr/owocr/__init__.py,sha256=opjBOyGGyEqZCE6YdZPnyt7nVfiwyELHsXA0jAsjm14,25
 GameSentenceMiner/owocr/owocr/__main__.py,sha256=XQaqZY99EKoCpU-gWQjNbTs7Kg17HvBVE7JY8LqIE0o,157
 GameSentenceMiner/owocr/owocr/config.py,sha256=qM7kISHdUhuygGXOxmgU6Ef2nwBShrZtdqu4InDCViE,8103
 GameSentenceMiner/owocr/owocr/lens_betterproto.py,sha256=oNoISsPilVVRBBPVDtb4-roJtAhp8ZAuFTci3TGXtMc,39141
 GameSentenceMiner/owocr/owocr/ocr.py,sha256=dPnDmtG-I24kcfxC3iudeRIVgGhLmiWMGyRiMANcYsA,41573
-GameSentenceMiner/owocr/owocr/run.py,sha256=ZC0sG-3mCyGgg8FPSto9Hd6-k-N18T1hBe-IgsbSBLM,52345
+GameSentenceMiner/owocr/owocr/run.py,sha256=upwGML6oFb_SQNwU5P7tP9pe-dlJEbTo3QTp7ISrxUU,53363
 GameSentenceMiner/owocr/owocr/screen_coordinate_picker.py,sha256=Na6XStbQBtpQUSdbN3QhEswtKuU1JjReFk_K8t5ezQE,3395
 GameSentenceMiner/vad/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 GameSentenceMiner/vad/result.py,sha256=C08HsYH4qVjTRh_dvrWrskmXHJ950w0GWxPjGx_BfGY,275
@@ -52,9 +52,9 @@ GameSentenceMiner/web/static/web-app-manifest-512x512.png,sha256=wyqgCWCrLEUxSRX
 GameSentenceMiner/web/templates/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 GameSentenceMiner/web/templates/text_replacements.html,sha256=tV5c8mCaWSt_vKuUpbdbLAzXZ3ATZeDvQ9PnnAfqY0M,8598
 GameSentenceMiner/web/templates/utility.html,sha256=P659ZU2j7tcbJ5xPO3p7E_SQpkp3CrrFtSvvXJNNuLI,16330
-gamesentenceminer-2.8.36.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-gamesentenceminer-2.8.36.dist-info/METADATA,sha256=2LiaKeCZpA2QMO9kEEmNCuKMS7LlkeUYmeKCPJQarq4,7165
-gamesentenceminer-2.8.36.dist-info/WHEEL,sha256=0CuiUZ_p9E4cD6NyLD6UG80LBXYyiSYZOKDm5lp32xk,91
-gamesentenceminer-2.8.36.dist-info/entry_points.txt,sha256=2APEP25DbfjSxGeHtwBstMH8mulVhLkqF_b9bqzU6vQ,65
-gamesentenceminer-2.8.36.dist-info/top_level.txt,sha256=V1hUY6xVSyUEohb0uDoN4UIE6rUZ_JYx8yMyPGX4PgQ,18
-gamesentenceminer-2.8.36.dist-info/RECORD,,
+gamesentenceminer-2.8.37.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+gamesentenceminer-2.8.37.dist-info/METADATA,sha256=9yT7aEEZ-DC7pFx3T50fWQh2FZlpgEmeckgPHi3PhCc,7165
+gamesentenceminer-2.8.37.dist-info/WHEEL,sha256=0CuiUZ_p9E4cD6NyLD6UG80LBXYyiSYZOKDm5lp32xk,91
+gamesentenceminer-2.8.37.dist-info/entry_points.txt,sha256=2APEP25DbfjSxGeHtwBstMH8mulVhLkqF_b9bqzU6vQ,65
+gamesentenceminer-2.8.37.dist-info/top_level.txt,sha256=V1hUY6xVSyUEohb0uDoN4UIE6rUZ_JYx8yMyPGX4PgQ,18
+gamesentenceminer-2.8.37.dist-info/RECORD,,