GameSentenceMiner 2.8.5__py3-none-any.whl → 2.8.7__py3-none-any.whl

GameSentenceMiner/gsm.py

@@ -1,36 +1,45 @@
-import os.path
-import signal
-from subprocess import Popen
-
-import keyboard
-import psutil
-import ttkbootstrap as ttk
-from PIL import Image, ImageDraw
-from pystray import Icon, Menu, MenuItem
-from watchdog.events import FileSystemEventHandler
-from watchdog.observers import Observer
-
-
-from GameSentenceMiner import anki
-from GameSentenceMiner import config_gui
-from GameSentenceMiner import configuration
-from GameSentenceMiner import ffmpeg
-from GameSentenceMiner import gametext
-from GameSentenceMiner import notification
-from GameSentenceMiner import obs
-from GameSentenceMiner import util
-from GameSentenceMiner.communication import Message
-from GameSentenceMiner.communication.send import send_restart_signal
-from GameSentenceMiner.communication.websocket import connect_websocket, register_websocket_message_handler, \
-    FunctionName
-from GameSentenceMiner.configuration import *
-from GameSentenceMiner.downloader.download_tools import download_obs_if_needed, download_ffmpeg_if_needed
-from GameSentenceMiner.ffmpeg import get_audio_and_trim, get_video_timings
-from GameSentenceMiner.obs import check_obs_folder_is_correct
-from GameSentenceMiner.text_log import GameLine, get_text_event, get_mined_line, get_all_lines
-from GameSentenceMiner.util import *
-from GameSentenceMiner.web import texthooking_page
-from GameSentenceMiner.web.texthooking_page import start_web_server
+import asyncio
+
+try:
+    import os.path
+    import signal
+    from subprocess import Popen
+
+    import keyboard
+    import psutil
+    import ttkbootstrap as ttk
+    from PIL import Image, ImageDraw
+    from pystray import Icon, Menu, MenuItem
+    from watchdog.events import FileSystemEventHandler
+    from watchdog.observers import Observer
+
+
+    from GameSentenceMiner import anki
+    from GameSentenceMiner import config_gui
+    from GameSentenceMiner import configuration
+    from GameSentenceMiner import ffmpeg
+    from GameSentenceMiner import gametext
+    from GameSentenceMiner import notification
+    from GameSentenceMiner import obs
+    from GameSentenceMiner import util
+    from GameSentenceMiner.communication import Message
+    from GameSentenceMiner.communication.send import send_restart_signal
+    from GameSentenceMiner.communication.websocket import connect_websocket, register_websocket_message_handler, \
+        FunctionName
+    from GameSentenceMiner.configuration import *
+    from GameSentenceMiner.downloader.download_tools import download_obs_if_needed, download_ffmpeg_if_needed
+    from GameSentenceMiner.ffmpeg import get_audio_and_trim, get_video_timings
+    from GameSentenceMiner.obs import check_obs_folder_is_correct
+    from GameSentenceMiner.text_log import GameLine, get_text_event, get_mined_line, get_all_lines
+    from GameSentenceMiner.util import *
+    from GameSentenceMiner.web import texthooking_page
+    from GameSentenceMiner.web.texthooking_page import run_text_hooker_page
+except Exception as e:
+    from GameSentenceMiner.configuration import logger
+    import time
+    logger.info("Something bad happened during import/initialization, closing in 5 seconds")
+    logger.exception(e)
+    time.sleep(5)
 
 if is_windows():
     import win32api
@@ -449,10 +458,12 @@ def run_tray():
 
 def close_obs():
     obs.disconnect_from_obs()
-    if obs.obs_process:
+    if obs.obs_process_pid:
         try:
-            subprocess.run(["taskkill", "/PID", str(obs.obs_process.pid), "/F"], check=True, capture_output=True, text=True)
-            print(f"OBS (PID {obs.obs_process.pid}) has been terminated.")
+            subprocess.run(["taskkill", "/PID", str(obs.obs_process_pid), "/F"], check=True, capture_output=True, text=True)
+            print(f"OBS (PID {obs.obs_process_pid}) has been terminated.")
+            if os.path.exists(obs.OBS_PID_FILE):
+                os.remove(obs.OBS_PID_FILE)
         except subprocess.CalledProcessError as e:
             print(f"Error terminating OBS: {e.stderr}")
     else:
@@ -460,9 +471,9 @@ def close_obs():
 
 
 def restart_obs():
-    if obs.obs_process:
+    if obs.obs_process_pid:
         close_obs()
-        time.sleep(2)
+        time.sleep(1)
         obs.start_obs()
         obs.connect_to_obs()
 
@@ -532,7 +543,7 @@ def initialize(reloading=False):
     #         whisper_helper.initialize_whisper_model()
 
 def initialize_async():
-    tasks = [gametext.start_text_monitor, connect_websocket, run_tray]
+    tasks = [connect_websocket, run_tray]
     threads = []
     tasks.append(anki.start_monitoring_anki)
     for task in tasks:
@@ -555,7 +566,6 @@ def post_init():
                 whisper_helper.initialize_whisper_model()
             if get_config().vad.is_silero():
                 from GameSentenceMiner.vad import silero_trim
-        start_web_server()
 
     util.run_new_thread(do_post_init)
 
@@ -572,8 +582,10 @@ def handle_websocket_message(message: Message):
         case _:
             logger.debug(f"unknown message from electron websocket: {message.to_json()}")
 
+def post_init2():
+    asyncio.run(gametext.start_text_monitor())
 
-def main(reloading=False):
+async def main(reloading=False):
     global root, settings_window
     logger.info("Script started.")
     root = ttk.Window(themename='darkly')
@@ -586,12 +598,16 @@ def main(reloading=False):
     if not is_linux():
         register_hotkeys()
 
+    util.run_new_thread(post_init2)
+    util.run_new_thread(run_text_hooker_page)
+
     # Register signal handlers for graceful shutdown
     signal.signal(signal.SIGTERM, handle_exit())  # Handle `kill` commands
     signal.signal(signal.SIGINT, handle_exit())  # Handle Ctrl+C
     if is_windows():
         win32api.SetConsoleCtrlHandler(handle_exit())
 
+
     try:
         # if get_config().general.open_config_on_startup:
         #     root.after(0, settings_window.show)
@@ -612,7 +628,7 @@ def main(reloading=False):
 if __name__ == "__main__":
     logger.info("Starting GSM")
     try:
-        main()
+        asyncio.run(main())
     except Exception as e:
         logger.exception(e)
         time.sleep(5)

GameSentenceMiner/obs.py

@@ -1,6 +1,7 @@
 import os.path
 import subprocess
 import time
+import psutil
 
 from obswebsocket import obsws, requests
 
@@ -9,8 +10,9 @@ from GameSentenceMiner.configuration import *
 from GameSentenceMiner.model import *
 
 client: obsws = None
-obs_process = 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')
 
 # REFERENCE: https://github.com/obsproject/obs-websocket/blob/master/docs/generated/protocol.md
 
@@ -18,20 +20,43 @@ logging.getLogger('obswebsocket').setLevel(logging.CRITICAL)
 def get_obs_path():
     return os.path.join(configuration.get_app_directory(), 'obs-studio/bin/64bit/obs64.exe')
 
+def is_process_running(pid):
+    try:
+        process = psutil.Process(pid)
+        return 'obs' in process.exe()
+    except (psutil.NoSuchProcess, psutil.AccessDenied, OSError):
+        if os.path.exists(OBS_PID_FILE):
+            os.remove(OBS_PID_FILE)
+        return False
+
 def start_obs():
-    global obs_process
+    global obs_process_pid
+    if os.path.exists(OBS_PID_FILE):
+        with open(OBS_PID_FILE, "r") as f:
+            try:
+                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.")
+            except OSError:
+                print("No process found with the stored PID. Launching new OBS instance.")
+
     obs_path = get_obs_path()
     if not os.path.exists(obs_path):
-        logger.error(f"OBS not found at {obs_path}. Please install OBS.")
+        print(f"OBS not found at {obs_path}. Please install OBS.")
         return None
-
     try:
-        obs_process = subprocess.Popen([obs_path, '--disable-shutdown-check', '--portable', '--startreplaybuffer'], cwd=os.path.dirname(obs_path))
-
-        logger.info("OBS launched")
-        return obs_process.pid
+        obs_process = subprocess.Popen([obs_path, '--disable-shutdown-check', '--portable', '--startreplaybuffer', ], cwd=os.path.dirname(obs_path))
+        obs_process_pid = obs_process.pid
+        with open(OBS_PID_FILE, "w") as f:
+            f.write(str(obs_process_pid))
+        print(f"OBS launched with PID: {obs_process_pid}")
+        return obs_process_pid
     except Exception as e:
-        logger.error(f"Error launching OBS: {e}")
+        print(f"Error launching OBS: {e}")
         return None
 
 def check_obs_folder_is_correct():
@@ -69,33 +94,32 @@ def get_obs_websocket_config_values():
 
     if get_config().obs.password == 'your_password':
         logger.info("OBS WebSocket password is not set. Setting it now...")
-        config = get_master_config()
-        config.get_config().port = server_port
-        config.get_config().password = server_password
-        with open(get_config_path(), 'w') as file:
-            json.dump(config.to_dict(), file, indent=4)
+        full_config = get_master_config()
+        full_config.get_config().obs.port = server_port
+        full_config.get_config().obs.password = server_password
+        full_config.sync_shared_fields()
+        full_config.save()
         reload_config()
 
 
-reconnecting = False
+connected = False
 
 def on_connect(obs):
-    global reconnecting
+    global connected
     logger.info("Reconnected to OBS WebSocket.")
-    if reconnecting:
-        start_replay_buffer()
-        reconnecting = False
+    start_replay_buffer()
+    connected = True
 
 
 def on_disconnect(obs):
-    global reconnecting
+    global connected
     logger.error("OBS Connection Lost!")
-    reconnecting = True
+    connected = False
 
 
 def connect_to_obs():
     global client
-    if get_config().obs.enabled:
+    if get_config().obs.enabled and not client:
         if util.is_windows():
             get_obs_websocket_config_values()
         client = obsws(host=get_config().obs.host, port=get_config().obs.port,
@@ -133,7 +157,6 @@ def do_obs_call(request, from_dict = None, retry=10):
                 time.sleep(1)
                 return do_obs_call(request, from_dict, retry - 1)
             else:
-                logger.error(f"Error doing obs call: {e}")
                 raise e
         return None
 
@@ -187,7 +210,7 @@ def get_current_scene():
     try:
         return do_obs_call(requests.GetCurrentProgramScene(), SceneInfo.from_dict, retry=0).sceneName
     except Exception as e:
-        logger.error(f"Couldn't get scene: {e}")
+        logger.debug(f"Couldn't get scene: {e}")
     return ''
 
 

GameSentenceMiner/ocr/owocr_area_selector.py

@@ -88,7 +88,6 @@ class ScreenSelector:
         try:
             windows = gw.getWindowsWithTitle(self.window_name)
             if windows:
-                # TODO: Handle multiple matches if necessary (e.g., let user choose?)
                 if len(windows) > 1:
                     print(f"Warning: Multiple windows found with title '{self.window_name}'. Using the first one.")
                 return windows[0]
@@ -235,7 +234,7 @@ class ScreenSelector:
                 # --- End Conversion ---
 
                 # Validate size using the final absolute pixel coordinates
-                if abs_coords and abs_coords[2] >= MIN_RECT_WIDTH and abs_coords[3] >= MIN_RECT_HEIGHT:
+                if coordinate_system == COORD_SYSTEM_PERCENTAGE or (abs_coords and abs_coords[2] >= MIN_RECT_WIDTH and abs_coords[3] >= MIN_RECT_HEIGHT):
                     # Find the correct monitor dict from self.monitors based on index
                     monitor_index = monitor_data['index']
                     target_monitor = next((m for m in self.monitors if m['index'] == monitor_index), None)
@@ -863,6 +862,9 @@ if __name__ == "__main__":
     # if not target_window_title:
     #     target_window_title = get_ocr_config().window
 
+    if not target_window_title:
+        target_window_title = "Windowed Projector (Preview)"
+
     # Get the selection result
     selection_result = get_screen_selection(target_window_title)
 

GameSentenceMiner/ocr/owocr_helper.py

@@ -254,8 +254,13 @@ def text_callback(text, orig_text, rectangle_index, time, img=None):
     # if orig_text:
     #     print(orig_text_string)
     if not twopassocr:
+        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"))
         send_result(text, time)
+        orig_text_results[rectangle_index] = orig_text_string
+        last_ocr1_results[rectangle_index] = previous_text
     if not text:
         if previous_text:
             if rectangle_index in text_stable_start_times:
@@ -269,8 +274,8 @@ def text_callback(text, orig_text, rectangle_index, time, img=None):
                     logger.info("Seems like Text we already sent, not doing anything.")
                     return
                 orig_text_results[rectangle_index] = orig_text_string
-                do_second_ocr(previous_text, rectangle_index, stable_time, previous_img)
                 last_ocr1_results[rectangle_index] = previous_text
+                do_second_ocr(previous_text, rectangle_index, stable_time, previous_img)
             return
         return
 
@@ -315,10 +320,24 @@ def run_oneocr(ocr_config: OCRConfig, i, area=False):
             text_callback=text_callback,
             screen_capture_exclusions=exclusions,
             rectangle=i,
-            ignore_window_visible=not get_requires_open_window())
+            language="ja")
     done = True
 
 
+def get_window(window_name):
+    import pygetwindow as gw
+    try:
+        windows = gw.getWindowsWithTitle(window_name)
+        if windows:
+            if len(windows) > 1:
+                print(f"Warning: Multiple windows found with title '{window_name}'. Using the first one.")
+            return windows[0]
+        else:
+            return None
+    except Exception as e:
+        print(f"Error finding window '{self.window_name}': {e}")
+        return None
+
 if __name__ == "__main__":
     global ocr1, ocr2, twopassocr
     import sys
@@ -343,7 +362,17 @@ if __name__ == "__main__":
     logger.info(f"Received arguments: ocr1={ocr1}, ocr2={ocr2}, twopassocr={twopassocr}")
     global ocr_config
     ocr_config: OCRConfig = get_ocr_config()
-    print(ocr_config)
+    if ocr_config:
+        if ocr_config.window:
+            start_time = time.time()
+            while time.time() - start_time < 30:
+                if get_window(ocr_config.window):
+                    break
+                logger.info(f"Window: {ocr_config.window} Could not be found, retrying in 1 second...")
+                time.sleep(1)
+            else:
+                logger.error(f"Window '{ocr_config.window}' not found within 30 seconds.")
+                sys.exit(1)
     logger.info(f"Starting OCR with configuration: Window: {ocr_config.window}, Rectangles: {len(ocr_config.rectangles)}, Engine 1: {ocr1}, Engine 2: {ocr2}, Two-pass OCR: {twopassocr}")
     if ocr_config:
         rectangles = list(filter(lambda rect: not rect.is_excluded, ocr_config.rectangles))

GameSentenceMiner/owocr/owocr/config.py

@@ -114,12 +114,14 @@ class Config:
                 for sub_key in config[key]:
                     self.__engine_config[key.lower()][sub_key.lower()] = self.__parse(config[key][sub_key])
 
-    def get_general(self, value):
+    def get_general(self, value, default_value=None):
         if self.__provided_cli_args.get(value, None) is not None:
             return self.__provided_cli_args[value]
         try:
             return self.__general_config[value]
         except KeyError:
+            if default_value:
+                return default_value
             if value in self.__default_config:
                 return self.__default_config[value]
             else:

GameSentenceMiner/owocr/owocr/run.py

@@ -222,9 +222,6 @@ class WindowsWindowTracker(threading.Thread):
                 if self.window_active != is_active:
                     on_window_activated(is_active)
                     self.window_active = is_active
-            elif ignore_window_visiblity:
-                on_window_minimized(False)
-                self.window_minimized = False
             else:
                 is_minimized = win32gui.IsIconic(self.window_handle)
                 if self.window_minimized != is_minimized:
@@ -308,8 +305,21 @@ class TextFiltering:
 
     def __init__(self):
         from pysbd import Segmenter
-        self.segmenter = Segmenter(language='ja', clean=True)
+        self.segmenter = Segmenter(language=lang, 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.,!?;:"\'()\[\]{}]')
+        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.,!?;:"\'()\[\]{}]')
+        self.korean_regex = re.compile(r'[\uAC00-\uD7AF]')
+        self.arabic_regex = re.compile(r'[\u0600-\u06FF\u0750-\u077F\u08A0-\u08FF\uFB50-\uFDFF\uFE70-\uFEFF]')
+        self.russian_regex = re.compile(r'[\u0400-\u04FF\u0500-\u052F\u2DE0-\u2DFF\uA640-\uA69F\u1C80-\u1C8F]')
+        self.greek_regex = re.compile(r'[\u0370-\u03FF\u1F00-\u1FFF]')
+        self.hebrew_regex = re.compile(r'[\u0590-\u05FF\uFB1D-\uFB4F]')
+        self.thai_regex = re.compile(r'[\u0E00-\u0E7F]')
+        self.latin_extended_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]')
         try:
             from transformers import pipeline, AutoTokenizer
             import torch
@@ -337,7 +347,28 @@ class TextFiltering:
 
         orig_text_filtered = []
         for block in orig_text:
-            block_filtered = self.kana_kanji_regex.findall(block)
+            if lang == "ja":
+                block_filtered = self.kana_kanji_regex.findall(block)
+            elif lang == "zh":
+                block_filtered = self.chinese_common_regex.findall(block)
+            elif lang == "ko":
+                block_filtered = self.korean_regex.findall(block)
+            elif lang == "ar":
+                block_filtered = self.arabic_regex.findall(block)
+            elif lang == "ru":
+                block_filtered = self.russian_regex.findall(block)
+            elif lang == "el":
+                block_filtered = self.greek_regex.findall(block)
+            elif lang == "he":
+                block_filtered = self.hebrew_regex.findall(block)
+            elif lang == "th":
+                block_filtered = self.thai_regex.findall(block)
+            elif lang in ["en", "fr", "de", "es", "it", "pt", "nl", "sv", "da", "no",
+                          "fi"]:  # Many European languages use extended Latin
+                block_filtered = self.latin_extended_regex.findall(block)
+            else:
+                block_filtered = self.english_regex.findall(block)
+
             if block_filtered:
                 orig_text_filtered.append(''.join(block_filtered))
             else:
@@ -358,12 +389,12 @@ class TextFiltering:
             detection_results = self.pipe(new_blocks, top_k=3, truncation=True)
             for idx, block in enumerate(new_blocks):
                 for result in detection_results[idx]:
-                    if result['label'] == 'ja':
+                    if result['label'] == lang:
                         final_blocks.append(block)
                         break
         else:
             for block in new_blocks:
-                if self.classify(block)[0] == 'ja':
+                if self.classify(block)[0] == lang:
                     final_blocks.append(block)
 
         text = '\n'.join(final_blocks)
@@ -565,10 +596,16 @@ def process_and_write_results(img_or_path, write_to, notifications, last_result,
 
     orig_text = []
     engine_color = config.get_general('engine_color')
+    # print(filtering)
+    #
+    #
+    # print(lang)
+
     if res:
         if filtering:
             text, orig_text = filtering(text, last_result)
-        text = post_process(text)
+        if lang == "ja" or lang == "zh":
+            text = post_process(text)
         logger.opt(ansi=True).info(f'Text recognized in {t1 - t0:0.03f}s using <{engine_color}>{engine_instance.readable_name}</{engine_color}>: {text}')
         if notifications:
             notifier.send(title='owocr', message='Text recognized: ' + text)
@@ -588,6 +625,9 @@ def process_and_write_results(img_or_path, write_to, notifications, last_result,
     else:
         logger.opt(ansi=True).info(f'<{engine_color}>{engine_instance.readable_name}</{engine_color}> reported an error after {t1 - t0:0.03f}s: {text}')
 
+    # print(orig_text)
+    # print(text)
+
     return orig_text, text
 
 
@@ -620,7 +660,7 @@ def run(read_from=None,
         screen_capture_event_bus=None,
         rectangle=None,
         text_callback=None,
-        ignore_window_visible=False,
+        language=None,
         ):
     """
     Japanese OCR client
@@ -646,18 +686,45 @@ def run(read_from=None,
     :param screen_capture_combo: When reading with screen capture, specifies a combo to wait on for taking a screenshot instead of using the delay. As an example: "<ctrl>+<shift>+s". The list of keys can be found here: https://pynput.readthedocs.io/en/latest/keyboard.html#pynput.keyboard.Key
     """
 
-    if not read_from:
+    if read_from is None:
         read_from = config.get_general('read_from')
 
-    if not screen_capture_area:
+    if screen_capture_area is None:
         screen_capture_area = config.get_general('screen_capture_area')
 
-    if not 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 not write_to:
+    if screen_capture_exclusions is None:
+        screen_capture_exclusions = config.get_general('screen_capture_exclusions')
+
+    if screen_capture_window is None:
+        screen_capture_window = config.get_general('screen_capture_window')
+
+    if screen_capture_delay_secs is None:
+        screen_capture_delay_secs = config.get_general('screen_capture_delay_secs')
+
+    if screen_capture_combo is None:
+        screen_capture_combo = config.get_general('screen_capture_combo')
+
+    if stop_running_flag is None:
+        stop_running_flag = config.get_general('stop_running_flag')
+
+    if screen_capture_event_bus is None:
+        screen_capture_event_bus = config.get_general('screen_capture_event_bus')
+
+    if rectangle is None:
+        rectangle = config.get_general('rectangle')
+
+    if text_callback is None:
+        text_callback = config.get_general('text_callback')
+
+    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:
@@ -669,8 +736,8 @@ def run(read_from=None,
 
     global engine_instances
     global engine_keys
-    global ignore_window_visiblity
-    ignore_window_visiblity = ignore_window_visible
+    global lang
+    lang = language
     engine_instances = []
     config_engines = []
     engine_keys = []