GameSentenceMiner 2.12.0.dev4__tar.gz → 2.12.0.dev6__tar.gz

{gamesentenceminer-2.12.0.dev4 → gamesentenceminer-2.12.0.dev6}/GameSentenceMiner/anki.py

@@ -19,6 +19,7 @@ from GameSentenceMiner.util.model import AnkiCard
 from GameSentenceMiner.util.text_log import get_all_lines, get_text_event, get_mined_line, lines_match
 from GameSentenceMiner.obs import get_current_game
 from GameSentenceMiner.web import texthooking_page
+import re
 
 # Global variables to track state
 previous_note_ids = set()
@@ -161,7 +162,36 @@ def get_initial_card_info(last_note: AnkiCard, selected_lines):
     game_line = get_text_event(last_note)
     sentences = []
     sentences_text = ''
-    if selected_lines:
+    
+    # TODO: REMOVE THIS, I DON'T THINK IT'S NEEDED
+    if get_config().wip.overlay_websocket_send:
+        sentence_in_anki = last_note.get_field(get_config().anki.sentence_field).replace("\n", "").replace("\r", "").strip()
+        if lines_match(game_line.text, remove_html_and_cloze_tags(sentence_in_anki)):
+            logger.info("Found matching line in Anki, Preserving HTML and fix spacing!")
+            if "<b>" in sentence_in_anki:
+                text_inside_bold = re.findall(r'<b>(.*?)</b>', sentence_in_anki)
+                logger.info(text_inside_bold)
+                if text_inside_bold:
+                    text = text_inside_bold[0].replace(" ", "").replace('\n', '').strip()
+                    note['fields'][get_config().anki.sentence_field] = game_line.text.replace(text_inside_bold[0], f"<b>{text}</b>")
+                    logger.info(f"Preserved bold Tag for Sentence: {note['fields'][get_config().anki.sentence_field]}")
+            if "<i>" in sentence_in_anki:
+                text_inside_italic = re.findall(r'<i>(.*?)</i>', sentence_in_anki)
+                if text_inside_italic:
+                    text = text_inside_italic[0].replace(" ", "").replace('\n', '').strip()
+                    note['fields'][get_config().anki.sentence_field] = game_line.text.replace(text_inside_italic[0], f"<i>{text}</i>")
+                    logger.info(f"Preserved italic Tag for Sentence: {note['fields'][get_config().anki.sentence_field]}")
+            if "<u>" in sentence_in_anki:
+                text_inside_underline = re.findall(r'<u>(.*?)</u>', sentence_in_anki)
+                if text_inside_underline:
+                    text = text_inside_underline[0].replace(" ", "").replace('\n', '').strip()
+                    note['fields'][get_config().anki.sentence_field] = game_line.text.replace(text_inside_underline[0], f"<u>{text}</u>")
+                    logger.info(f"Preserved underline Tag for Sentence: {note['fields'][get_config().anki.sentence_field]}")
+            
+            if get_config().anki.sentence_field not in note['fields']:
+                logger.info("No HTML tags found to preserve, just fixing spacing")
+                note['fields'][get_config().anki.sentence_field] = game_line.text
+    elif selected_lines:
         try:
             sentence_in_anki = last_note.get_field(get_config().anki.sentence_field)
             logger.info(f"Attempting Preserve HTML for multi-line")

{gamesentenceminer-2.12.0.dev4 → gamesentenceminer-2.12.0.dev6}/GameSentenceMiner/config_gui.py

@@ -113,6 +113,7 @@ class ConfigApp:
         self.window.title('GameSentenceMiner Configuration')
         self.window.protocol("WM_DELETE_WINDOW", self.hide)
         self.obs_scene_listbox_changed = False
+        self.test_func = None
 
         # self.window.geometry("800x500")
         self.current_row = 0
@@ -162,6 +163,9 @@ class ConfigApp:
         self.window.update_idletasks()
         self.window.geometry("")
         self.window.withdraw()
+        
+    def set_test_func(self, func):
+        self.test_func = func
 
     def create_tabs(self):
         self.create_general_tab()
@@ -580,6 +584,12 @@ class ConfigApp:
                   text="Every Label in settings has a tooltip with more information if you hover over them.",
                   font=("Helvetica", 10, "bold")).grid(row=self.current_row, column=0, columnspan=2, sticky='W', pady=2)
         self.current_row += 1
+        
+        if is_beangate:
+            ttk.Button(self.general_tab, text="Run Function", command=self.test_func, bootstyle="info").grid(
+                row=self.current_row, column=0, pady=5
+            )
+            self.current_row += 1
 
         # Add Reset to Default button
         self.add_reset_button(self.general_tab, "general", self.current_row, column=0, recreate_tab=self.create_general_tab)

{gamesentenceminer-2.12.0.dev4 → gamesentenceminer-2.12.0.dev6}/GameSentenceMiner/gametext.py

@@ -9,7 +9,7 @@ from websockets import InvalidStatus
 from GameSentenceMiner.util.gsm_utils import do_text_replacements, TEXT_REPLACEMENTS_FILE, run_new_thread
 from GameSentenceMiner.util.configuration import *
 from GameSentenceMiner.util.text_log import *
-from GameSentenceMiner.web.texthooking_page import add_event_to_texthooker, send_word_coordinates_to_overlay
+from GameSentenceMiner.web.texthooking_page import add_event_to_texthooker, send_word_coordinates_to_overlay, overlay_server_thread
 from GameSentenceMiner.wip import get_overlay_coords
 
 current_line = ''
@@ -125,7 +125,7 @@ async def handle_new_text_event(current_clipboard, line_time=None):
     add_line(current_line_after_regex, line_time)
     if len(get_text_log().values) > 0:
         await add_event_to_texthooker(get_text_log()[-1])
-    if get_config().wip.overlay_websocket_port and get_config().wip.overlay_websocket_send:
+    if get_config().wip.overlay_websocket_port and get_config().wip.overlay_websocket_send and overlay_server_thread.has_clients():
         boxes = await find_box_for_sentence(current_line_after_regex)
         if boxes:
             await send_word_coordinates_to_overlay(boxes)

{gamesentenceminer-2.12.0.dev4 → gamesentenceminer-2.12.0.dev6}/GameSentenceMiner/gsm.py

@@ -545,6 +545,8 @@ def async_loop():
             await check_obs_folder_is_correct()
         logger.info("Post-Initialization started.")
         vad_processor.init()
+        # if is_beangate:
+            # await run_test_code()
 
     asyncio.run(loop())
 
@@ -577,6 +579,13 @@ async def register_scene_switcher_callback():
             update_icon()
 
     await obs.register_scene_change_callback(scene_switcher_callback)
+    
+async def run_test_code():
+    if get_config().wip.overlay_websocket_port and get_config().wip.overlay_websocket_send:
+        boxes = await gametext.find_box_for_sentence("ちぇっ少しなの？")
+        if boxes:
+            await texthooking_page.send_word_coordinates_to_overlay(boxes)
+        await asyncio.sleep(2)
 
 async def async_main(reloading=False):
     global root, settings_window
@@ -600,6 +609,9 @@ async def async_main(reloading=False):
     signal.signal(signal.SIGINT, handle_exit())  # Handle Ctrl+C
     if is_windows():
         win32api.SetConsoleCtrlHandler(handle_exit())
+        
+    if is_beangate:
+        settings_window.set_test_func(lambda: run_new_thread(run_test_code))
 
     gsm_status.ready = True
     gsm_status.status = "Ready"

{gamesentenceminer-2.12.0.dev4 → gamesentenceminer-2.12.0.dev6}/GameSentenceMiner/owocr/owocr/ocr.py

@@ -6,13 +6,14 @@ from pathlib import Path
 import sys
 import platform
 import logging
-from math import sqrt
+from math import sqrt, floor
 import json
 import base64
 from urllib.parse import urlparse, parse_qs
 
 import jaconv
 import numpy as np
+import rapidfuzz.fuzz
 from PIL import Image
 from loguru import logger
 import requests
@@ -164,6 +165,28 @@ def limit_image_size(img, max_size):
     return False, ''
 
 
+def get_regex(lang):
+    if lang == "ja":
+        return re.compile(r'[\u3041-\u3096\u30A1-\u30FA\u4E00-\u9FFF]')
+    elif lang == "zh":
+        return re.compile(r'[\u4E00-\u9FFF]')
+    elif lang == "ko":
+        return re.compile(r'[\uAC00-\uD7AF]')
+    elif lang == "ar":
+        return re.compile(r'[\u0600-\u06FF\u0750-\u077F\u08A0-\u08FF\uFB50-\uFDFF\uFE70-\uFEFF]')
+    elif lang == "ru":
+        return re.compile(r'[\u0400-\u04FF\u0500-\u052F\u2DE0-\u2DFF\uA640-\uA69F\u1C80-\u1C8F]')
+    elif lang == "el":
+        return re.compile(r'[\u0370-\u03FF\u1F00-\u1FFF]')
+    elif lang == "he":
+        return re.compile(r'[\u0590-\u05FF\uFB1D-\uFB4F]')
+    elif lang == "th":
+        return re.compile(r'[\u0E00-\u0E7F]')
+    else:
+        return 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]')
+
+
 class MangaOcr:
     name = 'mangaocr'
     readable_name = 'Manga OCR'
@@ -243,15 +266,20 @@ class GoogleLens:
     available = False
 
     def __init__(self, lang='ja'):
-        self.kana_kanji_regex = re.compile(r'[\u3041-\u3096\u30A1-\u30FA\u4E00-\u9FFF]')
+        self.regex = get_regex(lang)
+        self.initial_lang = lang
         if 'betterproto' not in sys.modules:
             logger.warning('betterproto not available, Google Lens will not work!')
         else:
             self.available = True
             logger.info('Google Lens ready')
 
-    def __call__(self, img, furigana_filter_sensitivity=0):
+    def __call__(self, img, furigana_filter_sensitivity=0, return_coords=False):
+        lang = get_ocr_language()
         img, is_path = input_to_pil_image(img)
+        if lang != self.initial_lang:
+            self.initial_lang = lang
+            self.regex = get_regex(lang)
         if not img:
             return (False, 'Invalid image provided')
 
@@ -309,12 +337,14 @@ class GoogleLens:
         response_proto = LensOverlayServerResponse().FromString(res.content)
         response_dict = response_proto.to_dict(betterproto.Casing.SNAKE)
 
-        # with open(os.path.join(r"C:\Users\Beangate\GSM\Electron App\test", 'glens_response.json'), 'w', encoding='utf-8') as f:
-        #     json.dump(response_dict, f, indent=4, ensure_ascii=False)
+        if os.path.exists(r"C:\Users\Beangate\GSM\Electron App\test"):
+            with open(os.path.join(r"C:\Users\Beangate\GSM\Electron App\test", 'glens_response.json'), 'w', encoding='utf-8') as f:
+                json.dump(response_dict, f, indent=4, ensure_ascii=False)
         res = ''
         text = response_dict['objects_response']['text']
         skipped = []
         previous_line = None
+        lines = []
         if 'text_layout' in text:
             for paragraph in text['text_layout']['paragraphs']:
                 if previous_line:
@@ -330,18 +360,38 @@ class GoogleLens:
                     if vertical_space > avg_height * 2:
                         res += 'BLANK_LINE'
                 for line in paragraph['lines']:
+                    # Build a list of word boxes for this line
+                    words_info = []
+                    for word in line['words']:
+                        word_info = {
+                            "word": word['plain_text'],
+                            "x1": int(word['geometry']['bounding_box']['center_x'] * img.width - (word['geometry']['bounding_box']['width'] * img.width) / 2),
+                            "y1": int(word['geometry']['bounding_box']['center_y'] * img.height - (word['geometry']['bounding_box']['height'] * img.height) / 2),
+                            "x2": int(word['geometry']['bounding_box']['center_x'] * img.width + (word['geometry']['bounding_box']['width'] * img.width) / 2),
+                            "y2": int(word['geometry']['bounding_box']['center_y'] * img.height + (word['geometry']['bounding_box']['height'] * img.height) / 2)
+                        }
+                        words_info.append(word_info)
+
+                    line_text = ''.join([w['word'] for w in words_info])
+                    line_box = {
+                        "sentence": line_text,
+                        "words": words_info
+                    }
+
+                    # Optionally apply furigana filter
                     if furigana_filter_sensitivity:
-                        if furigana_filter_sensitivity < line['geometry']['bounding_box']['width'] * img.width and furigana_filter_sensitivity < line['geometry']['bounding_box']['height'] * img.height:
-                            for word in line['words']:
-                                res += word['plain_text'] + word['text_separator']
+                        line_width = line['geometry']['bounding_box']['width'] * img.width
+                        line_height = line['geometry']['bounding_box']['height'] * img.height
+                        if furigana_filter_sensitivity < line_width and furigana_filter_sensitivity < line_height and self.regex.search(line_text):
+                            for w in words_info:
+                                res += w['word']
                         else:
-                            skipped.append(word['plain_text'] for word in line['words'])
+                            skipped.extend([w['word'] for w in words_info])
                             continue
                     else:
-                        for word in line['words']:
-                                res += word['plain_text'] + word['text_separator']
-                        else:
-                            continue
+                        for w in words_info:
+                            res += w['word']
+                    lines.append(line_box)
                 previous_line = paragraph
                 res += '\n'
             # logger.info(
@@ -384,8 +434,11 @@ class GoogleLens:
         #                 else:
         #                     continue
         #             res += '\n'
-
-        x = (True, res)
+        
+        if return_coords:
+            x = (True, res, lines)
+        else:
+            x = (True, res)
 
         # img.close()
         return x
@@ -812,7 +865,7 @@ class OneOCR:
 
     def __init__(self, config={}, lang='ja'):
         self.initial_lang = lang
-        self.get_regex(lang)
+        self.regex = get_regex(lang)
         if sys.platform == 'win32':
             if int(platform.release()) < 10:
                 logger.warning('OneOCR is not supported on Windows older than 10!')
@@ -834,32 +887,11 @@ 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):
+    def __call__(self, img, furigana_filter_sensitivity=0, sentence_to_check=None, return_coords=False):
         lang = get_ocr_language()
         if lang != self.initial_lang:
             self.initial_lang = lang
-            self.get_regex(lang)
+            self.regex = 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)
@@ -873,20 +905,18 @@ class OneOCR:
         if sys.platform == 'win32':
             try:
                 ocr_resp = self.model.recognize_pil(img)
+                if os.path.exists(os.path.expanduser("~/GSM/temp")):
+                    with open(os.path.join(os.path.expanduser("~/GSM/temp"), 'oneocr_response.json'), 'w',
+                                encoding='utf-8') as f:
+                        json.dump(ocr_resp, f, indent=4, ensure_ascii=False)
                 # print(json.dumps(ocr_resp))
                 filtered_lines = [line for line in ocr_resp['lines'] if self.regex.search(line['text'])]
-                x_coords = [line['bounding_rect'][f'x{i}'] for line in filtered_lines for i in range(1, 5)]
-                y_coords = [line['bounding_rect'][f'y{i}'] for line in filtered_lines for i in range(1, 5)]
-                if x_coords and y_coords:
-                    crop_coords = (min(x_coords) - 5, min(y_coords) - 5, max(x_coords) + 5, max(y_coords) + 5)
-
-                # with open(os.path.join(get_temporary_directory(), 'oneocr_response.json'), 'w',
-                #           encoding='utf-8') as f:
-                #     json.dump(ocr_resp, f, indent=4, ensure_ascii=False)
+                # logger.info(filtered_lines)
                 res = ''
                 skipped = []
+                boxes = []
                 if furigana_filter_sensitivity > 0:
-                    for line in ocr_resp['lines']:
+                    for line in filtered_lines:
                         x1, x2, x3, x4 = line['bounding_rect']['x1'], line['bounding_rect']['x2'], \
                             line['bounding_rect']['x3'], line['bounding_rect']['x4']
                         y1, y2, y3, y4 = line['bounding_rect']['y1'], line['bounding_rect']['y2'], \
@@ -934,8 +964,46 @@ class OneOCR:
                     #         else:
                     #             continue
                     #     res += '\n'
+                elif sentence_to_check:
+                    lines_to_build_area = []
+                    widths = []
+                    heights = []
+                    for line in ocr_resp['lines']:
+                        print(line['text'])
+                        if sentence_to_check in line['text'] or line['text'] in sentence_to_check or rapidfuzz.fuzz.partial_ratio(sentence_to_check, line['text']) > 50:
+                            lines_to_build_area.append(line)
+                            res += line['text']
+                            for word in line['words']:
+                                widths.append(word['bounding_rect']['x2'] - word['bounding_rect']['x1'])
+                                heights.append(word['bounding_rect']['y3'] - word['bounding_rect']['y1'])
+
+                    x_coords = [line['bounding_rect'][f'x{i}'] for line in lines_to_build_area for i in
+                                range(1, 5)]
+                    y_coords = [line['bounding_rect'][f'y{i}'] for line in lines_to_build_area for i in
+                                range(1, 5)]
+                    if widths:
+                        avg_width = sum(widths) / len(widths)
+                    if heights:
+                        avg_height = sum(heights) / len(heights)
+                    if x_coords and y_coords:
+                        crop_coords = (
+                            min(x_coords) - 5, min(y_coords) - 5, max(x_coords) + 5, max(y_coords) + 5)
+                elif return_coords:
+                    for line in filtered_lines:
+                        for word in line['words']:
+                            box = {
+                                "text": word['text'],
+                                "bounding_rect": word['bounding_rect']
+                            }
+                            boxes.append(box)
+                    res = ocr_resp['text']
                 else:
+                    x_coords = [line['bounding_rect'][f'x{i}'] for line in filtered_lines for i in range(1, 5)]
+                    y_coords = [line['bounding_rect'][f'y{i}'] for line in filtered_lines for i in range(1, 5)]
+                    if x_coords and y_coords:
+                        crop_coords = (min(x_coords) - 5, min(y_coords) - 5, max(x_coords) + 5, max(y_coords) + 5)
                     res = ocr_resp['text']
+
             except RuntimeError as e:
                 return (False, e)
         else:
@@ -950,10 +1018,12 @@ class OneOCR:
                 return (False, 'Unknown error!')
 
             res = res.json()['text']
-
-        x = (True, res, crop_coords)
-
-        # img.close()
+        if return_coords:
+            x = (True, res, boxes)
+        else:
+            x = (True, res, crop_coords)
+        if is_path:
+            img.close()
         return x
 
     def _preprocess(self, img):

{gamesentenceminer-2.12.0.dev4 → gamesentenceminer-2.12.0.dev6}/GameSentenceMiner/owocr/owocr/run.py

@@ -384,7 +384,6 @@ class TextFiltering:
                 block_filtered = self.latin_extended_regex.findall(block)
             else:
                 block_filtered = self.latin_extended_regex.findall(block)
-
             if block_filtered:
                 orig_text_filtered.append(''.join(block_filtered))
             else:
@@ -548,6 +547,39 @@ class ScreenshotThread(threading.Thread):
             else:
                 raise ValueError('Window capture is only currently supported on Windows and macOS')
 
+    def __del__(self):
+        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 setup_persistent_windows_window_tracker(self):
+        global window_open
+        window_open = False
+        def setup_tracker():
+            global window_open
+            self.window_handle, window_title = self.get_windows_window_handle(self.screen_capture_window)
+
+            if not self.window_handle:
+                # print(f"Window '{screen_capture_window}' not found.")
+                return
+
+            set_dpi_awareness()
+            window_open = True
+            self.windows_window_tracker_instance = threading.Thread(target=self.windows_window_tracker)
+            self.windows_window_tracker_instance.start()
+            logger.opt(ansi=True).info(f'Selected window: {window_title}')
+
+        while not terminated:
+            if not window_open:
+                try:
+                    setup_tracker()
+                except ValueError as e:
+                    logger.error(f"Error setting up persistent windows window tracker: {e}")
+                    break
+            time.sleep(5)
+
+
     def get_windows_window_handle(self, window_title):
         def callback(hwnd, window_title_part):
             window_title = win32gui.GetWindowText(hwnd)
@@ -570,7 +602,7 @@ class ScreenshotThread(threading.Thread):
 
     def windows_window_tracker(self):
         found = True
-        while not terminated:
+        while not terminated or window_open:
             found = win32gui.IsWindow(self.window_handle)
             if not found:
                 break
@@ -1086,10 +1118,11 @@ def signal_handler(sig, frame):
 
 
 def on_window_closed(alive):
-    global terminated
+    global terminated, window_open
     if not (alive or terminated):
         logger.info('Window closed or error occurred, terminated!')
-        terminated = True
+        window_open = False
+        # terminated = True
 
 
 def on_screenshot_combo():

{gamesentenceminer-2.12.0.dev4 → gamesentenceminer-2.12.0.dev6}/GameSentenceMiner/util/configuration.py

@@ -282,7 +282,7 @@ class CommonLanguages(str, Enum):
         Raises ValueError if not found.
         """
         try:
-            return cls[name]
+            return cls[name.upper()]
         except KeyError:
             raise ValueError(f"Language '{name}' not found in CommonLanguages")
         
@@ -527,7 +527,7 @@ class Ai:
 @dataclass_json
 @dataclass
 class WIP:
-    overlay_websocket_port: int = 55003
+    overlay_websocket_port: int = 55499
     overlay_websocket_send: bool = False
                     
 
@@ -549,7 +549,14 @@ class ProfileConfig:
     advanced: Advanced = field(default_factory=Advanced)
     ai: Ai = field(default_factory=Ai)
     wip: WIP = field(default_factory=WIP)
-
+    
+    
+    def get_field_value(self, section: str, field_name: str):
+        section_obj = getattr(self, section, None)
+        if section_obj and hasattr(section_obj, field_name):
+            return getattr(section_obj, field_name)
+        else:
+            raise ValueError(f"Field '{field_name}' not found in section '{section}' of ProfileConfig.")
 
     # This is just for legacy support
     def load_from_toml(self, file_path: str):
@@ -992,4 +999,7 @@ anki_results = {}
 gsm_state = GsmAppState()
 is_dev = is_running_from_source()
 
+is_beangate = os.path.exists("C:/Users/Beangate")
+
 logger.debug(f"Running in development mode: {is_dev}")
+logger.debug(f"Running on Beangate's PC: {is_beangate}")

{gamesentenceminer-2.12.0.dev4 → gamesentenceminer-2.12.0.dev6}/GameSentenceMiner/util/text_log.py

@@ -113,8 +113,8 @@ def similar(a, b):
 
 
 def lines_match(texthooker_sentence, anki_sentence):
-    texthooker_sentence = texthooker_sentence.replace("\n", "").replace("\r", "").strip()
-    anki_sentence = anki_sentence.replace("\n", "").replace("\r", "").strip()
+    texthooker_sentence = texthooker_sentence.replace("\n", "").replace("\r", "").replace(' ', '').strip()
+    anki_sentence = anki_sentence.replace("\n", "").replace("\r", "").replace(' ', '').strip()
     similarity = similar(texthooker_sentence, anki_sentence)
     if texthooker_sentence in anki_sentence:
         logger.debug(f"One contains the other: {texthooker_sentence} in {anki_sentence} - Similarity: {similarity}")

{gamesentenceminer-2.12.0.dev4 → gamesentenceminer-2.12.0.dev6}/GameSentenceMiner/util/window_transparency.py

@@ -1,9 +1,11 @@
+import sys
 import win32gui
 import win32con
 import win32api
 import keyboard
 import time
 import threading
+import signal
 
 from GameSentenceMiner.util.configuration import logger
 
@@ -137,6 +139,22 @@ def mouse_monitor_loop():
         # A small delay to reduce CPU usage
         time.sleep(0.1)
 
+class HandleSTDINThread(threading.Thread):
+    def run(self):
+        while True:
+            try:
+                line = input()
+                if "exit" in line.strip().lower():
+                    handle_quit()
+                    break
+            except EOFError:
+                break
+            
+def handle_quit():
+    if is_toggled and target_hwnd:
+        reset_window_state(target_hwnd)
+    logger.info("Exiting Window Transparency Tool.")
+
 # --- Main Execution Block ---
 
 if __name__ == "__main__":
@@ -155,8 +173,18 @@ if __name__ == "__main__":
     # Register the global hotkey
     keyboard.add_hotkey(hotkey, toggle_functionality)
 
+    # Handle SigINT/SigTERM gracefully
+    def signal_handler(sig, frame):
+        handle_quit()
+        sys.exit(0)
+
+    signal.signal(signal.SIGINT, signal_handler)
+    signal.signal(signal.SIGTERM, signal_handler)
+
     logger.info(f"Script running. Press '{hotkey}' on a window to toggle transparency.")
     logger.info("Press Ctrl+C in this console to exit.")
+    
+    HandleSTDINThread().start()
 
     # Keep the script running to listen for the hotkey.
     # keyboard.wait() is a blocking call that waits indefinitely.

{gamesentenceminer-2.12.0.dev4 → gamesentenceminer-2.12.0.dev6}/GameSentenceMiner/web/texthooking_page.py

@@ -389,19 +389,18 @@ def start_web_server():
     app.run(host='0.0.0.0', port=port, debug=False) # debug=True provides helpful error messages during development
 
 
-websocket_server_thread = None
 websocket_queue = queue.Queue()
 paused = False
 
 
 class WebsocketServerThread(threading.Thread):
-    def __init__(self, read, ws_port):
+    def __init__(self, read, get_ws_port_func):
         super().__init__(daemon=True)
         self._loop = None
         self.read = read
         self.clients = set()
         self._event = threading.Event()
-        self.ws_port = ws_port
+        self.get_ws_port_func = get_ws_port_func
         self.backedup_text = []
 
     @property
@@ -446,6 +445,9 @@ class WebsocketServerThread(threading.Thread):
                 text = json.dumps(text)
             return asyncio.run_coroutine_threadsafe(
                 self.send_text_coroutine(text), self.loop)
+            
+    def has_clients(self):
+        return len(self.clients) > 0
 
     def stop_server(self):
         self.loop.call_soon_threadsafe(self._stop_event.set)
@@ -459,7 +461,7 @@ class WebsocketServerThread(threading.Thread):
                 try:
                     self.server = start_server = websockets.serve(self.server_handler,
                                                                   "0.0.0.0",
-                                                                  self.ws_port,
+                                                                  self.get_ws_port_func(),
                                                                   max_size=1000000000)
                     async with start_server:
                         await stop_event.wait()
@@ -474,6 +476,16 @@ def handle_exit_signal(loop):
     logger.info("Received exit signal. Shutting down...")
     for task in asyncio.all_tasks(loop):
         task.cancel()
+        
+websocket_server_thread = WebsocketServerThread(read=True, get_ws_port_func=lambda : get_config().get_field_value('advanced', 'texthooker_communication_websocket_port'))
+websocket_server_thread.start()
+
+if get_config().advanced.plaintext_websocket_port:
+    plaintext_websocket_server_thread = WebsocketServerThread(read=False, get_ws_port_func=lambda : get_config().get_field_value('advanced', 'plaintext_websocket_port'))
+    plaintext_websocket_server_thread.start()
+    
+overlay_server_thread = WebsocketServerThread(read=False, get_ws_port_func=lambda : get_config().get_field_value('wip', 'overlay_websocket_port'))
+overlay_server_thread.start()
 
 async def texthooker_page_coro():
     global websocket_server_thread, plaintext_websocket_server_thread, overlay_server_thread
@@ -482,16 +494,6 @@ async def texthooker_page_coro():
     flask_thread.daemon = True
     flask_thread.start()
 
-    websocket_server_thread = WebsocketServerThread(read=True, ws_port=get_config().advanced.texthooker_communication_websocket_port)
-    websocket_server_thread.start()
-
-    if get_config().advanced.plaintext_websocket_port:
-        plaintext_websocket_server_thread = WebsocketServerThread(read=False, ws_port=get_config().advanced.plaintext_websocket_port)
-        plaintext_websocket_server_thread.start()
-        
-    overlay_server_thread = WebsocketServerThread(read=False, ws_port=49999)
-    overlay_server_thread.start()
-
     # Keep the main asyncio event loop running (for the WebSocket server)
 
 def run_text_hooker_page():