GameSentenceMiner 2.11.5__py3-none-any.whl → 2.11.7__py3-none-any.whl

GameSentenceMiner/gsm.py

@@ -12,6 +12,7 @@ from GameSentenceMiner.util.communication.send import send_restart_signal
 from GameSentenceMiner.util.downloader.download_tools import download_obs_if_needed, download_ffmpeg_if_needed
 from GameSentenceMiner.vad import vad_processor
 from GameSentenceMiner.util.model import VADResult
+import time
 
 try:
     import os.path
@@ -45,7 +46,6 @@ try:
     from GameSentenceMiner.web.texthooking_page import run_text_hooker_page
 except Exception as e:
     from GameSentenceMiner.util.configuration import logger, is_linux, is_windows
-    import time
     logger.info("Something bad happened during import/initialization, closing in 5 seconds")
     logger.exception(e)
     time.sleep(5)

GameSentenceMiner/obs.py

@@ -334,6 +334,7 @@ async def register_scene_change_callback(callback):
 
         logger.info("Scene change callback registered.")
 
+
 def get_screenshot(compression=-1):
     try:
         screenshot = os.path.join(configuration.get_temporary_directory(), make_unique_file_name('screenshot.png'))
@@ -377,6 +378,7 @@ def get_screenshot_base64(compression=0, width=None, height=None):
         logger.error(f"Error getting screenshot: {e}")
         return None
 
+
 def update_current_game():
     gsm_state.current_game = get_current_scene()
 

GameSentenceMiner/ocr/gsm_ocr_config.py

@@ -131,6 +131,16 @@ def set_dpi_awareness():
     ctypes.windll.shcore.SetProcessDpiAwareness(per_monitor_awareness)
 
 def get_scene_ocr_config(use_window_as_config=False, window=""):
+    path = get_scene_ocr_config_path(use_window_as_config, window)
+    if not os.path.exists(path):
+        return None
+    with open(path, "r", encoding="utf-8") as f:
+        from json import load
+        data = load(f)
+        ocr_config = OCRConfig.from_dict(data)
+        return ocr_config
+
+def get_scene_ocr_config_path(use_window_as_config=False, window=""):
     ocr_config_dir = get_ocr_config_path()
     try:
         if use_window_as_config:

GameSentenceMiner/ocr/owocr_area_selector.py

@@ -11,7 +11,7 @@ from PIL import Image, ImageTk
 
 # Assuming a mock or real obs module exists in this path
 from GameSentenceMiner import obs
-from GameSentenceMiner.ocr.gsm_ocr_config import set_dpi_awareness, get_window, get_scene_ocr_config
+from GameSentenceMiner.ocr.gsm_ocr_config import set_dpi_awareness, get_window, get_scene_ocr_config_path
 from GameSentenceMiner.util.gsm_utils import sanitize_filename
 
 try:
@@ -123,7 +123,7 @@ class ScreenSelector:
 
     def load_existing_rectangles(self):
         """Loads rectangles from config, converting from percentage to absolute pixels for use."""
-        config_path = get_scene_ocr_config(self.use_window_as_config, self.window_name)
+        config_path = get_scene_ocr_config_path(self.use_window_as_config, self.window_name)
         win_geom = self.target_window_geometry  # Use current geometry for conversion
         win_w, win_h, win_l, win_t = win_geom['width'], win_geom['height'], win_geom['left'], win_geom['top']
 
@@ -168,7 +168,7 @@ class ScreenSelector:
 
     def save_rects(self, event=None):
         """Saves rectangles to config, converting from absolute pixels to percentages."""
-        config_path = get_scene_ocr_config(self.use_window_as_config, self.window_name)
+        config_path = get_scene_ocr_config_path(self.use_window_as_config, self.window_name)
         win_geom = self.target_window_geometry
         win_l, win_t, win_w, win_h = win_geom['left'], win_geom['top'], win_geom['width'], win_geom['height']
         print(f"Saving rectangles to: {config_path} relative to window: {win_geom}")

GameSentenceMiner/ocr/owocr_helper.py

@@ -18,13 +18,15 @@ from PIL import Image
 from rapidfuzz import fuzz
 
 from GameSentenceMiner import obs
+from GameSentenceMiner.util.electron_config import *
 from GameSentenceMiner.ocr.ss_picker import ScreenCropper
 from GameSentenceMiner.owocr.owocr.run import TextFiltering
 from GameSentenceMiner.util.configuration import get_config, get_app_directory, get_temporary_directory
-from GameSentenceMiner.util.electron_config import get_ocr_scan_rate, get_requires_open_window
 from GameSentenceMiner.ocr.gsm_ocr_config import OCRConfig, set_dpi_awareness, get_window, get_ocr_config_path
 from GameSentenceMiner.owocr.owocr import screen_coordinate_picker, run
 from GameSentenceMiner.util.gsm_utils import sanitize_filename, do_text_replacements, OCR_REPLACEMENTS_FILE
+import threading
+import time
 
 CONFIG_FILE = Path("ocr_config.json")
 DEFAULT_IMAGE_PATH = r"C:\Users\Beangate\Pictures\msedge_acbl8GL7Ax.jpg"  # CHANGE THIS
@@ -193,17 +195,17 @@ all_cords = None
 rectangles = None
 last_ocr2_result = []
 
-def do_second_ocr(ocr1_text, time, img, filtering, ignore_furigana_filter=False, ignore_previous_result=False):
+def do_second_ocr(ocr1_text, time, img, filtering, pre_crop_image, ignore_furigana_filter=False, ignore_previous_result=False):
     global twopassocr, ocr2, last_ocr2_result
     try:
         orig_text, text = run.process_and_write_results(img, None, last_ocr2_result if not ignore_previous_result else None, filtering, None,
-                                                        engine=ocr2, furigana_filter_sensitivity=furigana_filter_sensitivity if not ignore_furigana_filter else 0)
+                                                        engine=get_ocr_ocr2(), furigana_filter_sensitivity=furigana_filter_sensitivity if not ignore_furigana_filter else 0)
 
         if compare_ocr_results(last_ocr2_result, orig_text):
             if text:
                 logger.info("Seems like Text we already sent, not doing anything.")
             return
-        save_result_image(img)
+        save_result_image(img, pre_crop_image=pre_crop_image)
         last_ocr2_result = orig_text
         asyncio.run(send_result(text, time))
     except json.JSONDecodeError:
@@ -213,19 +215,19 @@ def do_second_ocr(ocr1_text, time, img, filtering, ignore_furigana_filter=False,
         print(f"Error processing message: {e}")
 
 
-def save_result_image(img):
+def save_result_image(img, pre_crop_image=None):
     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()
+    run.set_last_image(pre_crop_image if pre_crop_image else img)
 
 
 async def send_result(text, time):
     if text:
         text = do_text_replacements(text, OCR_REPLACEMENTS_FILE)
-        if clipboard_output:
+        if get_ocr_send_to_clipboard():
             import pyperclip
             pyperclip.copy(text)
         try:
@@ -244,6 +246,50 @@ previous_orig_text = ""  # Store original text result
 TEXT_APPEARENCE_DELAY = get_ocr_scan_rate() * 1000 + 500  # Adjust as needed
 force_stable = False
 
+class ConfigChangeCheckThread(threading.Thread):
+    def __init__(self):
+        super().__init__(daemon=True)
+        self.last_changes = None
+        self.callbacks = []
+
+    def run(self):
+        global ocr_config
+        while True:
+            try:
+                section_changed, changes = has_ocr_config_changed()
+                if section_changed:
+                    reload_electron_config()
+                    self.last_changes = changes
+                # Only run this block after a change has occurred and then the section is stable (no change)
+                if self.last_changes is not None and not section_changed:
+                    logger.info(f"Detected config changes: {self.last_changes}")
+                    for cb in self.callbacks:
+                        cb(self.last_changes)
+                    if hasattr(run, 'handle_config_change'):
+                        run.handle_config_change()
+                    if any(c in self.last_changes for c in ('ocr1', 'ocr2', 'language', 'furigana_filter_sensitivity')):
+                        reset_callback_vars()
+                    self.last_changes = None
+            except Exception as e:
+                logger.debug(f"ConfigChangeCheckThread error: {e}")
+            time.sleep(0.25)  # Lowered to 0.25s for more responsiveness
+
+    def add_callback(self, callback):
+        self.callbacks.append(callback)
+        
+def reset_callback_vars():
+    global previous_text, last_oneocr_time, text_stable_start_time, previous_orig_text, previous_img, force_stable, previous_ocr1_result, previous_text_list, last_ocr2_result
+    previous_text = None
+    previous_orig_text = ""
+    previous_img = None
+    text_stable_start_time = None
+    last_oneocr_time = None
+    force_stable = False
+    previous_ocr1_result = ""
+    previous_text_list = []
+    last_ocr2_result = ""
+    run.set_last_image(None)
+
 def text_callback(text, orig_text, time, img=None, came_from_ss=False, filtering=None, crop_coords=None):
     global twopassocr, ocr2, previous_text, last_oneocr_time, text_stable_start_time, previous_orig_text, previous_img, force_stable, previous_ocr1_result, previous_text_list
     orig_text_string = ''.join([item for item in orig_text if item is not None]) if orig_text else ""
@@ -251,10 +297,13 @@ def text_callback(text, orig_text, time, img=None, came_from_ss=False, filtering
         save_result_image(img)
         asyncio.run(send_result(text, time))
         return
+    
+    if not text:
+        run.set_last_image(img)
 
     line_start_time = time if time else datetime.now()
 
-    if manual or not twopassocr:
+    if manual or not get_ocr_two_pass_ocr():
         if compare_ocr_results(previous_orig_text, orig_text_string):
             if text:
                 logger.info("Seems like Text we already sent, not doing anything.")
@@ -274,6 +323,7 @@ def text_callback(text, orig_text, time, img=None, came_from_ss=False, filtering
         if previous_text and text_stable_start_time:
             stable_time = text_stable_start_time
             previous_img_local = previous_img
+            pre_crop_image = previous_img_local
             if compare_ocr_results(previous_orig_text, orig_text_string):
                 if text:
                     logger.info("Seems like Text we already sent, not doing anything.")
@@ -281,10 +331,10 @@ def text_callback(text, orig_text, time, img=None, came_from_ss=False, filtering
                 return
             previous_orig_text = orig_text_string
             previous_ocr1_result = previous_text
-            if crop_coords and optimize_second_scan:
+            if crop_coords and get_ocr_optimize_second_scan():
                 previous_img_local.save(os.path.join(get_temporary_directory(), "pre_oneocrcrop.png"))
                 previous_img_local = previous_img_local.crop(crop_coords)
-            second_ocr_queue.put((previous_text, stable_time, previous_img_local, filtering))
+            second_ocr_queue.put((previous_text, stable_time, previous_img_local, filtering, pre_crop_image))
             # threading.Thread(target=do_second_ocr, args=(previous_text, stable_time, previous_img_local, filtering), daemon=True).start()
             previous_img = None
             previous_text = None
@@ -294,7 +344,7 @@ def text_callback(text, orig_text, time, img=None, came_from_ss=False, filtering
         return
 
     # Make sure it's an actual new line before starting the timer
-    if compare_ocr_results(orig_text_string, previous_orig_text):
+    if text and compare_ocr_results(orig_text_string, previous_orig_text):
         return
 
     if not text_stable_start_time:
@@ -315,15 +365,15 @@ def process_task_queue():
             task = second_ocr_queue.get()
             if task is None:  # Exit signal
                 break
-            ocr1_text, stable_time, previous_img_local, filtering = task
-            do_second_ocr(ocr1_text, stable_time, previous_img_local, filtering)
+            ocr1_text, stable_time, previous_img_local, filtering, pre_crop_image = task
+            do_second_ocr(ocr1_text, stable_time, previous_img_local, filtering, pre_crop_image)
         except Exception as e:
             logger.exception(f"Error processing task: {e}")
         finally:
             second_ocr_queue.task_done()
 
 
-def run_oneocr(ocr_config: OCRConfig, rectangles):
+def run_oneocr(ocr_config: OCRConfig, rectangles, config_check_thread):
     global done
     print("Running OneOCR")
     screen_area = None
@@ -344,11 +394,9 @@ def run_oneocr(ocr_config: OCRConfig, rectangles):
                 screen_capture_area=screen_area,
                 # screen_capture_monitor=monitor_config['index'],
                 screen_capture_window=ocr_config.window if ocr_config and ocr_config.window else None,
-                screen_capture_only_active_windows=get_requires_open_window(),
                 screen_capture_delay_secs=get_ocr_scan_rate(), engine=ocr1,
                 text_callback=text_callback,
                 screen_capture_exclusions=exclusions,
-                language=language,
                 monitor_index=None,
                 ocr1=ocr1,
                 ocr2=ocr2,
@@ -356,7 +404,7 @@ def run_oneocr(ocr_config: OCRConfig, rectangles):
                 screen_capture_areas=screen_areas,
                 furigana_filter_sensitivity=furigana_filter_sensitivity,
                 screen_capture_combo=manual_ocr_hotkey if manual_ocr_hotkey and manual else None,
-                keep_line_breaks=keep_newline)
+                config_check_thread=config_check_thread)
     except Exception as e:
         logger.exception(f"Error running OneOCR: {e}")
     done = True
@@ -366,7 +414,7 @@ def run_oneocr(ocr_config: OCRConfig, rectangles):
 def add_ss_hotkey(ss_hotkey="ctrl+shift+g"):
     import keyboard
     secret_ss_hotkey = "F14"
-    filtering = TextFiltering(lang=language)
+    filtering = TextFiltering(lang=get_ocr_language())
     cropper = ScreenCropper()
     def capture():
         print("Taking screenshot...")
@@ -462,6 +510,12 @@ if __name__ == "__main__":
         use_window_for_config = args.use_window_for_config
         keep_newline = args.keep_newline
         obs_ocr = args.obs_ocr
+    
+        # Start config change checker thread
+        config_check_thread = ConfigChangeCheckThread()
+        config_check_thread.start()
+        # Example: add a callback to config_check_thread if needed
+        # config_check_thread.add_callback(lambda: print("Config changed!"))
 
         window = None
         logger.info(f"Received arguments: {vars(args)}")
@@ -487,7 +541,7 @@ if __name__ == "__main__":
         if manual or ocr_config:
             rectangles = ocr_config.rectangles if ocr_config and ocr_config.rectangles else []
             oneocr_threads = []
-            ocr_thread = threading.Thread(target=run_oneocr, args=(ocr_config, rectangles), daemon=True)
+            ocr_thread = threading.Thread(target=run_oneocr, args=(ocr_config, rectangles, config_check_thread), daemon=True)
             ocr_thread.start()
             if not manual:
                 worker_thread = threading.Thread(target=process_task_queue, daemon=True)

GameSentenceMiner/owocr/owocr/ocr.py

@@ -17,6 +17,8 @@ from PIL import Image
 from loguru import logger
 import requests
 
+from GameSentenceMiner.util.electron_config import get_ocr_language
+
 # from GameSentenceMiner.util.configuration import get_temporary_directory
 
 try:
@@ -809,25 +811,8 @@ class OneOCR:
     available = False
 
     def __init__(self, config={}, lang='ja'):
-        if lang == "ja":
-            self.regex = re.compile(r'[\u3041-\u3096\u30A1-\u30FA\u4E00-\u9FFF]')
-        elif lang == "zh":
-            self.regex = re.compile(r'[\u4E00-\u9FFF]')
-        elif lang == "ko":
-            self.regex = re.compile(r'[\uAC00-\uD7AF]')
-        elif lang == "ar":
-            self.regex = re.compile(r'[\u0600-\u06FF\u0750-\u077F\u08A0-\u08FF\uFB50-\uFDFF\uFE70-\uFEFF]')
-        elif lang == "ru":
-            self.regex = re.compile(r'[\u0400-\u04FF\u0500-\u052F\u2DE0-\u2DFF\uA640-\uA69F\u1C80-\u1C8F]')
-        elif lang == "el":
-            self.regex = re.compile(r'[\u0370-\u03FF\u1F00-\u1FFF]')
-        elif lang == "he":
-            self.regex = re.compile(r'[\u0590-\u05FF\uFB1D-\uFB4F]')
-        elif lang == "th":
-            self.regex = re.compile(r'[\u0E00-\u0E7F]')
-        else:
-            self.regex = re.compile(
-            r'[a-zA-Z\u00C0-\u00FF\u0100-\u017F\u0180-\u024F\u0250-\u02AF\u1D00-\u1D7F\u1D80-\u1DBF\u1E00-\u1EFF\u2C60-\u2C7F\uA720-\uA7FF\uAB30-\uAB6F]')
+        self.initial_lang = lang
+        self.get_regex(lang)
         if sys.platform == 'win32':
             if int(platform.release()) < 10:
                 logger.warning('OneOCR is not supported on Windows older than 10!')
@@ -849,7 +834,32 @@ class OneOCR:
             except:
                 logger.warning('Error reading URL from config, OneOCR will not work!')
 
+    def get_regex(self, lang):
+        if lang == "ja":
+            self.regex = re.compile(r'[\u3041-\u3096\u30A1-\u30FA\u4E00-\u9FFF]')
+        elif lang == "zh":
+            self.regex = re.compile(r'[\u4E00-\u9FFF]')
+        elif lang == "ko":
+            self.regex = re.compile(r'[\uAC00-\uD7AF]')
+        elif lang == "ar":
+            self.regex = re.compile(r'[\u0600-\u06FF\u0750-\u077F\u08A0-\u08FF\uFB50-\uFDFF\uFE70-\uFEFF]')
+        elif lang == "ru":
+            self.regex = re.compile(r'[\u0400-\u04FF\u0500-\u052F\u2DE0-\u2DFF\uA640-\uA69F\u1C80-\u1C8F]')
+        elif lang == "el":
+            self.regex = re.compile(r'[\u0370-\u03FF\u1F00-\u1FFF]')
+        elif lang == "he":
+            self.regex = re.compile(r'[\u0590-\u05FF\uFB1D-\uFB4F]')
+        elif lang == "th":
+            self.regex = re.compile(r'[\u0E00-\u0E7F]')
+        else:
+            self.regex = re.compile(
+            r'[a-zA-Z\u00C0-\u00FF\u0100-\u017F\u0180-\u024F\u0250-\u02AF\u1D00-\u1D7F\u1D80-\u1DBF\u1E00-\u1EFF\u2C60-\u2C7F\uA720-\uA7FF\uAB30-\uAB6F]')
+
     def __call__(self, img, furigana_filter_sensitivity=0):
+        lang = get_ocr_language()
+        if lang != self.initial_lang:
+            self.initial_lang = lang
+            self.get_regex(lang)
         img, is_path = input_to_pil_image(img)
         if img.width < 51 or img.height < 51:
             new_width = max(img.width, 51)

GameSentenceMiner/owocr/owocr/run.py

@@ -1,4 +1,5 @@
-from ...ocr.gsm_ocr_config import set_dpi_awareness
+from ...ocr.gsm_ocr_config import set_dpi_awareness, get_scene_ocr_config_path, OCRConfig, get_scene_ocr_config
+from ...util.electron_config import *
 
 try:
     import win32gui
@@ -58,6 +59,7 @@ from .screen_coordinate_picker import get_screen_selection
 from GameSentenceMiner.util.configuration import get_temporary_directory, get_config
 
 config = None
+last_image = None
 
 
 class ClipboardThread(threading.Thread):
@@ -309,9 +311,10 @@ class RequestHandler(socketserver.BaseRequestHandler):
 class TextFiltering:
     accurate_filtering = False
 
-    def __init__(self, lang="ja"):
+    def __init__(self, lang='ja'):
         from pysbd import Segmenter
-        self.segmenter = Segmenter(language=lang, clean=True)
+        self.initial_lang = get_ocr_language() or lang
+        self.segmenter = Segmenter(language=get_ocr_language(), clean=True)
         self.kana_kanji_regex = re.compile(r'[\u3041-\u3096\u30A1-\u30FA\u4E00-\u9FFF]')
         self.chinese_common_regex = re.compile(r'[\u4E00-\u9FFF]')
         self.english_regex = re.compile(r'[a-zA-Z0-9.,!?;:"\'()\[\]{}]')
@@ -349,8 +352,13 @@ class TextFiltering:
             self.classify = langid.classify
 
     def __call__(self, text, last_result):
-        orig_text = self.segmenter.segment(text)
+        lang = get_ocr_language()
+        if self.initial_lang != lang:
+            from pysbd import Segmenter
+            self.segmenter = Segmenter(language=get_ocr_language(), clean=True)
+            self.initial_lang = get_ocr_language()
 
+        orig_text = self.segmenter.segment(text)
         orig_text_filtered = []
         for block in orig_text:
             if "BLANK_LINE" in block:
@@ -419,7 +427,7 @@ class TextFiltering:
 
 
 class ScreenshotThread(threading.Thread):
-    def __init__(self, screen_capture_area, screen_capture_window, screen_capture_exclusions, screen_capture_only_active_windows, screen_capture_areas, screen_capture_on_combo):
+    def __init__(self, screen_capture_area, screen_capture_window, screen_capture_exclusions, screen_capture_areas, screen_capture_on_combo):
         super().__init__(daemon=True)
         self.macos_window_tracker_instance = None
         self.windows_window_tracker_instance = None
@@ -490,7 +498,6 @@ class ScreenshotThread(threading.Thread):
 
 
         if self.screencapture_mode == 2 or self.screen_capture_window:
-            self.screen_capture_only_active_windows = screen_capture_only_active_windows
             area_invalid_error = '"screen_capture_area" must be empty, "screen_N" where N is a screen number starting from 1, a valid set of coordinates, or a valid window name'
             if sys.platform == 'darwin':
                 if config.get_general('screen_capture_old_macos_api') or int(platform.mac_ver()[0].split('.')[0]) < 14:
@@ -523,7 +530,7 @@ class ScreenshotThread(threading.Thread):
                 self.window_id = window_ids[window_index]
                 window_title = window_titles[window_index]
 
-                if self.screen_capture_only_active_windows:
+                if get_ocr_requires_open_window():
                     self.macos_window_tracker_instance = threading.Thread(target=self.macos_window_tracker)
                     self.macos_window_tracker_instance.start()
                 logger.opt(ansi=True).info(f'Selected window: {window_title}')
@@ -567,7 +574,7 @@ class ScreenshotThread(threading.Thread):
             found = win32gui.IsWindow(self.window_handle)
             if not found:
                 break
-            if self.screen_capture_only_active_windows:
+            if get_ocr_requires_open_window():
                 self.screencapture_window_active = self.window_handle == win32gui.GetForegroundWindow()
             else:
                 self.screencapture_window_visible = not win32gui.IsIconic(self.window_handle)
@@ -656,7 +663,14 @@ class ScreenshotThread(threading.Thread):
     def run(self):
         if self.screencapture_mode != 2:
             sct = mss.mss()
+        start = time.time()
         while not terminated:
+            if time.time() - start > 1:
+                start = time.time()
+                section_changed = has_ocr_config_changed()
+                if section_changed:
+                    reload_electron_config()
+
             if not screenshot_event.wait(timeout=0.1):
                 continue
             if self.screencapture_mode == 2 or self.screen_capture_window:
@@ -719,6 +733,11 @@ class ScreenshotThread(threading.Thread):
             else:
                 sct_img = sct.grab(self.sct_params)
                 img = Image.frombytes('RGB', sct_img.size, sct_img.bgra, 'raw', 'BGRX')
+                
+            if not img.getbbox():
+                logger.info("Screen Capture Didn't get Capturing anything, sleeping.")
+                time.sleep(1)
+                continue
 
             import random  # Ensure this is imported at the top of the file if not already
             rand_int = random.randint(1, 20)  # Executes only once out of 10 times
@@ -735,7 +754,12 @@ class ScreenshotThread(threading.Thread):
 
             cropped_sections = []
             for area in self.areas:
-                cropped_sections.append(img.crop((area[0], area[1], area[0] + area[2], area[1] + area[3])))
+                # Ensure crop coordinates are within image bounds
+                left = max(0, area[0])
+                top = max(0, area[1])
+                right = min(img.width, area[0] + area[2])
+                bottom = min(img.height, area[1] + area[3])
+                cropped_sections.append(img.crop((left, top, right, bottom)))
 
             if len(cropped_sections) > 1:
                 combined_width = max(section.width for section in cropped_sections)
@@ -755,13 +779,44 @@ class ScreenshotThread(threading.Thread):
             if rand_int == 1:
                 img.save(os.path.join(get_temporary_directory(), 'after_crop.png'), 'PNG')
 
-            self.write_result(img)
-            screenshot_event.clear()
+            if last_image and are_images_identical(img, last_image):
+                logger.debug("Captured screenshot is identical to the last one, sleeping.")
+                time.sleep(max(.5, get_ocr_scan_rate()))
+            else:
+                self.write_result(img)
+                screenshot_event.clear()
 
         if self.macos_window_tracker_instance:
             self.macos_window_tracker_instance.join()
         elif self.windows_window_tracker_instance:
             self.windows_window_tracker_instance.join()
+            
+            
+def set_last_image(image):
+    global last_image
+    if image == last_image:
+        return
+    try:
+        if last_image is not None and hasattr(last_image, "close"):
+            last_image.close()
+    except Exception:
+        pass
+    last_image = image
+    
+def are_images_identical(img1, img2):
+    if None in (img1, img2):
+        return img1 == img2
+
+    try: 
+        img1 = np.array(img1)
+        img2 = np.array(img2)
+    except Exception:
+        logger.warning("Failed to convert images to numpy arrays for comparison.")
+        # If conversion to numpy array fails, consider them not identical
+        return False
+    
+    return (img1.shape == img2.shape) and np.array_equal(img1, img2)
+
 
 # Use OBS for Screenshot Source (i.e. Linux)
 class OBSScreenshotThread(threading.Thread):
@@ -771,6 +826,9 @@ class OBSScreenshotThread(threading.Thread):
         self.interval = interval
         self.obs_client = None
         self.websocket = None
+        self.current_source = None
+        self.current_source_name = None
+        self.current_scene = None
         self.width = width
         self.height = height
         self.use_periodic_queue = not screen_capture_on_combo
@@ -796,23 +854,51 @@ class OBSScreenshotThread(threading.Thread):
             self.obs_client = None
 
     def run(self):
+        global last_image
         import base64
         import io
         from PIL import Image
         import GameSentenceMiner.obs as obs
 
-        loop = asyncio.new_event_loop()
-        asyncio.set_event_loop(loop)
+        def init_config(source=None, scene=None):
+            obs.update_current_game()
+            self.current_source = source if source else obs.get_active_source()
+            self.current_source_name = self.current_source.get('sourceName') if isinstance(self.current_source, dict) else None
+            self.current_scene = scene if scene else obs.get_current_game()
+            self.ocr_config = get_scene_ocr_config()
+            self.ocr_config.scale_to_custom_size(self.width, self.height)
 
-        self.connect_obs()
-        self.ocr_config.scale_to_custom_size(self.width, self.height)
-        current_source = obs.get_active_source()
-        current_source_name = current_source.get('sourceName') if isinstance(current_source, dict) else None
+        # Register a scene switch callback in obsws
+        def on_scene_switch(scene):
+            logger.info(f"Scene switched to: {scene}. Loading new OCR config.")
+            init_config(scene=scene)
 
+        asyncio.run(obs.register_scene_change_callback(on_scene_switch))
+
+        self.connect_obs()
+        init_config()
+        start = time.time()
         while not terminated:
+            if time.time() - start > 5:
+                if not self.obs_client:
+                    self.connect_obs()
+                else:
+                    try:
+                        self.obs_client.get_version()
+                    except Exception as e:
+                        logger.error(f"Lost connection to OBS: {e}")
+                        self.obs_client = None
+                        self.connect_obs()
+            if not screenshot_event.wait(timeout=0.1):
+                continue
+
+            if not self.ocr_config:
+                time.sleep(1)
+                continue
+
             try:
                 response = self.obs_client.get_source_screenshot(
-                    name=current_source_name,
+                    name=self.current_source_name,
                     img_format='png',
                     quality=75,
                     width=self.width,
@@ -822,6 +908,11 @@ class OBSScreenshotThread(threading.Thread):
                 if response.image_data:
                     image_data = base64.b64decode(response.image_data.split(",")[1])
                     img = Image.open(io.BytesIO(image_data)).convert("RGBA")
+                    
+                    if not img.getbbox():
+                        logger.info("OBS Not Capturing anything, sleeping.")
+                        time.sleep(1)
+                        continue
 
                     for rectangle in self.ocr_config.rectangles:
                         if rectangle.is_excluded:
@@ -832,7 +923,12 @@ class OBSScreenshotThread(threading.Thread):
                     cropped_sections = []
                     for rectangle in [r for r in self.ocr_config.rectangles if not r.is_excluded]:
                         area = rectangle.coordinates
-                        cropped_sections.append(img.crop((area[0], area[1], area[0] + area[2], area[1] + area[3])))
+                        # Ensure crop coordinates are within image bounds
+                        left = max(0, area[0])
+                        top = max(0, area[1])
+                        right = min(img.width, area[0] + area[2])
+                        bottom = min(img.height, area[1] + area[3])
+                        cropped_sections.append(img.crop((left, top, right, bottom)))
 
                     if len(cropped_sections) > 1:
                         combined_width = max(section.width for section in cropped_sections)
@@ -846,17 +942,20 @@ class OBSScreenshotThread(threading.Thread):
                         img = combined_img
                     elif cropped_sections:
                         img = cropped_sections[0]
-
-                    self.write_result(img)
+                        
+                    if last_image and are_images_identical(img, last_image):
+                        logger.debug("Captured screenshot is identical to the last one, sleeping.")
+                        time.sleep(max(.5, get_ocr_scan_rate()))
+                    else:
+                        self.write_result(img)
+                        screenshot_event.clear()
                 else:
                     logger.error("Failed to get screenshot data from OBS.")
 
             except Exception as e:
-                logger.error(f"An unexpected error occurred with OBS connection: {e}")
+                logger.error(f"An unexpected error occurred during OBS Capture : {e}", exc_info=True)
                 continue
 
-            time.sleep(self.interval)
-
 class AutopauseTimer:
     def __init__(self, timeout):
         self.stop_event = threading.Event()
@@ -919,6 +1018,22 @@ def engine_change_handler(user_input='s', is_combo=True):
         logger.opt(ansi=True).info(f'Switched to <{engine_color}>{new_engine_name}</{engine_color}>!')
 
 
+def engine_change_handler_name(engine):
+    global engine_index
+    old_engine_index = engine_index
+
+    for i, instance in enumerate(engine_instances):
+        if instance.name.lower() in engine.lower():
+            engine_index = i
+            break
+
+    if engine_index != old_engine_index:
+        new_engine_name = engine_instances[engine_index].readable_name
+        notifier.send(title='owocr', message=f'Switched to {new_engine_name}')
+        engine_color = config.get_general('engine_color')
+        logger.opt(ansi=True).info(f'Switched to <{engine_color}>{new_engine_name}</{engine_color}>!')
+
+
 def user_input_thread_run():
     def _terminate_handler():
         global terminated
@@ -1034,8 +1149,8 @@ def process_and_write_results(img_or_path, write_to=None, last_result=None, filt
     if res:
         if filtering:
             text, orig_text = filtering(text, last_result)
-        if lang == "ja" or lang == "zh":
-            text = post_process(text, keep_blank_lines=keep_new_lines)
+        if get_ocr_language() == "ja" or get_ocr_language() == "zh":
+            text = post_process(text, keep_blank_lines=get_ocr_keep_newline())
         logger.opt(ansi=True).info(f'Text recognized in {end_time - start_time:0.03f}s using <{engine_color}>{engine_instance.readable_name}</{engine_color}>: {text}')
         if notify and config.get_general('notifications'):
             notifier.send(title='owocr', message='Text recognized: ' + text)
@@ -1086,18 +1201,16 @@ def run(read_from=None,
         screen_capture_exclusions=None,
         screen_capture_window=None,
         screen_capture_delay_secs=None,
-        screen_capture_only_active_windows=None,
         screen_capture_combo=None,
         stop_running_flag=None,
         screen_capture_event_bus=None,
         text_callback=None,
-        language=None,
         monitor_index=None,
         ocr1=None,
         ocr2=None,
         gsm_ocr_config=None,
         furigana_filter_sensitivity=None,
-        keep_line_breaks=False,
+        config_check_thread=None
         ):
     """
     Japanese OCR client
@@ -1132,8 +1245,8 @@ def run(read_from=None,
     if screen_capture_area is None:
         screen_capture_area = config.get_general('screen_capture_area')
 
-    if screen_capture_only_active_windows is None:
-        screen_capture_only_active_windows = config.get_general('screen_capture_only_active_windows')
+    # if screen_capture_only_active_windows is None:
+    #     screen_capture_only_active_windows = config.get_general('screen_capture_only_active_windows')
 
     if screen_capture_exclusions is None:
         screen_capture_exclusions = config.get_general('screen_capture_exclusions')
@@ -1159,9 +1272,6 @@ def run(read_from=None,
     if write_to is None:
         write_to = config.get_general('write_to')
 
-    if language is None:
-        language = config.get_general('language', "ja")
-
     logger.configure(handlers=[{'sink': sys.stderr, 'format': config.get_general('logger_format')}])
 
     if config.has_config:
@@ -1173,14 +1283,10 @@ def run(read_from=None,
 
     global engine_instances
     global engine_keys
-    global lang
-    global keep_new_lines
-    lang = language
     engine_instances = []
     config_engines = []
     engine_keys = []
     default_engine = ''
-    keep_new_lines = keep_line_breaks
 
     if len(config.get_general('engines')) > 0:
         for config_engine in config.get_general('engines').split(','):
@@ -1194,7 +1300,7 @@ def run(read_from=None,
             if config.get_engine(engine_class.name) == None:
                 engine_instance = engine_class()
             else:
-                engine_instance = engine_class(config.get_engine(engine_class.name), lang=lang)
+                engine_instance = engine_class(config.get_engine(engine_class.name), lang=get_ocr_language())
 
             if engine_instance.available:
                 engine_instances.append(engine_instance)
@@ -1270,7 +1376,7 @@ def run(read_from=None,
         global txt_callback
         txt_callback = text_callback
 
-    if 'screencapture' in (read_from, read_from_secondary) or 'obs' in (read_from, read_from_secondary):
+    if any(x in ('screencapture', 'obs') for x in (read_from, read_from_secondary)):
         global screenshot_event
         global take_screenshot
         if screen_capture_combo != '':
@@ -1285,7 +1391,7 @@ def run(read_from=None,
         last_result = ([], engine_index)
 
         screenshot_event = threading.Event()
-        screenshot_thread = ScreenshotThread(screen_capture_area, screen_capture_window, screen_capture_exclusions, screen_capture_only_active_windows, screen_capture_areas, screen_capture_on_combo)
+        screenshot_thread = ScreenshotThread(screen_capture_area, screen_capture_window, screen_capture_exclusions, screen_capture_areas, screen_capture_on_combo)
         screenshot_thread.start()
         filtering = TextFiltering()
         read_from_readable.append('screen capture')
@@ -1347,6 +1453,13 @@ def run(read_from=None,
     if screen_capture_combo:
         logger.opt(ansi=True).info(f'Manual OCR Running... Press <{engine_color}>{screen_capture_combo.replace("<", "").replace(">", "")}</{engine_color}> to run OCR')
 
+    def handle_config_changes(changes):
+        nonlocal last_result
+        if any(c in changes for c in ('ocr1', 'ocr2', 'language', 'furigana_filter_sensitivity')):
+            last_result = ([], engine_index)
+            engine_change_handler_name(get_ocr_ocr1())
+    config_check_thread.add_callback(handle_config_changes)
+
     while not terminated:
         ocr_start_time = datetime.now()
         start_time = time.time()
@@ -1361,7 +1474,7 @@ def run(read_from=None,
                 pass
 
         if (not img) and process_screenshots:
-            if (not paused) and (not screenshot_thread or (screenshot_thread.screencapture_window_active and screenshot_thread.screencapture_window_visible)) and (time.time() - last_screenshot_time) > screen_capture_delay_secs:
+            if (not paused) and (not screenshot_thread or (screenshot_thread.screencapture_window_active and screenshot_thread.screencapture_window_visible)) and (time.time() - last_screenshot_time) > get_ocr_scan_rate():
                 screenshot_event.set()
                 img = periodic_screenshot_queue.get()
                 filter_img = True
@@ -1374,7 +1487,7 @@ def run(read_from=None,
             break
         elif img:
             if filter_img:
-                res, _ = process_and_write_results(img, write_to, last_result, filtering, notify, ocr_start_time=ocr_start_time, furigana_filter_sensitivity=furigana_filter_sensitivity)
+                res, _ = process_and_write_results(img, write_to, last_result, filtering, notify, ocr_start_time=ocr_start_time, furigana_filter_sensitivity=get_ocr_furigana_filter_sensitivity())
                 if res:
                     last_result = (res, engine_index)
             else:
@@ -1398,8 +1511,10 @@ def run(read_from=None,
         directory_watcher_thread.join()
     if unix_socket_server:
         unix_socket_server.shutdown()
-        unix_socket_server_thread.join()
+        unix_socket_server.join()
     if screenshot_thread:
         screenshot_thread.join()
     if key_combo_listener:
         key_combo_listener.stop()
+    if config_check_thread:
+        config_check_thread.join()

GameSentenceMiner/util/electron_config.py

@@ -4,7 +4,7 @@ from dataclasses import dataclass, field
 from typing import List, Optional
 from dataclasses_json import dataclass_json
 
-from GameSentenceMiner.util.configuration import get_app_directory
+from GameSentenceMiner.util.configuration import get_app_directory, logger
 
 
 # @dataclass_json
@@ -42,12 +42,26 @@ class VNConfig:
 @dataclass_json
 @dataclass
 class OCRConfig:
-    twoPassOCR: bool = False
+    twoPassOCR: bool = True
+    optimize_second_scan: bool = True
     ocr1: str = "oneOCR"
     ocr2: str = "glens"
     window_name: str = ""
-    requiresOpenWindow: Optional[bool] = None
-    scanRate: Optional[float] = None
+    language: str = "ja"
+    ocr_screenshots: bool = False
+    furigana_filter_sensitivity: int = 0
+    manualOcrHotkey: str = "Ctrl+Shift+G"
+    areaSelectOcrHotkey: str = "Ctrl+Shift+O"
+    sendToClipboard: bool = True
+    scanRate: float = 0.5
+    requiresOpenWindow: bool = False
+    useWindowForConfig: bool = False
+    lastWindowSelected: str = ""
+    keep_newline: bool = False
+    useObsAsSource: bool = False
+
+    def has_changed(self, other: 'OCRConfig') -> bool:
+        return self.to_dict() != other.to_dict()
 
 @dataclass_json
 @dataclass
@@ -66,15 +80,21 @@ class StoreConfig:
 
 class Store:
     def __init__(self, config_path=os.path.join(get_app_directory(), "electron", "config.json"), defaults: Optional[StoreConfig] = None):
+        self.data: StoreConfig = StoreConfig()
         self.config_path = config_path
         self.defaults = defaults if defaults is not None else StoreConfig()
         self._load_config()
 
     def _load_config(self):
         if os.path.exists(self.config_path):
-            with open(self.config_path, 'r', encoding='utf-8') as f:
-                data = json.load(f)
-                self.data = StoreConfig.from_dict(data)
+            while True:
+                try:
+                    with open(self.config_path, 'r', encoding='utf-8') as f:
+                        data = json.load(f)
+                        self.data = StoreConfig.from_dict(data)
+                    break
+                except (json.JSONDecodeError, IOError) as e:
+                    logger.debug(f"File being written to: {e}. Retrying...")
         else:
             self.data = self.defaults
             self._save_config()
@@ -83,6 +103,9 @@ class Store:
         with open(self.config_path, 'w', encoding='utf-8') as f:
             json.dump(self.data.to_dict(), f, indent=4)
 
+    def reload_config(self):
+        self._load_config()
+
     def get(self, key, default=None):
         keys = key.split('.')
         value = self.data
@@ -127,189 +150,107 @@ class Store:
         print(json.dumps(self.data.to_dict(), indent=4))
 
 # Initialize the store
-store = Store(config_path=os.path.join(get_app_directory(), "electron", "config.json"), defaults=StoreConfig())
-
-# --- Convenience functions ---
-
-def get_auto_update_gsm_app() -> bool:
-    return store.get("autoUpdateGSMApp")
-
-def set_auto_update_gsm_app(auto_update: bool):
-    store.set("autoUpdateGSMApp", auto_update)
-
-def get_auto_update_electron() -> bool:
-    return store.get("autoUpdateElectron")
-
-def set_auto_update_electron(auto_update: bool):
-    store.set("autoUpdateElectron", auto_update)
-
-def get_python_path() -> str:
-    return store.get("pythonPath")
-
-def set_python_path(path: str):
-    store.set("pythonPath", path)
-
-# OCR
-
-def get_ocr_config() -> OCRConfig:
-    ocr_data = store.get("OCR")
-    return ocr_data if isinstance(ocr_data, OCRConfig) else OCRConfig.from_dict(ocr_data) if isinstance(ocr_data, dict) else OCRConfig()
-
-def set_ocr_config(config: OCRConfig):
-    store.set("OCR", config)
-
-def get_two_pass_ocr() -> bool:
-    return store.get("OCR.twoPassOCR")
-
-def set_two_pass_ocr(two_pass: bool):
-    store.set("OCR.twoPassOCR", two_pass)
-
-def get_ocr1() -> str:
-    return store.get("OCR.ocr1")
-
-def set_ocr1(ocr: str):
-    store.set("OCR.ocr1", ocr)
-
-def get_ocr2() -> str:
-    return store.get("OCR.ocr2")
-
-def set_ocr2(ocr: str):
-    store.set("OCR.ocr2", ocr)
-
-def get_window_name() -> str:
-    return store.get("OCR.window_name")
-
-def set_window_name(name: str):
-    store.set("OCR.window_name", name)
-
-def get_requires_open_window() -> Optional[bool]:
-    return store.get("OCR.requiresOpenWindow")
-
-def set_requires_open_window(requires_open_window: Optional[bool]):
-    store.set("OCR.requiresOpenWindow", requires_open_window)
-
-def get_ocr_scan_rate() -> Optional[int]:
-    return store.get("OCR.scanRate")
-
-def set_ocr_scan_rate(scan_rate: Optional[int]):
-    store.set("OCR.scanRate", scan_rate)
-
-# Yuzu config getters and setters
-def get_yuzu_config() -> YuzuConfig:
-    yuzu_data = store.get('yuzu')
-    return yuzu_data if isinstance(yuzu_data, YuzuConfig) else YuzuConfig.from_dict(yuzu_data) if isinstance(yuzu_data, dict) else YuzuConfig()
-
-def set_yuzu_config(config: YuzuConfig):
-    store.set('yuzu', config)
-
-
-# Yuzu emulator path getters and setters
-def get_yuzu_emu_path() -> str:
-    return store.get('yuzu.emuPath')
-
-def set_yuzu_emu_path(path: str):
-    store.set('yuzu.emuPath', path)
-
-# Yuzu ROMs path getters and setters
-def get_yuzu_roms_path() -> str:
-    return store.get('yuzu.romsPath')
-
-def set_yuzu_roms_path(path: str):
-    store.set('yuzu.romsPath', path)
-
-def get_launch_yuzu_game_on_start() -> str:
-    return store.get("yuzu.launchGameOnStart")
-
-def set_launch_yuzu_game_on_start(path: str):
-    store.set("yuzu.launchGameOnStart", path)
-
-def get_last_yuzu_game_launched() -> str:
-    return store.get("yuzu.lastGameLaunched")
-
-def set_last_yuzu_game_launched(path: str):
-    store.set("yuzu.lastGameLaunched", path)
-
-# Agent scripts path getters and setters
-def get_agent_scripts_path() -> str:
-    return store.get('agentScriptsPath')
-
-def set_agent_scripts_path(path: str):
-    store.set('agentScriptsPath', path)
-
-def set_agent_path(path: str):
-    store.set('agentPath', path)
-
-def get_agent_path() -> str:
-    return store.get('agentPath')
-
-def get_start_console_minimized() -> bool:
-    return store.get("startConsoleMinimized")
-
-def set_start_console_minimized(should_minimize: bool):
-    store.set("startConsoleMinimized", should_minimize)
-
-def get_vns() -> List[str]:
-    return store.get('VN.vns')
-
-def set_vns(vns: List[str]):
-    store.set('VN.vns', vns)
-
-def get_textractor_path() -> str:
-    return store.get("VN.textractorPath")
-
-def set_textractor_path(path: str):
-    store.set("VN.textractorPath", path)
-
-def get_launch_vn_on_start() -> str:
-    return store.get("VN.launchVNOnStart")
-
-def set_launch_vn_on_start(vn: str):
-    store.set("VN.launchVNOnStart", vn)
-
-def get_last_vn_launched() -> str:
-    return store.get("VN.lastVNLaunched")
-
-def set_last_vn_launched(vn: str):
-    store.set("VN.lastVNLaunched", vn)
-
-def get_steam_path() -> str:
-    return store.get('steam.steamPath')
-
-def set_steam_path(path: str):
-    store.set('steam.steamPath', path)
-
-def get_launch_steam_on_start() -> int:
-    return store.get('steam.launchSteamOnStart')
-
-def set_launch_steam_on_start(game_id: int):
-    store.set('steam.launchSteamOnStart', game_id)
-
-def get_last_steam_game_launched() -> int:
-    return store.get('steam.lastGameLaunched')
-
-def set_last_steam_game_launched(game_id: int):
-    store.set('steam.lastGameLaunched', game_id)
-
-# def get_steam_games() -> List[SteamGame]:
-#     steam_games_data = store.get('steam.steamGames')
-#     return [SteamGame.from_dict(game_data) for game_data in steam_games_data] if isinstance(steam_games_data, list) else []
-
-# def set_steam_games(games: List[SteamGame]):
-#     store.set('steam.steamGames', [game.to_dict() for game in games])
-
-# if __name__ == "__main__":
-#     # Example usage:
-#     print(f"Initial Yuzu Emulator Path: {get_yuzu_emu_path()}")
-#     set_yuzu_emu_path("D:\\NewEmulators\\yuzu\\yuzu.exe")
-#     print(f"Updated Yuzu Emulator Path: {get_yuzu_emu_path()}")
-#
-#     ocr_config = get_ocr_config()
-#     print(f"Initial Two-Pass OCR: {ocr_config.twoPassOCR}")
-#     set_two_pass_ocr(True)
-#     print(f"Updated Two-Pass OCR: {get_two_pass_ocr()}")
-#
-#     steam_games = get_steam_games()
-#     print(f"Initial Steam Games: {[game.name for game in steam_games]}")
-#     new_games = [SteamGame(123, "Game One"), SteamGame(456, "Game Two")]
-#     set_steam_games(new_games)
-#     print(f"Updated Steam Games: {[game.name for game in get_steam_games()]}")
+electron_store = Store(config_path=os.path.join(get_app_directory(), "electron", "config.json"), defaults=StoreConfig())
+
+
+# def has_section_changed(section_class: type) -> bool:
+#     global electron_store
+#     # Get the attribute name from the class (e.g. OCRConfig -> OCR)
+#     section_name = None
+#     for attr, value in StoreConfig.__dataclass_fields__.items():
+#         if value.type == section_class:
+#             section_name = attr
+#             break
+#     if not section_name:
+#         return False
+#     if not os.path.exists(electron_store.config_path):
+#         return False
+#     with open(electron_store.config_path, 'r', encoding='utf-8') as f:
+#         data = json.load(f)
+#         current = StoreConfig.from_dict(data)
+#         current_section = getattr(current, section_name)
+#         old_section = getattr(electron_store, section_name)
+#         if hasattr(current_section, 'to_dict') and hasattr(old_section, 'to_dict'):
+#             return current_section.to_dict() != old_section.to_dict()
+#         electron_store = Store(config_path=electron_store.config_path)
+#         return True
+
+# Helper Methods
+def get_electron_store() -> Store:
+    global electron_store
+    return electron_store
+
+def get_ocr_two_pass_ocr():
+    return electron_store.data.OCR.twoPassOCR
+
+def get_ocr_optimize_second_scan():
+    return electron_store.data.OCR.optimize_second_scan
+
+def get_ocr_ocr1():
+    return electron_store.data.OCR.ocr1
+
+def get_ocr_ocr2():
+    return electron_store.data.OCR.ocr2
+
+def get_ocr_window_name():
+    return electron_store.data.OCR.window_name or ""
+
+def get_ocr_language():
+    return electron_store.data.OCR.language or "ja"
+
+def get_ocr_ocr_screenshots():
+    return electron_store.data.OCR.ocr_screenshots
+
+def get_ocr_furigana_filter_sensitivity():
+    return electron_store.data.OCR.furigana_filter_sensitivity
+
+def get_ocr_manual_ocr_hotkey():
+    return electron_store.data.OCR.manualOcrHotkey
+
+def get_ocr_area_select_ocr_hotkey():
+    return electron_store.data.OCR.areaSelectOcrHotkey
+
+def get_ocr_send_to_clipboard():
+    return electron_store.data.OCR.sendToClipboard
+
+def get_ocr_scan_rate():
+    return electron_store.data.OCR.scanRate
+
+def get_ocr_requires_open_window():
+    return electron_store.data.OCR.requiresOpenWindow
+
+def get_ocr_use_window_for_config():
+    return electron_store.data.OCR.useWindowForConfig
+
+def get_ocr_last_window_selected():
+    return electron_store.data.OCR.lastWindowSelected
+
+def get_ocr_keep_newline():
+    return electron_store.data.OCR.keep_newline
+
+def get_ocr_use_obs_as_source():
+    return electron_store.data.OCR.useObsAsSource
+
+def has_ocr_config_changed() -> bool:
+    global electron_store
+    if not os.path.exists(electron_store.config_path):
+        return False, {}
+    with open(electron_store.config_path, 'r', encoding='utf-8') as f:
+        data = json.load(f)
+        current = StoreConfig.from_dict(data)
+        current_section = current.OCR
+        old_section = electron_store.data.OCR
+    if not (hasattr(current_section, 'to_dict') and hasattr(old_section, 'to_dict')):
+        return False, {}
+    current_dict = current_section.to_dict()
+    old_dict = old_section.to_dict()
+    if current_dict != old_dict:
+        changes = {k: (old_dict[k], current_dict[k]) for k in current_dict if old_dict.get(k) != current_dict.get(k)}
+        # logger.info(f"OCR Config changes detected: {changes}")
+        return True, changes
+    return False, {}
+
+def reload_electron_config():
+    global electron_store
+    electron_store.reload_config()
+    return electron_store

{gamesentenceminer-2.11.5.dist-info → gamesentenceminer-2.11.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: GameSentenceMiner
-Version: 2.11.5
+Version: 2.11.7
 Summary: A tool for mining sentences from games. Update: Full UI Re-design
 Author-email: Beangate <bpwhelan95@gmail.com>
 License: MIT License
@@ -23,7 +23,8 @@ Requires-Dist: rapidfuzz~=3.9.7
 Requires-Dist: plyer~=2.1.0
 Requires-Dist: keyboard~=0.13.5
 Requires-Dist: websockets~=15.0.1
-Requires-Dist: stable-ts~=2.19.0
+Requires-Dist: openai-whisper
+Requires-Dist: stable-ts-whisperless
 Requires-Dist: silero-vad~=5.1.2
 Requires-Dist: ttkbootstrap~=1.10.1
 Requires-Dist: dataclasses_json~=0.6.7

{gamesentenceminer-2.11.5.dist-info → gamesentenceminer-2.11.7.dist-info}/RECORD

@@ -2,8 +2,8 @@ GameSentenceMiner/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU
 GameSentenceMiner/anki.py,sha256=3BVFXAM7tpJAxHMbsMpnMHUoDfyqHQ1JSYJThW18QWA,16846
 GameSentenceMiner/config_gui.py,sha256=QTK1yBDcfHaIUR_JyekkRQY9CVI_rh3Cae0bi7lviIo,99198
 GameSentenceMiner/gametext.py,sha256=6VkjmBeiuZfPk8T6PHFdIAElBH2Y_oLVYvmcafqN7RM,6747
-GameSentenceMiner/gsm.py,sha256=wTERcvG37SeDel51TCFusoQqk5B_b11YY4QZMTF0a6s,24954
-GameSentenceMiner/obs.py,sha256=rapxY9PTDczGr7e8_41hVuD5VoRExe3IFFbSWZcYDsQ,15470
+GameSentenceMiner/gsm.py,sha256=qVHxnvly-yJ85v9RAxsGN2MqZxU-C1JA5wSRxVxMPMg,24950
+GameSentenceMiner/obs.py,sha256=450jRo2jeOMtlDJN3doNT2wJ5z5YQ0entamxdaLE8mo,15472
 GameSentenceMiner/vad.py,sha256=Xj_9TM0fiaz9K8JcmW0QqGYASFnPEmYepsTHQrxP38c,18711
 GameSentenceMiner/ai/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 GameSentenceMiner/ai/ai_prompting.py,sha256=ojp7i_xg2YB1zALgFbivwtXPMVkThnSbPoUiAs-nz_g,25892
@@ -16,22 +16,22 @@ GameSentenceMiner/assets/icon512.png,sha256=HxUj2GHjyQsk8NV433256UxU9phPhtjCY-YB
 GameSentenceMiner/assets/icon64.png,sha256=N8xgdZXvhqVQP9QUK3wX5iqxX9LxHljD7c-Bmgim6tM,9301
 GameSentenceMiner/assets/pickaxe.png,sha256=VfIGyXyIZdzEnVcc4PmG3wszPMO1W4KCT7Q_nFK6eSE,1403829
 GameSentenceMiner/ocr/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-GameSentenceMiner/ocr/gsm_ocr_config.py,sha256=76IuoOMsBxNvU8z8lixqz58YSZpenNVugnHjrUXgCf4,4963
+GameSentenceMiner/ocr/gsm_ocr_config.py,sha256=Ezj-0k6Wo-una91FvYhMp6KGkRhWYihXzLAoh_Wu2xY,5329
 GameSentenceMiner/ocr/ocrconfig.py,sha256=_tY8mjnzHMJrLS8E5pHqYXZjMuLoGKYgJwdhYgN-ny4,6466
-GameSentenceMiner/ocr/owocr_area_selector.py,sha256=Aj6t-cCePPeYNSF-XxQKo2gVNWmWqK3f3qR-0vxdtuE,25523
-GameSentenceMiner/ocr/owocr_helper.py,sha256=sxmZcori9_ujldclwQFpmMwTyfJyflAQ3mn_3BvIdQs,22888
+GameSentenceMiner/ocr/owocr_area_selector.py,sha256=O8qKOTDglk-D4N-2_ORLeZacXT-OVOCNxUI8sQHAlx4,25538
+GameSentenceMiner/ocr/owocr_helper.py,sha256=3sJW3SmXghUKwCFIHtweEq0t42jcBOyBhFbIHTvxYwc,25301
 GameSentenceMiner/ocr/ss_picker.py,sha256=0IhxUdaKruFpZyBL-8SpxWg7bPrlGpy3lhTcMMZ5rwo,5224
 GameSentenceMiner/owocr/owocr/__init__.py,sha256=87hfN5u_PbL_onLfMACbc0F5j4KyIK9lKnRCj6oZgR0,49
 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=xAhqCfVY2xKKvUhskAiAaYiL3yQrAl8oYi5GU46NOgI,59392
-GameSentenceMiner/owocr/owocr/run.py,sha256=824KFS5v3c4ZLx7RYafBOezvFmnB4Idexf4mJAJhfp8,61100
+GameSentenceMiner/owocr/owocr/ocr.py,sha256=z0w7kcPjXvFabMQTWaQyiBehxmjeIVaS2p53yvFyPbg,59707
+GameSentenceMiner/owocr/owocr/run.py,sha256=p7DBHTbhey1DeW1SRqNQ5-y3H4Cq2zoMPCMED5C0Rws,65945
 GameSentenceMiner/owocr/owocr/screen_coordinate_picker.py,sha256=Na6XStbQBtpQUSdbN3QhEswtKuU1JjReFk_K8t5ezQE,3395
 GameSentenceMiner/util/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 GameSentenceMiner/util/audio_offset_selector.py,sha256=8Stk3BP-XVIuzRv9nl9Eqd2D-1yD3JrgU-CamBywJmY,8542
 GameSentenceMiner/util/configuration.py,sha256=vwBehuEP2QVvbsyJx5x1EPXZEOtGsqeIQjlEES0vVdQ,28999
-GameSentenceMiner/util/electron_config.py,sha256=3VmIrcXhC-wIMMc4uqV85NrNenRl4ZUbnQfSjWEwuig,9852
+GameSentenceMiner/util/electron_config.py,sha256=8LZwl-T_uF5z_ig-IZcm9QI-VKaD7zaHX9u6MaLYuo4,8648
 GameSentenceMiner/util/ffmpeg.py,sha256=t0tflxq170n8PZKkdw8fTZIUQfXD0p_qARa9JTdhBTc,21530
 GameSentenceMiner/util/gsm_utils.py,sha256=iRyLVcodMptRhkCzLf3hyqc6_RCktXnwApi6mLju6oQ,11565
 GameSentenceMiner/util/model.py,sha256=AaOzgqSbaN7yks_rr1dQpLQR45FpBYdoLebMbrIYm34,6638
@@ -63,9 +63,9 @@ GameSentenceMiner/web/templates/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm
 GameSentenceMiner/web/templates/index.html,sha256=Gv3CJvNnhAzIVV_QxhNq4OD-pXDt1vKCu9k6WdHSXuA,215343
 GameSentenceMiner/web/templates/text_replacements.html,sha256=tV5c8mCaWSt_vKuUpbdbLAzXZ3ATZeDvQ9PnnAfqY0M,8598
 GameSentenceMiner/web/templates/utility.html,sha256=3flZinKNqUJ7pvrZk6xu__v67z44rXnaK7UTZ303R-8,16946
-gamesentenceminer-2.11.5.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-gamesentenceminer-2.11.5.dist-info/METADATA,sha256=xaKLwY8WkbwAYG_32q_mg8xeJnuT5S778I0CyIgonXo,7319
-gamesentenceminer-2.11.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-gamesentenceminer-2.11.5.dist-info/entry_points.txt,sha256=2APEP25DbfjSxGeHtwBstMH8mulVhLkqF_b9bqzU6vQ,65
-gamesentenceminer-2.11.5.dist-info/top_level.txt,sha256=V1hUY6xVSyUEohb0uDoN4UIE6rUZ_JYx8yMyPGX4PgQ,18
-gamesentenceminer-2.11.5.dist-info/RECORD,,
+gamesentenceminer-2.11.7.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+gamesentenceminer-2.11.7.dist-info/METADATA,sha256=bJTODm-zidIxVgTh8e7jE1IPLn1NFv39ReZpda0JQ68,7353
+gamesentenceminer-2.11.7.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+gamesentenceminer-2.11.7.dist-info/entry_points.txt,sha256=2APEP25DbfjSxGeHtwBstMH8mulVhLkqF_b9bqzU6vQ,65
+gamesentenceminer-2.11.7.dist-info/top_level.txt,sha256=V1hUY6xVSyUEohb0uDoN4UIE6rUZ_JYx8yMyPGX4PgQ,18
+gamesentenceminer-2.11.7.dist-info/RECORD,,