GameSentenceMiner 2.12.0.dev5__tar.gz → 2.12.1__tar.gz

{gamesentenceminer-2.12.0.dev5 → gamesentenceminer-2.12.1}/GameSentenceMiner/ai/ai_prompting.py

@@ -5,16 +5,6 @@ from abc import ABC, abstractmethod
 from dataclasses import dataclass
 from enum import Enum
 from typing import List, Optional
-
-
-try:
-    import torch
-    from transformers import AutoTokenizer, AutoModelForCausalLM, AutoModelForSeq2SeqLM, pipeline
-
-    TRANSFORMERS_AVAILABLE = True
-except ImportError:
-    TRANSFORMERS_AVAILABLE = False
-
 from google import genai
 from google.genai import types
 from groq import Groq
@@ -136,6 +126,13 @@ class AIManager(ABC):
 class LocalAIManager(AIManager):
     def __init__(self, model, logger: Optional[logging.Logger] = None):
         super().__init__(LocalAIConfig(model=model), logger)
+        try:
+            import torch
+            from transformers import AutoTokenizer, AutoModelForCausalLM, AutoModelForSeq2SeqLM, pipeline
+
+            self.transformers_available = True
+        except (ImportError, OSError):
+            self.transformers_available = False
         self.model_name = self.ai_config.model
         if MANUAL_MODEL_OVERRIDE:
             self.model_name = MANUAL_MODEL_OVERRIDE
@@ -147,7 +144,7 @@ class LocalAIManager(AIManager):
         self.is_encoder_decoder = False
         self.is_nllb = "nllb" in self.model_name.lower()
 
-        if not TRANSFORMERS_AVAILABLE:
+        if not self.transformers_available:
             self.logger.error("Local AI dependencies not found. Please run: pip install torch transformers sentencepiece")
             return
 

{gamesentenceminer-2.12.0.dev5 → gamesentenceminer-2.12.1}/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,6 +162,35 @@ def get_initial_card_info(last_note: AnkiCard, selected_lines):
     game_line = get_text_event(last_note)
     sentences = []
     sentences_text = ''
+    
+    # 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
     if selected_lines:
         try:
             sentence_in_anki = last_note.get_field(get_config().anki.sentence_field)

{gamesentenceminer-2.12.0.dev5 → gamesentenceminer-2.12.1}/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.dev5 → gamesentenceminer-2.12.1}/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.dev5 → gamesentenceminer-2.12.1}/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

{gamesentenceminer-2.12.0.dev5 → gamesentenceminer-2.12.1}/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.dev5 → gamesentenceminer-2.12.1}/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.dev5 → gamesentenceminer-2.12.1}/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.dev5 → gamesentenceminer-2.12.1}/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.dev5 → gamesentenceminer-2.12.1}/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=get_config().wip.overlay_websocket_port)
-    overlay_server_thread.start()
-
     # Keep the main asyncio event loop running (for the WebSocket server)
 
 def run_text_hooker_page():

gamesentenceminer-2.12.1/GameSentenceMiner/wip/get_overlay_coords.py

@@ -0,0 +1,244 @@
+import asyncio
+import io
+import base64
+from PIL import Image
+from GameSentenceMiner.util.configuration import get_config
+
+if get_config().wip.overlay_websocket_send:
+    from GameSentenceMiner.owocr.owocr.ocr import GoogleLens, OneOCR
+from GameSentenceMiner.obs import *
+
+# OBS WebSocket settings
+OBS_HOST = 'localhost'
+OBS_PORT = 7274
+OBS_PASSWORD = 'your_obs_websocket_password' # Set your OBS WebSocket password here, if any
+
+WINDOW_NAME = "Nier:Automata"
+WIDTH = 2560
+HEIGHT = 1440
+if get_config().wip.overlay_websocket_send:
+    oneocr = OneOCR()
+    lens = GoogleLens()
+
+def correct_ocr_text(detected_text: str, reference_text: str) -> str:
+    """
+    Correct OCR text by comparing character-by-character with reference text.
+    When mismatches are found, look for subsequent matches and correct previous mismatches.
+    """
+    if not detected_text or not reference_text:
+        return detected_text
+    
+    detected_chars = list(detected_text)
+    reference_chars = list(reference_text)
+    
+    # Track positions where mismatches occurred
+    mismatched_positions = []
+    
+    min_length = min(len(detected_chars), len(reference_chars))
+    
+    for i in range(min_length):
+        if detected_chars[i] != reference_chars[i]:
+            mismatched_positions.append(i)
+            logger.info(f"Mismatch at position {i}: detected '{detected_chars[i]}' vs reference '{reference_chars[i]}'")
+        else:
+            # We found a match - if we have previous mismatches, correct the most recent one
+            if mismatched_positions:
+                # Correct the most recent mismatch (simple 1-for-1 strategy)
+                last_mismatch_pos = mismatched_positions.pop()
+                old_char = detected_chars[last_mismatch_pos]
+                detected_chars[last_mismatch_pos] = reference_chars[last_mismatch_pos]
+                logger.info(f"Corrected position {last_mismatch_pos}: '{old_char}' -> '{reference_chars[last_mismatch_pos]}'")
+    
+    corrected_text = ''.join(detected_chars)
+    return corrected_text
+
+def redistribute_corrected_text(original_boxes: list, original_text: str, corrected_text: str) -> list:
+    """
+    Redistribute corrected text back to the original text boxes while maintaining their positions.
+    """
+    if original_text == corrected_text:
+        return original_boxes
+    
+    corrected_boxes = []
+    text_position = 0
+    
+    for box in original_boxes:
+        original_word = box['text']
+        word_length = len(original_word)
+        
+        # Extract the corrected portion for this box
+        if text_position + word_length <= len(corrected_text):
+            corrected_word = corrected_text[text_position:text_position + word_length]
+        else:
+            # Handle case where corrected text is shorter
+            corrected_word = corrected_text[text_position:] if text_position < len(corrected_text) else ""
+        
+        # Create a new box with corrected text but same coordinates
+        corrected_box = box.copy()
+        corrected_box['text'] = corrected_word
+        corrected_boxes.append(corrected_box)
+        
+        text_position += word_length
+        
+        logger.info(f"Redistributed: '{original_word}' -> '{corrected_word}'")
+    
+    return corrected_boxes
+
+async def get_full_screenshot() -> Image.Image | None:
+    # logger.info(f"Attempting to connect to OBS WebSocket at ws://{OBS_HOST}:{OBS_PORT}")
+    # try:
+    #     client = obs.ReqClient(host=OBS_HOST, port=OBS_PORT, password=OBS_PASSWORD, timeout=30)
+    #     logger.info("Connected to OBS WebSocket.")
+    # except Exception as e:
+    #     logger.info(f"Failed to connect to OBS: {e}")
+    #     return None
+    #
+    # try:
+    #     response = client.get_source_screenshot(
+    #         name=WINDOW_NAME,
+    #         img_format='png',
+    #         quality=75,
+    #         width=WIDTH,
+    #         height=HEIGHT,
+    #     )
+    #
+    #     if not response.image_data:
+    #         logger.info("Failed to get screenshot data from OBS.")
+    #         return None
+
+    logger.info("Getting Screenshot from OBS")
+    try:
+        update_current_game()
+        start_time = time.time()
+        image_data = get_screenshot_base64(compression=75, width=1280, height=720)
+        image_data = base64.b64decode(image_data)
+        img = Image.open(io.BytesIO(image_data)).convert("RGBA").resize((WIDTH, HEIGHT), Image.Resampling.LANCZOS)
+        # img.show()
+        logger.info(f"Screenshot captured in {time.time() - start_time:.2f} seconds.")
+
+        return img
+
+    except Exception as e:
+        logger.info(f"An unexpected error occurred during screenshot capture: {e}")
+        return None
+    
+async def do_work(sentence_to_check=None):
+    # connect_to_obs_sync(5)
+    logger.info("in find_box")
+    # await asyncio.sleep(.5)
+    logger.info("after_initial_sleep")
+    full_screenshot_image = await get_full_screenshot()
+    if os.path.exists("C:\\Users\\Beangate\\GSM\\temp"):
+        full_screenshot_image.save("C:\\Users\\Beangate\\GSM\\temp\\full_screenshot.png")
+    # full_screenshot_image.show()
+    if full_screenshot_image:
+        logger.info("Full screenshot captured successfully. Now performing local OCR...")
+        ocr_results = oneocr(full_screenshot_image, return_coords=True)
+        
+        boxes_of_text = ocr_results[2]
+        # logger.info(f"Boxes of text found: {boxes_of_text}")
+        
+        words = []
+        
+        # If we have a reference sentence, perform character-by-character correction
+        if sentence_to_check:
+            # Concatenate all OCR text to form the detected sentence
+            detected_sentence = ''.join([box['text'] for box in boxes_of_text])
+            logger.info(f"Original detected sentence: '{detected_sentence}'")
+            logger.info(f"Reference sentence: '{sentence_to_check}'")
+            
+            # Perform character-by-character comparison and correction
+            corrected_sentence = correct_ocr_text(detected_sentence, sentence_to_check)
+            logger.info(f"Corrected sentence: '{corrected_sentence}'")
+            
+            # Redistribute corrected text back to boxes while maintaining positions
+            corrected_boxes = redistribute_corrected_text(boxes_of_text, detected_sentence, corrected_sentence)
+        else:
+            corrected_boxes = boxes_of_text
+        
+        sentence_position = 0
+        for box in corrected_boxes:
+            word = box['text']
+            # logger.info(f"Box: {box}")
+            x1, y1 = box['bounding_rect']['x1'], box['bounding_rect']['y1']
+            x2, y2 = box['bounding_rect']['x3'], box['bounding_rect']['y3']
+            words.append({
+                "x1": x1,
+                "y1": y1,
+                "x2": x2,
+                "y2": y2,
+                "word": box['text']
+            })
+        
+        # logger.info(f"Returning words: {words}")
+        
+        ret = [
+            {
+                "words": words,
+            }
+        ]
+        # cropped_sections = []
+        # for box in boxes_of_text:
+        #     # Ensure crop coordinates are within image bounds
+        #     left = max(0, box['bounding_rect']['x1'])
+        #     top = max(0, box['bounding_rect']['y1'])
+        #     right = min(full_screenshot_image.width, box['bounding_rect']['x3'])
+        #     bottom = min(full_screenshot_image.height, box['bounding_rect']['y3'])
+        #     cropped_sections.append(full_screenshot_image.crop((left, top, right, bottom)))
+
+        # if len(cropped_sections) > 1:
+        #     # Create a transparent image with the same size as the full screenshot
+        #     combined_img = Image.new("RGBA", (full_screenshot_image.width, full_screenshot_image.height), (0, 0, 0, 0))
+
+        #     combined_img.show()
+
+        #     # Paste each cropped section at its original coordinates
+        #     for box, section in zip(boxes_of_text, cropped_sections):
+        #         left = max(0, box['bounding_rect']['x1'])
+        #         top = max(0, box['bounding_rect']['y1'])
+        #         combined_img.paste(section, (left, top))
+
+        #     new_image = combined_img
+        # elif cropped_sections:
+        #     new_image = cropped_sections[0]
+        # else:
+        #     new_image = Image.new("RGBA", full_screenshot_image.size)
+
+        # new_image.show()
+        # ocr_results = lens(new_image, return_coords=True)
+        # ocr_results = oneocr(full_screenshot_image, sentence_to_check=sentence_to_check)
+        # logger.info("\n--- OCR Results ---")
+        # logger.info(ocr_results)
+
+        return ret, 48
+        # from PIL import ImageDraw
+        # draw = ImageDraw.Draw(full_screenshot_image)
+        # draw.rectangle([x1, y1, x2, y2], outline="red", width=3)
+        # full_screenshot_image.save("full_screenshot_with_ocr.png")
+        # full_screenshot_image.show()
+        #
+        # logger.info(ocr_results)
+        # if ocr_results:
+        #     for i, result in enumerate(ocr_results):
+        #         logger.info(f"Result {i + 1}:\n{result}\n")
+        # else:
+        #     logger.info("No OCR results found.")
+    else:
+        logger.info("Failed to get full screenshot for OCR.")
+
+async def find_box_for_sentence(sentence_to_check):
+    try:
+        return await do_work(sentence_to_check=sentence_to_check)
+    except Exception as e:
+        logger.info(f"Error in find_box_for_sentence: {e}", exc_info=True)
+        return [], 48
+
+async def main():
+    connect_to_obs_sync(5)
+    await find_box_for_sentence("はじめから")
+
+if __name__ == '__main__':
+    try:
+        asyncio.run(main())
+    except KeyboardInterrupt:
+        logger.info("Script terminated by user.")

{gamesentenceminer-2.12.0.dev5 → gamesentenceminer-2.12.1}/GameSentenceMiner.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: GameSentenceMiner
-Version: 2.12.0.dev5
+Version: 2.12.1
 Summary: A tool for mining sentences from games. Update: Overlay?
 Author-email: Beangate <bpwhelan95@gmail.com>
 License: MIT License

{gamesentenceminer-2.12.0.dev5 → gamesentenceminer-2.12.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: GameSentenceMiner
-Version: 2.12.0.dev5
+Version: 2.12.1
 Summary: A tool for mining sentences from games. Update: Overlay?
 Author-email: Beangate <bpwhelan95@gmail.com>
 License: MIT License

{gamesentenceminer-2.12.0.dev5 → gamesentenceminer-2.12.1}/pyproject.toml

@@ -7,7 +7,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "GameSentenceMiner"
-version = "2.12.0-dev5"
+version = "2.12.1"
 description = "A tool for mining sentences from games. Update: Overlay?"
 readme = "README.md"
 requires-python = ">=3.10"

gamesentenceminer-2.12.0.dev5/GameSentenceMiner/wip/get_overlay_coords.py

@@ -1,95 +0,0 @@
-import asyncio
-import io
-import base64
-from PIL import Image
-import obsws_python as obs
-
-from GameSentenceMiner.owocr.owocr.ocr import GoogleLens, OneOCR
-from GameSentenceMiner.obs import *
-
-# OBS WebSocket settings
-OBS_HOST = 'localhost'
-OBS_PORT = 7274
-OBS_PASSWORD = 'your_obs_websocket_password' # Set your OBS WebSocket password here, if any
-
-WINDOW_NAME = "Nier:Automata"
-WIDTH = 2560
-HEIGHT = 1440
-oneocr = OneOCR()
-lens = GoogleLens()
-
-async def get_full_screenshot() -> Image.Image | None:
-    # print(f"Attempting to connect to OBS WebSocket at ws://{OBS_HOST}:{OBS_PORT}")
-    # try:
-    #     client = obs.ReqClient(host=OBS_HOST, port=OBS_PORT, password=OBS_PASSWORD, timeout=30)
-    #     print("Connected to OBS WebSocket.")
-    # except Exception as e:
-    #     print(f"Failed to connect to OBS: {e}")
-    #     return None
-    #
-    # try:
-    #     response = client.get_source_screenshot(
-    #         name=WINDOW_NAME,
-    #         img_format='png',
-    #         quality=75,
-    #         width=WIDTH,
-    #         height=HEIGHT,
-    #     )
-    #
-    #     if not response.image_data:
-    #         print("Failed to get screenshot data from OBS.")
-    #         return None
-
-    print("Getting Screenshot from OBS")
-    try:
-        update_current_game()
-        start_time = time.time()
-        image_data = get_screenshot_base64(compression=75, width=1280, height=720)
-        image_data = base64.b64decode(image_data)
-        img = Image.open(io.BytesIO(image_data)).convert("RGBA").resize((WIDTH, HEIGHT), Image.Resampling.LANCZOS)
-        # img.show()
-        print(f"Screenshot captured in {time.time() - start_time:.2f} seconds.")
-
-        return img
-
-    except Exception as e:
-        print(f"An unexpected error occurred during screenshot capture: {e}")
-        return None
-
-async def find_box_for_sentence(sentence_to_check):
-    # connect_to_obs_sync(5)
-    print("in find_box")
-    # await asyncio.sleep(.5)
-    print("after_initial_sleep")
-    full_screenshot_image = await get_full_screenshot()
-    if full_screenshot_image:
-        print("Full screenshot captured successfully. Now performing local OCR...")
-        ocr_results = lens(full_screenshot_image, return_coords=True)
-        # ocr_results = oneocr(full_screenshot_image, sentence_to_check=sentence_to_check)
-        print("\n--- OCR Results ---")
-        print(ocr_results)
-
-        return ocr_results[2], 48
-        # from PIL import ImageDraw
-        # draw = ImageDraw.Draw(full_screenshot_image)
-        # draw.rectangle([x1, y1, x2, y2], outline="red", width=3)
-        # full_screenshot_image.save("full_screenshot_with_ocr.png")
-        # full_screenshot_image.show()
-        #
-        # print(ocr_results)
-        # if ocr_results:
-        #     for i, result in enumerate(ocr_results):
-        #         print(f"Result {i + 1}:\n{result}\n")
-        # else:
-        #     print("No OCR results found.")
-    else:
-        print("Failed to get full screenshot for OCR.")
-
-async def main():
-    await find_box_for_sentence("はじめから")
-
-if __name__ == '__main__':
-    try:
-        asyncio.run(main())
-    except KeyboardInterrupt:
-        print("Script terminated by user.")