GameSentenceMiner 2.14.21__py3-none-any.whl → 2.15.1__py3-none-any.whl

GameSentenceMiner/config_gui.py

@@ -2192,6 +2192,9 @@ class ConfigApp:
                                 row=self.current_row, column=0)
         self.overlay_monitor = ttk.Combobox(overlay_frame, values=self.monitors, state="readonly")
         self.overlay_monitor.grid(row=self.current_row, column=1, sticky='EW', pady=2)
+        # disable selection for now, default to value 1
+        self.overlay_monitor.current(0)
+        self.overlay_monitor.config(state="disabled")
         self.current_row += 1
         
         if self.monitors:

GameSentenceMiner/obs.py

@@ -483,6 +483,9 @@ def set_fit_to_screen_for_scene_items(scene_name: str):
     try:
         # 1. Get the canvas (base) resolution from OBS video settings
         video_settings = client.get_video_settings()
+        if not hasattr(video_settings, 'base_width') or not hasattr(video_settings, 'base_height'):
+            logger.debug("Video settings do not have base_width or base_height attributes, probably weird websocket error issue? Idk what causes it..")
+            return
         canvas_width = video_settings.base_width
         canvas_height = video_settings.base_height
 
@@ -499,12 +502,49 @@ def set_fit_to_screen_for_scene_items(scene_name: str):
             item_id = item['sceneItemId']
             source_name = item['sourceName']
             
+            scene_item_transform = item.get('sceneItemTransform', {})
+            
+            source_width = scene_item_transform.get('sourceWidth', None)
+            source_height = scene_item_transform.get('sourceHeight', None)
+            
+            aspect_ratio_different = False
+            if source_width and source_height:
+                source_aspect_ratio = source_width / source_height
+                canvas_aspect_ratio = canvas_width / canvas_height
+                # Check if aspect ratio is different and if it's a standard aspect ratio
+                aspect_ratio_different = abs(source_aspect_ratio - canvas_aspect_ratio) > 0.01
+
+                # List of standard aspect ratios
+                standard_ratios = [
+                    4 / 3,
+                    16 / 9,
+                    16 / 10,
+                    21 / 9,
+                    32 / 9,
+                    5 / 4,
+                    3 / 2,
+                ]
+
+                def is_standard_ratio(ratio):
+                    return any(abs(ratio - std) < 0.02 for std in standard_ratios)
+
+                # Only crop if both source and canvas are standard aspect ratios
+                if aspect_ratio_different:
+                    if not (is_standard_ratio(source_aspect_ratio) and is_standard_ratio(canvas_aspect_ratio)):
+                        aspect_ratio_different = False
+            
             # This transform object is the equivalent of "Fit to Screen"
             fit_to_screen_transform = {
                 'boundsType': 'OBS_BOUNDS_SCALE_INNER',
                 'alignment': 5,  # 5 = Center alignment (horizontal and vertical)
                 'boundsWidth': canvas_width,
                 'boundsHeight': canvas_height,
+                'positionX': 0,
+                'positionY': 0,
+                'cropLeft': 0 if not aspect_ratio_different or canvas_width > source_width else (source_width - canvas_width) // 2,
+                'cropRight': 0 if not aspect_ratio_different or canvas_width > source_width else (source_width - canvas_width) // 2,
+                'cropTop': 0 if not aspect_ratio_different or canvas_height > source_height else (source_height - canvas_height) // 2,
+                'cropBottom': 0 if not aspect_ratio_different or canvas_height > source_height else (source_height - canvas_height) // 2,
             }
 
             try:

GameSentenceMiner/ocr/gsm_ocr_config.py

@@ -83,7 +83,6 @@ class OCRConfig:
                 ]
 
     def scale_to_custom_size(self, width, height):
-        print(self.pre_scale_rectangles)
         self.rectangles = self.pre_scale_rectangles.copy()
         if self.coordinate_system and self.coordinate_system == "percentage":
             for rectangle in self.rectangles:

GameSentenceMiner/ocr/owocr_helper.py

@@ -228,7 +228,6 @@ def save_result_image(img, pre_crop_image=None):
 
 async def send_result(text, time):
     if text:
-        text = do_text_replacements(text, OCR_REPLACEMENTS_FILE)
         if get_ocr_send_to_clipboard():
             import pyperclip
             pyperclip.copy(text)

GameSentenceMiner/owocr/owocr/ocr.py

@@ -106,6 +106,7 @@ def empty_post_process(text):
 
 def post_process(text, keep_blank_lines=False):
     import jaconv
+    text = text.replace("\"", "")
     if keep_blank_lines:
         text = '\n'.join([''.join(i.split()) for i in text.splitlines()])
     else:
@@ -354,8 +355,8 @@ class GoogleLens:
         response_proto = LensOverlayServerResponse().FromString(res.content)
         response_dict = response_proto.to_dict(betterproto.Casing.SNAKE)
 
-        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:
+        if os.path.exists(r"C:\Users\Beangate\GSM\test"):
+            with open(os.path.join(r"C:\Users\Beangate\GSM\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']
@@ -1433,10 +1434,10 @@ class localLLMOCR:
             self.keep_warm = config.get('keep_warm', True)
             self.custom_prompt = config.get('prompt', None)
             self.available = True
-            # if any(x in self.api_url for x in ['localhost', '127.0.0.1']):
-            #     if not self.check_connection(self.api_url):
-            #         logger.warning('Local LLM OCR API is not reachable')
-            #         return
+            if any(x in self.api_url for x in ['localhost', '127.0.0.1']):
+                if not self.check_connection(self.api_url):
+                    logger.warning('Local LLM OCR API is not reachable')
+                    return
             self.client = openai.OpenAI(
                 base_url=self.api_url.replace('/v1/chat/completions', '/v1'),
                 api_key=self.api_key
@@ -1493,7 +1494,7 @@ class localLLMOCR:
                 prompt = self.custom_prompt.strip()
             else:
                 prompt = f"""
-                Extract all {CommonLanguages.from_code(get_ocr_language()).name} Text from Image. Ignore all Furigana. Do not return any commentary, just the text in the image. If there is no text in the image, return "" (Empty String).
+                Extract all {CommonLanguages.from_code(get_ocr_language()).name} Text from Image. Ignore all Furigana. Do not return any commentary, just the text in the image. Do not Translate. If there is no text in the image, return "" (Empty String).
                 """
 
             response = self.client.chat.completions.create(

GameSentenceMiner/owocr/owocr/run.py

@@ -1,5 +1,6 @@
-from ...ocr.gsm_ocr_config import set_dpi_awareness, get_scene_ocr_config_path, OCRConfig, get_scene_ocr_config
-from ...util.electron_config import *
+from GameSentenceMiner.ocr.gsm_ocr_config import set_dpi_awareness, get_scene_ocr_config
+from GameSentenceMiner.util.electron_config import *  # noqa: F403
+from GameSentenceMiner.util.gsm_utils import do_text_replacements, OCR_REPLACEMENTS_FILE
 
 try:
     import win32gui
@@ -28,7 +29,6 @@ import signal
 import threading
 from pathlib import Path
 import queue
-import io
 import re
 import logging
 import inspect
@@ -39,23 +39,22 @@ import mss
 import asyncio
 import websockets
 import socketserver
-import queue
+import cv2
+import numpy as np
 
 from datetime import datetime, timedelta
-from PIL import Image, ImageDraw, UnidentifiedImageError
+from PIL import Image, ImageDraw
 from loguru import logger
 from desktop_notifier import DesktopNotifierSync
 import psutil
 
-import inspect
-from .ocr import *
-try:
-    from .secret import *
-except ImportError:
-    pass
+from .ocr import *  # noqa: F403
 from .config import Config
 from .screen_coordinate_picker import get_screen_selection
-from GameSentenceMiner.util.configuration import get_temporary_directory, get_config
+from GameSentenceMiner.util.configuration import get_temporary_directory
+
+from skimage.metrics import structural_similarity as ssim
+from typing import Union
 
 config = None
 last_image = None
@@ -799,8 +798,6 @@ class ScreenshotThread(threading.Thread):
             self.windows_window_tracker_instance.join()
 
 
-import cv2
-import numpy as np
     
 def apply_adaptive_threshold_filter(img):
     img = cv2.cvtColor(np.array(img), cv2.COLOR_RGB2BGR)
@@ -865,11 +862,6 @@ def are_images_identical(img1, img2, img2_np=None):
     return (img1_np.shape == img2_np.shape) and np.array_equal(img1_np, img2_np)
 
 
-import cv2
-import numpy as np
-from skimage.metrics import structural_similarity as ssim
-from typing import Union
-
 ImageType = Union[np.ndarray, Image.Image]
 
 def _prepare_image(image: ImageType) -> np.ndarray:
@@ -1319,6 +1311,10 @@ def on_screenshot_combo():
 def on_window_minimized(minimized):
     global screencapture_window_visible
     screencapture_window_visible = not minimized
+    
+
+def do_configured_ocr_replacements(text: str) -> str:
+    return do_text_replacements(text, OCR_REPLACEMENTS_FILE)
 
 
 def process_and_write_results(img_or_path, write_to=None, last_result=None, filtering=None, notify=None, engine=None, ocr_start_time=None, furigana_filter_sensitivity=0):
@@ -1364,14 +1360,21 @@ def process_and_write_results(img_or_path, write_to=None, last_result=None, filt
     # print(engine_index)
 
     if res:
+        text = do_configured_ocr_replacements(text)
         if filtering:
             text, orig_text = filtering(text, last_result)
         if get_ocr_language() == "ja" or get_ocr_language() == "zh":
             text = post_process(text, keep_blank_lines=get_ocr_keep_newline())
-        logger.opt(ansi=True).info(
-            f'Text recognized in {end_time - start_time:0.03f}s using <{engine_color}>{engine_instance.readable_name}</{engine_color}>: {text}')
         if notify and config.get_general('notifications'):
             notifier.send(title='owocr', message='Text recognized: ' + text)
+            
+        if text and write_to is not None:
+            if check_text_is_all_menu(text, crop_coords):
+                logger.opt(ansi=True).info('Text is identified as all menu items, skipping further processing.')
+                return orig_text, ''
+            
+        logger.opt(ansi=True).info(
+    f'Text recognized in {end_time - start_time:0.03f}s using <{engine_color}>{engine_instance.readable_name}</{engine_color}>: {text}')
 
         if write_to == 'websocket':
             websocket_server_thread.send_text(text)
@@ -1395,6 +1398,83 @@ def process_and_write_results(img_or_path, write_to=None, last_result=None, filt
 
     return orig_text, text
 
+def check_text_is_all_menu(text: str, crop_coords: tuple) -> bool:
+    """
+    Checks if the recognized text consists entirely of menu items.
+    This function checks if the detected text area falls entirely within secondary rectangles (menu areas).
+
+    :param text: The recognized text from OCR.
+    :param crop_coords: Tuple containing (x, y, width, height) of the detected text area relative to the cropped image.
+    :return: True if the text is all menu items (within secondary rectangles), False otherwise.
+    """
+    if not text or not crop_coords:
+        return False
+
+    original_width = obs_screenshot_thread.width
+    original_height = obs_screenshot_thread.height
+    crop_x, crop_y, crop_w, crop_h = crop_coords
+
+    ocr_config = get_scene_ocr_config()
+    
+    if not any(rect.is_secondary for rect in ocr_config.rectangles):
+        return False
+
+    ocr_config.scale_to_custom_size(original_width, original_height)
+    if not ocr_config or not ocr_config.rectangles:
+        return False
+
+    primary_rectangles = [rect for rect in ocr_config.rectangles if not rect.is_excluded and not rect.is_secondary]
+    menu_rectangles = [rect for rect in ocr_config.rectangles if rect.is_secondary and not rect.is_excluded]
+
+    if not menu_rectangles:
+        return False
+
+    if not primary_rectangles:
+        if crop_x < 0 or crop_y < 0 or crop_x + crop_w > original_width or crop_y + crop_h > original_height:
+            return False
+        for menu_rect in menu_rectangles:
+            rect_left, rect_top, rect_width, rect_height = menu_rect.coordinates
+            rect_right = rect_left + rect_width
+            rect_bottom = rect_top + rect_height
+            if (crop_x >= rect_left and crop_y >= rect_top and
+                crop_x + crop_w <= rect_right and crop_y + crop_h <= rect_bottom):
+                return True
+        return False
+
+    primary_rectangles.sort(key=lambda r: r.coordinates[1])
+
+    if len(primary_rectangles) == 1:
+        primary_rect = primary_rectangles[0]
+        primary_left, primary_top = primary_rect.coordinates[0], primary_rect.coordinates[1]
+        original_x = crop_x + primary_left
+        original_y = crop_y + primary_top
+    else:
+        current_y_offset = 0
+        original_x = None
+        original_y = None
+        for i, primary_rect in enumerate(primary_rectangles):
+            primary_left, primary_top, primary_width, primary_height = primary_rect.coordinates
+            section_height = primary_height
+            if crop_y >= current_y_offset and crop_y < current_y_offset + section_height:
+                original_x = crop_x + primary_left
+                original_y = (crop_y - current_y_offset) + primary_top
+                break
+            current_y_offset += section_height + 50
+        if original_x is None or original_y is None:
+            return False
+
+    if original_x < 0 or original_y < 0 or original_x > original_width or original_y > original_height:
+        return False
+
+    for menu_rect in menu_rectangles:
+        rect_left, rect_top, rect_width, rect_height = menu_rect.coordinates
+        rect_right = rect_left + rect_width
+        rect_bottom = rect_top + rect_height
+        if (original_x >= rect_left and original_y >= rect_top and
+            original_x <= rect_right and original_y <= rect_bottom):
+            return True
+
+    return False
 
 def get_path_key(path):
     return path, path.lstat().st_mtime

GameSentenceMiner/util/get_overlay_coords.py

@@ -94,26 +94,59 @@ class OverlayProcessor:
         except Exception as e:
             logger.error(f"Error during OCR processing: {e}", exc_info=True)
             return []
+        
+    @staticmethod
+    def get_monitor_workarea(monitor_index=0):
+        """
+        Return MSS-style dict for monitor area.
+        For primary monitor, excludes taskbar. For others, returns full monitor area.
+        monitor_index: 0 = primary monitor, 1+ = others (as in mss.monitors).
+        """
+        with mss.mss() as sct:
+            monitors = sct.monitors[1:]
+            print(monitors)
+            if is_windows() and monitor_index == 0:
+                from ctypes import wintypes
+                import ctypes
+                # Get work area for primary monitor (ignores taskbar)
+                SPI_GETWORKAREA = 0x0030
+                rect = wintypes.RECT()
+                res = ctypes.windll.user32.SystemParametersInfoW(
+                    SPI_GETWORKAREA, 0, ctypes.byref(rect), 0
+                )
+                if not res:
+                    raise ctypes.WinError()
+                
+                return {
+                    "left": rect.left,
+                    "top": rect.top,
+                    "width": rect.right - rect.left,
+                    "height": rect.bottom - rect.top,
+                }
+            elif is_windows() and monitor_index > 0:
+                # Secondary monitors: just return with a guess of how tall the taskbar is
+                taskbar_height_guess = 48  # A common taskbar height, may vary
+                mon = monitors[monitor_index]
+                return {
+                    "left": mon["left"],
+                    "top": mon["top"],
+                    "width": mon["width"],
+                    "height": mon["height"] - taskbar_height_guess
+                }
+            else:
+                # For non-Windows systems or unspecified monitors, return the monitor area as-is
+                return monitors[monitor_index] if 0 <= monitor_index < len(monitors) else monitors[0]
+
 
     def _get_full_screenshot(self) -> Tuple[Image.Image | None, int, int]:
         """Captures a screenshot of the configured monitor."""
         if not mss:
             raise RuntimeError("MSS screenshot library is not installed.")
-        
         with mss.mss() as sct:
-            monitors = sct.monitors
-            # Index 0 is the 'all monitors' virtual screen, so we skip it.
-            monitor_list = monitors[1:] if len(monitors) > 1 else [monitors[0]]
-            
-            monitor_index = self.config.overlay.monitor_to_capture
-            if monitor_index >= len(monitor_list):
-                logger.error(f"Monitor index {monitor_index} is out of bounds. Found {len(monitor_list)} monitors.")
-                return None, 0, 0
-                
-            monitor = monitor_list[monitor_index]
+            monitor = self.get_monitor_workarea(0)  # Get primary monitor work area
             sct_img = sct.grab(monitor)
             img = Image.frombytes('RGB', sct_img.size, sct_img.bgra, 'raw', 'BGRX')
-            
+                
             return img, monitor['width'], monitor['height']
 
     def _create_composite_image(
@@ -210,7 +243,8 @@ class OverlayProcessor:
             crop_x=0,
             crop_y=0,
             crop_width=composite_image.width,
-            crop_height=composite_image.height
+            crop_height=composite_image.height,
+            use_percentages=True
         )
         
         return extracted_data
@@ -223,7 +257,8 @@ class OverlayProcessor:
         crop_x: int,
         crop_y: int,
         crop_width: int,
-        crop_height: int
+        crop_height: int,
+        use_percentages: bool
     ) -> List[Dict[str, Any]]:
         """
         Parses Google Lens API response and converts normalized coordinates
@@ -244,9 +279,10 @@ class OverlayProcessor:
                     word_text = word.get("plain_text", "")
                     line_text_parts.append(word_text)
                     
-                    word_box = self._convert_box_to_pixels_v2(
+                    word_box = self._convert_box_to_overlay_coords(
                         word["geometry"]["bounding_box"],
-                        crop_x, crop_y, crop_width, crop_height
+                        crop_x, crop_y, crop_width, crop_height,
+                        use_percentage=use_percentages
                     )
                     
                     word_list.append({
@@ -258,9 +294,9 @@ class OverlayProcessor:
                     continue
                 
                 full_line_text = "".join(line_text_parts)
-                line_box = self._convert_box_to_pixels_v2(
+                line_box = self._convert_box_to_overlay_coords(
                     line["geometry"]["bounding_box"],
-                    crop_x, crop_y, crop_width, crop_height
+                    crop_x, crop_y, crop_width, crop_height, use_percentage=use_percentages
                 )
 
                 results.append({
@@ -270,36 +306,45 @@ class OverlayProcessor:
                 })
         return results
 
-    def _convert_box_to_pixels_v2(
+    def _convert_box_to_overlay_coords(
         self,
         bbox_data: Dict[str, float],
         crop_x: int,
         crop_y: int,
         crop_width: int,
-        crop_height: int
+        crop_height: int,
+        use_percentage: bool
     ) -> Dict[str, float]:
         """
         Simplified conversion: scales normalized bbox to pixel coordinates within
         the cropped region, then offsets by the crop position. Ignores rotation.
+        If use_percentage is True, returns coordinates as percentages of the crop dimensions.
         """
         cx, cy = bbox_data['center_x'], bbox_data['center_y']
         w, h = bbox_data['width'], bbox_data['height']
 
-        # Scale normalized coordinates to pixel coordinates relative to the crop area
-        box_width_px = w * crop_width
-        box_height_px = h * crop_height
-        
-        # Calculate center within the cropped area and then add the crop offset
-        center_x_px = (cx * crop_width) + crop_x
-        center_y_px = (cy * crop_height) + crop_y
+        if use_percentage:
+            # Return coordinates as percentages of the crop dimensions
+            box_width = w
+            box_height = h
+            center_x = cx
+            center_y = cy
+        else:
+            # Scale normalized coordinates to pixel coordinates relative to the crop area
+            box_width = w * crop_width
+            box_height = h * crop_height
+
+            # Calculate center within the cropped area and then add the crop offset
+            center_x = (cx * crop_width) + crop_x
+            center_y = (cy * crop_height) + crop_y
 
         # Calculate corners (unrotated)
-        half_w_px, half_h_px = box_width_px / 2, box_height_px / 2
+        half_w, half_h = box_width / 2, box_height / 2
         return {
-            "x1": center_x_px - half_w_px, "y1": center_y_px - half_h_px,
-            "x2": center_x_px + half_w_px, "y2": center_y_px - half_h_px,
-            "x3": center_x_px + half_w_px, "y3": center_y_px + half_h_px,
-            "x4": center_x_px - half_w_px, "y4": center_y_px + half_h_px,
+            "x1": center_x - half_w, "y1": center_y - half_h,
+            "x2": center_x + half_w, "y2": center_y - half_h,
+            "x3": center_x + half_w, "y3": center_y + half_h,
+            "x4": center_x - half_w, "y4": center_y + half_h,
         }
 
 async def main_test_screenshot():
@@ -334,22 +379,10 @@ async def main_run_ocr():
     """
     Main function to demonstrate running the full OCR process.
     """
-    processor = OverlayProcessor()
-    results, _ = await processor.find_box_for_sentence()
-    if results:
-        import json
-        print("OCR process completed successfully.")
-        # print(json.dumps(results, indent=2, ensure_ascii=False))
-        # Find first result with some text
-        for result in results:
-            if result.get("text"):
-                print(f"Found line: '{result['text']}'")
-                print(f"  - Line BBox: {result['bounding_rect']}")
-                if result.get("words"):
-                    print(f"  - First word: '{result['words'][0]['text']}' BBox: {result['words'][0]['bounding_rect']}")
-                break
-    else:
-        print("OCR process did not find any text.")
+    overlay_processor = OverlayProcessor()
+    while True:
+        await overlay_processor.find_box_and_send_to_overlay('')
+        await asyncio.sleep(10)
 
 
 if __name__ == '__main__':

{gamesentenceminer-2.14.21.dist-info → gamesentenceminer-2.15.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: GameSentenceMiner
-Version: 2.14.21
+Version: 2.15.1
 Summary: A tool for mining sentences from games. Update: Overlay?
 Author-email: Beangate <bpwhelan95@gmail.com>
 License: MIT License
@@ -57,7 +57,7 @@ An application designed to assist with language learning through games.
 
 Short Demo (Watch this first): https://www.youtube.com/watch?v=FeFBL7py6HY
 
-Installation: https://youtu.be/h5ksXallc-o
+Installation: https://www.youtube.com/watch?v=sVL9omRbGc4
 
 Discord: https://discord.gg/yP8Qse6bb8
 

{gamesentenceminer-2.14.21.dist-info → gamesentenceminer-2.15.1.dist-info}/RECORD

@@ -1,9 +1,9 @@
 GameSentenceMiner/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 GameSentenceMiner/anki.py,sha256=4Tq6OGjfN-5tYorYRWiih7FZjSKMG6amrLv6DFKkFQc,25344
-GameSentenceMiner/config_gui.py,sha256=SDZ4TEkdhvXxOM_pEG1LABt12M1QkKjMHcQX7bG0OAs,139519
+GameSentenceMiner/config_gui.py,sha256=G36MLR1UcdiLB6V3T25_ggGVnt5B4Vj1pS76nQQMqpk,139669
 GameSentenceMiner/gametext.py,sha256=fgBgLchezpauWELE9Y5G3kVCLfAneD0X4lJFoI3FYbs,10351
 GameSentenceMiner/gsm.py,sha256=4mJn5v4WKqKAJEtph5e0v4YPVDOpvFN1ylV2vQvf_Dg,31913
-GameSentenceMiner/obs.py,sha256=oUeQgspkdk2iVTZ3Mi7mDJxAJMYbeKQCf2HviPTl3Hs,23579
+GameSentenceMiner/obs.py,sha256=pr3n2Z9S80vYlwaYi516iwQL4DZKLx6owQofbwUMPnQ,25837
 GameSentenceMiner/vad.py,sha256=YCn4ZIc6_Q3IGOr5QNMiheVT3Ma5nisn8-V8xD53Mw4,19236
 GameSentenceMiner/ai/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 GameSentenceMiner/ai/ai_prompting.py,sha256=41xdBzE88Jlt12A0D-T_cMfLO5j6MSxfniOptpwNZm0,24068
@@ -19,17 +19,17 @@ GameSentenceMiner/locales/en_us.json,sha256=FAnvsCfsFzWyxYKZKh8HKHsAahi3Oa4wGVek
 GameSentenceMiner/locales/ja_jp.json,sha256=-v0ng0psD88-C4XjYazJL0Rn0gwQU7b2VYspvdatDO4,28326
 GameSentenceMiner/locales/zh_cn.json,sha256=X5nw6tsu7ACaZIuSUDSUUjG8qPUwmqyG3TKcPbWSIYw,24654
 GameSentenceMiner/ocr/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-GameSentenceMiner/ocr/gsm_ocr_config.py,sha256=QyBarjb6Wjt-oyor1sIT9hG-KrGdi6wODLyCrHXun6E,6008
+GameSentenceMiner/ocr/gsm_ocr_config.py,sha256=DfcR3bHTu26JJerLzqfW_KpdgUBSrRV4hqSy_LYclps,5967
 GameSentenceMiner/ocr/ocrconfig.py,sha256=_tY8mjnzHMJrLS8E5pHqYXZjMuLoGKYgJwdhYgN-ny4,6466
 GameSentenceMiner/ocr/owocr_area_selector.py,sha256=Rm1_nuZotJhfOfoJ_3mesh9udtOBjYqKhnAvSief6fo,29181
-GameSentenceMiner/ocr/owocr_helper.py,sha256=vquG3O1-2LdAuSt9yQ5hFzCv2E5rDnfqw7eaY33zsYM,28502
+GameSentenceMiner/ocr/owocr_helper.py,sha256=8aIpAHSPPByox5qcU4SX-_ECDgQZVEwrXdj4A8AQZ6U,28437
 GameSentenceMiner/ocr/ss_picker.py,sha256=0IhxUdaKruFpZyBL-8SpxWg7bPrlGpy3lhTcMMZ5rwo,5224
 GameSentenceMiner/owocr/owocr/__init__.py,sha256=87hfN5u_PbL_onLfMACbc0F5j4KyIK9lKnRCj6oZgR0,49
 GameSentenceMiner/owocr/owocr/__main__.py,sha256=XQaqZY99EKoCpU-gWQjNbTs7Kg17HvBVE7JY8LqIE0o,157
 GameSentenceMiner/owocr/owocr/config.py,sha256=qM7kISHdUhuygGXOxmgU6Ef2nwBShrZtdqu4InDCViE,8103
 GameSentenceMiner/owocr/owocr/lens_betterproto.py,sha256=oNoISsPilVVRBBPVDtb4-roJtAhp8ZAuFTci3TGXtMc,39141
-GameSentenceMiner/owocr/owocr/ocr.py,sha256=kyRDBbid7HmZ3giHcuEISEOSjRL8vDeaN9eMSfxe32I,71002
-GameSentenceMiner/owocr/owocr/run.py,sha256=6CU5R3MM4tTHh1vpec6tSZ5I90D22KUOg7XrR-ywm2Q,76155
+GameSentenceMiner/owocr/owocr/ocr.py,sha256=rJKmB8xtSVrayq8XcZ4JKBULyPKDqfJDGKgLjICbUX8,71021
+GameSentenceMiner/owocr/owocr/run.py,sha256=xbBpyFCVfITZDztsRLT8_sX6BGf1o5LxOPxE9zUWfQc,79975
 GameSentenceMiner/owocr/owocr/screen_coordinate_picker.py,sha256=Na6XStbQBtpQUSdbN3QhEswtKuU1JjReFk_K8t5ezQE,3395
 GameSentenceMiner/tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 GameSentenceMiner/tools/audio_offset_selector.py,sha256=8Stk3BP-XVIuzRv9nl9Eqd2D-1yD3JrgU-CamBywJmY,8542
@@ -41,7 +41,7 @@ GameSentenceMiner/util/configuration.py,sha256=JVwaqvfrUrOUiA0kZcznDsCo9hJkJqBpV
 GameSentenceMiner/util/db.py,sha256=2bO0rD4i8A1hhsRBER-wgZy9IK17ibRbI8DHxdKvYsI,16598
 GameSentenceMiner/util/electron_config.py,sha256=KfeJToeFFVw0IR5MKa-gBzpzaGrU-lyJbR9z-sDEHYU,8767
 GameSentenceMiner/util/ffmpeg.py,sha256=jA-cFtCmdCWrUSPpdtFSLr-GSoqs4qNUzW20v4HPHf0,28715
-GameSentenceMiner/util/get_overlay_coords.py,sha256=VtrT25DOjqMgo-eRFRMovuq6LUnoY8GrpbkfDsvgSjM,13855
+GameSentenceMiner/util/get_overlay_coords.py,sha256=bSvBSvLFmABogPp-quXcQrN-meWvl5NRB6gFEluoNNg,15142
 GameSentenceMiner/util/gsm_utils.py,sha256=Piwv88Q9av2LBeN7M6QDi0Mp0_R2lNbkcI6ekK5hd2o,11851
 GameSentenceMiner/util/model.py,sha256=R-_RYTYLSDNgBoVTPuPBcIHeOznIqi_vBzQ7VQ20WYk,6727
 GameSentenceMiner/util/notification.py,sha256=YBhf_mSo_i3cjBz-pmeTPx3wchKiG9BK2VBdZSa2prQ,4597
@@ -72,9 +72,9 @@ GameSentenceMiner/web/templates/index.html,sha256=LqXZx7-NE42pXSpHNZ3To680rD-vt9
 GameSentenceMiner/web/templates/text_replacements.html,sha256=tV5c8mCaWSt_vKuUpbdbLAzXZ3ATZeDvQ9PnnAfqY0M,8598
 GameSentenceMiner/web/templates/utility.html,sha256=3flZinKNqUJ7pvrZk6xu__v67z44rXnaK7UTZ303R-8,16946
 GameSentenceMiner/wip/__init___.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-gamesentenceminer-2.14.21.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-gamesentenceminer-2.14.21.dist-info/METADATA,sha256=G9vL0piNQqJcNMhTzcRHYT0DOUzJS_b3cujW0jldaXU,7303
-gamesentenceminer-2.14.21.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-gamesentenceminer-2.14.21.dist-info/entry_points.txt,sha256=2APEP25DbfjSxGeHtwBstMH8mulVhLkqF_b9bqzU6vQ,65
-gamesentenceminer-2.14.21.dist-info/top_level.txt,sha256=V1hUY6xVSyUEohb0uDoN4UIE6rUZ_JYx8yMyPGX4PgQ,18
-gamesentenceminer-2.14.21.dist-info/RECORD,,
+gamesentenceminer-2.15.1.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+gamesentenceminer-2.15.1.dist-info/METADATA,sha256=bGgKYTzm7t0Ko5S8johUdqLaSDJrqtmiFSrkjiwd1wk,7317
+gamesentenceminer-2.15.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+gamesentenceminer-2.15.1.dist-info/entry_points.txt,sha256=2APEP25DbfjSxGeHtwBstMH8mulVhLkqF_b9bqzU6vQ,65
+gamesentenceminer-2.15.1.dist-info/top_level.txt,sha256=V1hUY6xVSyUEohb0uDoN4UIE6rUZ_JYx8yMyPGX4PgQ,18
+gamesentenceminer-2.15.1.dist-info/RECORD,,