GameSentenceMiner 2.15.3__py3-none-any.whl → 2.15.5__py3-none-any.whl

GameSentenceMiner/ocr/owocr_helper.py

@@ -1,4 +1,5 @@
 import asyncio
+from copy import copy
 import io
 import json
 import logging
@@ -376,18 +377,19 @@ def text_callback(text, orig_text, time, img=None, came_from_ss=False, filtering
                 return
             previous_orig_text = orig_text_string
             previous_ocr1_result = previous_text
-            if crop_coords and get_ocr_optimize_second_scan():
-                x1, y1, x2, y2 = crop_coords
-                x1 = max(0, min(x1, img.width))
-                y1 = max(0, min(y1, img.height))
-                x2 = max(x1, min(x2, img.width))
-                y2 = max(y1, min(y2, img.height))
-                previous_img_local.save(os.path.join(get_temporary_directory(), "pre_oneocrcrop.png"))
-                try:
-                    previous_img_local = previous_img_local.crop((x1, y1, x2, y2))
-                except ValueError:
-                    logger.warning("Error cropping image, using original image")
-            second_ocr_queue.put((previous_text, stable_time, previous_img_local, filtering, pre_crop_image))
+            ocr2_image = get_ocr2_image(crop_coords, og_image=previous_img_local, ocr2_engine=get_ocr_ocr2())
+            # if crop_coords and get_ocr_optimize_second_scan():
+            #     x1, y1, x2, y2 = crop_coords
+            #     x1 = max(0, min(x1, img.width))
+            #     y1 = max(0, min(y1, img.height))
+            #     x2 = max(x1, min(x2, img.width))
+            #     y2 = max(y1, min(y2, img.height))
+            #     previous_img_local.save(os.path.join(get_temporary_directory(), "pre_oneocrcrop.png"))
+            #     try:
+            #         previous_img_local = previous_img_local.crop((x1, y1, x2, y2))
+            #     except ValueError:
+            #         logger.warning("Error cropping image, using original image")
+            second_ocr_queue.put((previous_text, stable_time, ocr2_image, filtering, pre_crop_image))
             # threading.Thread(target=do_second_ocr, args=(previous_text, stable_time, previous_img_local, filtering), daemon=True).start()
             previous_img = None
             previous_text = None
@@ -412,6 +414,69 @@ done = False
 # Create a queue for tasks
 second_ocr_queue = queue.Queue()
 
+def get_ocr2_image(crop_coords, og_image, ocr2_engine=None):
+    """
+    Returns the image to use for the second OCR pass, cropping and scaling as needed.
+    Logic is unchanged, but code is refactored for clarity and maintainability.
+    """
+    def return_original_image():
+        logger.info("Returning original image for OCR2 (no cropping or optimization).")
+        if not crop_coords or not get_ocr_optimize_second_scan():
+            return og_image
+        x1, y1, x2, y2 = crop_coords
+        x1 = max(0, min(x1, og_image.width))
+        y1 = max(0, min(y1, og_image.height))
+        x2 = max(x1, min(x2, og_image.width))
+        y2 = max(y1, min(y2, og_image.height))
+        og_image.save(os.path.join(get_temporary_directory(), "pre_oneocrcrop.png"))
+        return og_image.crop((x1, y1, x2, y2))
+    
+    LOCAL_OCR_ENGINES = ['easyocr', 'oneocr', 'rapidocr', 'mangaocr', 'winrtocr']
+    local_ocr = ocr2_engine in LOCAL_OCR_ENGINES
+    ocr_config_local = copy(ocr_config)
+
+    # Non-local OCR: just crop the original image if needed
+    if not local_ocr:
+        return return_original_image()
+
+    # Local OCR: get fresh screenshot and apply config/cropping
+    obs_width = getattr(run.obs_screenshot_thread, 'width', None)
+    obs_height = getattr(run.obs_screenshot_thread, 'height', None)
+    if not obs_width or not obs_height:
+        return return_original_image()
+    logger.debug(f"Getting OCR2 image with OBS dimensions: {obs_width}x{obs_height}")
+
+    img = obs.get_screenshot_PIL(compression=100, img_format="jpg")
+    ocr_config_local.scale_to_custom_size(img.width, img.height)
+
+    # If no crop or optimization, just apply config and return
+    if not crop_coords or not get_ocr_optimize_second_scan():
+        img = run.apply_ocr_config_to_image(img, ocr_config_local, is_secondary=True)
+        return img
+
+    # Calculate scaling ratios
+    width_ratio = img.width / obs_width if obs_width else 1
+    height_ratio = img.height / obs_height if obs_height else 1
+    logger.debug(f"Cropping OCR2 image with crop coordinates: {crop_coords} and ratios: {width_ratio}, {height_ratio}")
+
+    # Scale crop_coords
+    x1 = int(crop_coords[0] * width_ratio)
+    y1 = int(crop_coords[1] * height_ratio)
+    x2 = int(crop_coords[2] * width_ratio)
+    y2 = int(crop_coords[3] * height_ratio)
+    logger.debug(f"Scaled crop coordinates: {(x1, y1, x2, y2)}")
+
+    # Clamp coordinates to image bounds
+    x1 = max(0, min(x1, img.width))
+    y1 = max(0, min(y1, img.height))
+    x2 = max(x1, min(x2, img.width))
+    y2 = max(y1, min(y2, img.height))
+
+    img = run.apply_ocr_config_to_image(img, ocr_config_local, is_secondary=False)
+    
+    
+    return img.crop((x1, y1, x2, y2))
+
 def process_task_queue():
     while True:
         try:
@@ -456,7 +521,7 @@ def run_oneocr(ocr_config: OCRConfig, rectangles, config_check_thread):
                 gsm_ocr_config=ocr_config,
                 screen_capture_areas=screen_areas,
                 furigana_filter_sensitivity=furigana_filter_sensitivity,
-                screen_capture_combo=manual_ocr_hotkey if manual_ocr_hotkey and manual else None,
+                screen_capture_combo=manual_ocr_hotkey.upper() if manual_ocr_hotkey and manual else None,
                 config_check_thread=config_check_thread)
     except Exception as e:
         logger.exception(f"Error running OneOCR: {e}")
@@ -530,7 +595,7 @@ def set_force_stable_hotkey():
 
 if __name__ == "__main__":
     try:
-        global ocr1, ocr2, twopassocr, language, ss_clipboard, ss, ocr_config, furigana_filter_sensitivity, area_select_ocr_hotkey, window, optimize_second_scan, use_window_for_config, keep_newline, obs_ocr
+        global ocr1, ocr2, twopassocr, language, ss_clipboard, ss, ocr_config, furigana_filter_sensitivity, area_select_ocr_hotkey, window, optimize_second_scan, use_window_for_config, keep_newline, obs_ocr, manual
         import sys
 
         import argparse
@@ -577,7 +642,7 @@ if __name__ == "__main__":
         keep_newline = args.keep_newline
         obs_ocr = args.obs_ocr
         
-        obs.connect_to_obs_sync(retry=0, check_output=False)
+        obs.connect_to_obs_sync(check_output=False)
     
         # Start config change checker thread
         config_check_thread = ConfigChangeCheckThread()

GameSentenceMiner/owocr/owocr/ocr.py

@@ -1243,7 +1243,7 @@ class OCRSpace:
 class GeminiOCR:
     name = 'gemini'
     readable_name = 'Gemini'
-    key = 'm'
+    key = ';'
     available = False
 
     def __init__(self, config={'api_key': None}, lang='ja'):
@@ -1433,10 +1433,14 @@ class localLLMOCR:
             self.keep_warm = config.get('keep_warm', True)
             self.custom_prompt = config.get('prompt', None)
             self.available = True
+            if not self.check_url_for_connectivity(self.api_url):
+                self.available = False
+                logger.warning(f'Local LLM OCR API URL not reachable: {self.api_url}')
+                return
             self.client = openai.OpenAI(
                 base_url=self.api_url.replace('/v1/chat/completions', '/v1'),
                 api_key=self.api_key,
-                timeout=3
+                timeout=1
             )
             if self.client.models.retrieve(self.model):
                 self.model = self.model
@@ -1446,7 +1450,15 @@ class localLLMOCR:
                 self.keep_llm_hot_thread.start()
         except Exception as e:
             logger.warning(f'Error initializing Local LLM OCR, Local LLM OCR will not work!')
-        
+            
+    def check_url_for_connectivity(self, url):
+        import requests
+        try:
+            response = requests.get(url, timeout=0.5)
+            return response.status_code == 200
+        except Exception:
+            return False
+
     def keep_llm_warm(self):
         def ocr_blank_black_image():
             if self.last_ocr_time and (time.time() - self.last_ocr_time) < 5:

GameSentenceMiner/owocr/owocr/run.py

@@ -42,6 +42,7 @@ import socketserver
 import cv2
 import numpy as np
 
+from collections import deque
 from datetime import datetime, timedelta
 from PIL import Image, ImageDraw
 from loguru import logger
@@ -337,6 +338,7 @@ class TextFiltering:
         self.thai_regex = re.compile(r'[\u0E00-\u0E7F]')
         self.latin_extended_regex = re.compile(
             r'[a-zA-Z\u00C0-\u00FF\u0100-\u017F\u0180-\u024F\u0250-\u02AF\u1D00-\u1D7F\u1D80-\u1DBF\u1E00-\u1EFF\u2C60-\u2C7F\uA720-\uA7FF\uAB30-\uAB6F]')
+        self.last_few_results = {}
         try:
             from transformers import pipeline, AutoTokenizer
             import torch
@@ -361,7 +363,7 @@ class TextFiltering:
             import langid
             self.classify = langid.classify
 
-    def __call__(self, text, last_result):
+    def __call__(self, text, last_result, engine=None, is_second_ocr=False):
         lang = get_ocr_language()
         if self.initial_lang != lang:
             from pysbd import Segmenter
@@ -402,11 +404,24 @@ class TextFiltering:
 
         try:
             if isinstance(last_result, list):
-                last_text = last_result
+                last_text = last_result.copy()
             elif last_result and last_result[1] == engine_index:
                 last_text = last_result[0]
             else:
                 last_text = []
+            
+            if engine and not is_second_ocr:
+                if self.last_few_results and self.last_few_results.get(engine):
+                    for sublist in self.last_few_results.get(engine, []):
+                        if sublist:
+                            for item in sublist:
+                                if item and item not in last_text:
+                                    last_text.append(item)
+                    self.last_few_results[engine].append(orig_text_filtered)
+                else:
+                    self.last_few_results[engine] = deque(maxlen=3)
+                    self.last_few_results[engine].append(orig_text_filtered)
+
         except Exception as e:
             logger.error(f"Error processing last_result {last_result}: {e}")
             last_text = []
@@ -981,7 +996,7 @@ def quick_text_detection(pil_image, threshold_ratio=0.01):
 
 # Use OBS for Screenshot Source (i.e. Linux)
 class OBSScreenshotThread(threading.Thread):
-    def __init__(self, ocr_config, screen_capture_on_combo, width=1280, height=720, interval=1):
+    def __init__(self, ocr_config, screen_capture_on_combo, width=1280, height=720, interval=1, is_manual_ocr=False):
         super().__init__(daemon=True)
         self.ocr_config = ocr_config
         self.interval = interval
@@ -992,6 +1007,7 @@ class OBSScreenshotThread(threading.Thread):
         self.width = width
         self.height = height
         self.use_periodic_queue = not screen_capture_on_combo
+        self.is_manual_ocr = is_manual_ocr
 
     def write_result(self, result):
         if self.use_periodic_queue:
@@ -1003,62 +1019,26 @@ class OBSScreenshotThread(threading.Thread):
     def connect_obs(self):
         import GameSentenceMiner.obs as obs
         obs.connect_to_obs_sync(check_output=False)
-
-    def scale_down_width_height(self, width, height):
-        if width == 0 or height == 0:
-            return self.width, self.height
-        # return width, height
-        aspect_ratio = width / height
-        logger.info(
-            f"Scaling down OBS source dimensions: {width}x{height} (Aspect Ratio: {aspect_ratio})")
-        if aspect_ratio > 2.66:
-            # Ultra-wide (32:9) - use 1920x540
-            logger.info("Using ultra-wide aspect ratio scaling (32:9).")
-            return 1920, 540
-        elif aspect_ratio > 2.33:
-            # 21:9 - use 1920x800
-            logger.info("Using ultra-wide aspect ratio scaling (21:9).")
-            return 1920, 800
-        elif aspect_ratio > 1.77:
-            # 16:9 - use 1280x720
-            logger.info("Using standard aspect ratio scaling (16:9).")
-            return 1280, 720
-        elif aspect_ratio > 1.6:
-            # 16:10 - use 1280x800
-            logger.info("Using standard aspect ratio scaling (16:10).")
-            return 1280, 800
-        elif aspect_ratio > 1.33:
-            # 4:3 - use 960x720
-            logger.info("Using standard aspect ratio scaling (4:3).")
-            return 960, 720
-        elif aspect_ratio > 1.25:
-            # 5:4 - use 900x720
-            logger.info("Using standard aspect ratio scaling (5:4).")
-            return 900, 720
-        elif aspect_ratio > 1.5:
-            # 3:2 - use 1080x720
-            logger.info("Using standard aspect ratio scaling (3:2).")
-            return 1080, 720
-        else:
-            # Default fallback - use original resolution
-            logger.info(
-                "Using default aspect ratio scaling (original resolution).")
-            return width, height
         
     def init_config(self, source=None, scene=None):
         import GameSentenceMiner.obs as obs
         obs.update_current_game()
         self.current_source = source if source else obs.get_active_source()
-        logger.info(f"Current OBS source: {self.current_source}")
+        logger.debug(f"Current OBS source: {self.current_source}")
         self.source_width = self.current_source.get(
             "sceneItemTransform").get("sourceWidth") or self.width
         self.source_height = self.current_source.get(
             "sceneItemTransform").get("sourceHeight") or self.height
-        if self.source_width and self.source_height:
-            self.width, self.height = self.scale_down_width_height(
+        if self.source_width and self.source_height and not self.is_manual_ocr and not get_ocr_two_pass_ocr():
+            self.width, self.height = scale_down_width_height(
                 self.source_width, self.source_height)
             logger.info(
-                f"Using OBS source dimensions: {self.width}x{self.height}")
+                f"Using OBS source dimensions: {self.source_width}x{self.source_height}")
+        else:
+            self.width = self.source_width or 1280
+            self.height = self.source_height or 720
+            logger.info(
+                f"Using source dimensions: {self.width}x{self.height}")
         self.current_source_name = self.current_source.get(
             "sourceName") or None
         self.current_scene = scene if scene else obs.get_current_game()
@@ -1105,7 +1085,7 @@ class OBSScreenshotThread(threading.Thread):
                     self.write_result(1)
                     continue
                 img = obs.get_screenshot_PIL(source_name=self.current_source_name,
-                                             width=self.width, height=self.height, img_format='jpg', compression=80)
+                                             width=self.width, height=self.height, img_format='jpg', compression=100)
                 
                 img = apply_ocr_config_to_image(img, self.ocr_config)
 
@@ -1120,6 +1100,39 @@ class OBSScreenshotThread(threading.Thread):
                     f"An unexpected error occurred during OBS Capture : {e}", exc_info=True)
                 time.sleep(.5)
                 continue
+            
+def scale_down_width_height(width, height):
+        if width == 0 or height == 0:
+            return width, height
+        # return width, height
+        aspect_ratio = width / height
+        logger.info(
+            f"Scaling down OBS source dimensions: {width}x{height} (Aspect Ratio: {aspect_ratio})")
+        if aspect_ratio > 2.66:
+            logger.info("Using ultra-wide aspect ratio scaling (32:9).")
+            return 1920, 540
+        elif aspect_ratio > 2.33:
+            logger.info("Using ultra-wide aspect ratio scaling (21:9).")
+            return 1920, 800
+        elif aspect_ratio > 1.77:
+            logger.info("Using standard aspect ratio scaling (16:9).")
+            return 1280, 720
+        elif aspect_ratio > 1.6:
+            logger.info("Using standard aspect ratio scaling (16:10).")
+            return 1280, 800
+        elif aspect_ratio > 1.33:
+            logger.info("Using standard aspect ratio scaling (4:3).")
+            return 960, 720
+        elif aspect_ratio > 1.25:
+            logger.info("Using standard aspect ratio scaling (5:4).")
+            return 900, 720
+        elif aspect_ratio > 1.5:
+            logger.info("Using standard aspect ratio scaling (3:2).")
+            return 1080, 720
+        else:
+            logger.info(
+                "Using default aspect ratio scaling (original resolution).")
+            return width, height
 
 
 def apply_ocr_config_to_image(img, ocr_config, is_secondary=False):
@@ -1317,8 +1330,10 @@ 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):
+def process_and_write_results(img_or_path, write_to=None, last_result=None, filtering: TextFiltering = None, notify=None, engine=None, ocr_start_time=None, furigana_filter_sensitivity=0):
     global engine_index
+    # TODO Replace this at a later date
+    is_second_ocr = bool(engine)
     if auto_pause_handler:
         auto_pause_handler.stop()
     if engine:
@@ -1328,9 +1343,10 @@ def process_and_write_results(img_or_path, write_to=None, last_result=None, filt
                 break
     else:
         engine_instance = engine_instances[engine_index]
+        engine = engine_instance.name
 
     engine_color = config.get_general('engine_color')
-
+    
     start_time = time.time()
     result = engine_instance(img_or_path, furigana_filter_sensitivity)
     res, text, crop_coords = (*result, None)[:3]
@@ -1362,7 +1378,7 @@ def process_and_write_results(img_or_path, write_to=None, last_result=None, filt
     if res:
         text = do_configured_ocr_replacements(text)
         if filtering:
-            text, orig_text = filtering(text, last_result)
+            text, orig_text = filtering(text, last_result, engine=engine, is_second_ocr=is_second_ocr)
         if get_ocr_language() == "ja" or get_ocr_language() == "zh":
             text = post_process(text, keep_blank_lines=get_ocr_keep_newline())
         if notify and config.get_general('notifications'):
@@ -1382,7 +1398,7 @@ def process_and_write_results(img_or_path, write_to=None, last_result=None, filt
             pyperclipfix.copy(text)
         elif write_to == "callback":
             txt_callback(text, orig_text, ocr_start_time,
-                         img_or_path, bool(engine), filtering, crop_coords)
+                         img_or_path, is_second_ocr, filtering, crop_coords)
         elif write_to:
             with Path(write_to).open('a', encoding='utf-8') as f:
                 f.write(text + '\n')
@@ -1404,7 +1420,7 @@ def check_text_is_all_menu(text: str, crop_coords: tuple) -> bool:
     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.
+    :param crop_coords: Tuple containing (x, y, x2, y2) 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:
@@ -1412,7 +1428,7 @@ def check_text_is_all_menu(text: str, crop_coords: tuple) -> bool:
 
     original_width = obs_screenshot_thread.width
     original_height = obs_screenshot_thread.height
-    crop_x, crop_y, crop_w, crop_h = crop_coords
+    crop_x, crop_y, crop_x2, crop_y2 = crop_coords
 
     ocr_config = get_scene_ocr_config()
     
@@ -1430,14 +1446,14 @@ def check_text_is_all_menu(text: str, crop_coords: tuple) -> bool:
         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:
+        if crop_x < 0 or crop_y < 0 or crop_x2 > original_width or crop_y2 > 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):
+                crop_x2 <= rect_right and crop_y2 <= rect_bottom):
                 return True
         return False
 
@@ -1445,19 +1461,25 @@ def check_text_is_all_menu(text: str, crop_coords: tuple) -> bool:
 
     if len(primary_rectangles) == 1:
         primary_rect = primary_rectangles[0]
-        primary_left, primary_top = primary_rect.coordinates[0], primary_rect.coordinates[1]
+        primary_left, primary_top, primary_width, primary_height = primary_rect.coordinates
         original_x = crop_x + primary_left
         original_y = crop_y + primary_top
+        original_x2 = crop_x2 + primary_left
+        original_y2 = crop_y2 + primary_top
     else:
         current_y_offset = 0
         original_x = None
         original_y = None
+        original_x2 = None
+        original_y2 = 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
+                original_x2 = crop_x2 + primary_left
+                original_y2 = crop_y2 + primary_top
                 break
             current_y_offset += section_height + 50
         if original_x is None or original_y is None:
@@ -1471,7 +1493,7 @@ def check_text_is_all_menu(text: str, crop_coords: tuple) -> bool:
         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):
+            original_x2 <= rect_right and original_y2 <= rect_bottom):
             return True
 
     return False
@@ -1712,7 +1734,7 @@ def run(read_from=None,
         last_result = ([], engine_index)
         screenshot_event = threading.Event()
         obs_screenshot_thread = OBSScreenshotThread(
-            gsm_ocr_config, screen_capture_on_combo, interval=screen_capture_delay_secs)
+            gsm_ocr_config, screen_capture_on_combo, interval=screen_capture_delay_secs, is_manual_ocr=bool(screen_capture_on_combo))
         obs_screenshot_thread.start()
         filtering = TextFiltering()
         read_from_readable.append('obs')

GameSentenceMiner/util/configuration.py

@@ -559,6 +559,7 @@ class VAD:
     add_audio_on_no_results: bool = False
     cut_and_splice_segments: bool = False
     splice_padding: float = 0.1
+    use_cpu_for_inference: bool = False
 
     def is_silero(self):
         return self.selected_vad_model == SILERO or self.backup_vad_model == SILERO

GameSentenceMiner/util/get_overlay_coords.py

@@ -104,7 +104,6 @@ class OverlayProcessor:
         """
         with mss.mss() as sct:
             monitors = sct.monitors[1:]
-            print(monitors)
             if is_windows() and monitor_index == 0:
                 from ctypes import wintypes
                 import ctypes

GameSentenceMiner/vad.py

@@ -139,7 +139,7 @@ class VADProcessor(ABC):
             self.extract_audio_and_combine_segments(input_audio, voice_activity, output_audio, padding=get_config().vad.splice_padding)
         else:
             ffmpeg.trim_audio(input_audio, start_time + get_config().vad.beginning_offset, end_time + get_config().audio.end_offset, output_audio, trim_beginning=get_config().vad.trim_beginning, fade_in_duration=0.05, fade_out_duration=0)
-        return VADResult(True, start_time + get_config().vad.beginning_offset, end_time + get_config().audio.end_offset, self.vad_system_name, voice_activity, output_audio)
+        return VADResult(True, max(0, start_time + get_config().vad.beginning_offset), max(0, end_time + get_config().audio.end_offset), self.vad_system_name, voice_activity, output_audio)
 
 class SileroVADProcessor(VADProcessor):
     def __init__(self):
@@ -165,9 +165,12 @@ class WhisperVADProcessor(VADProcessor):
 
     def load_whisper_model(self):
         import stable_whisper as whisper
+        import torch
         if not self.vad_model:
+            self.device = "cpu" if get_config().vad.use_cpu_for_inference else "cuda" if torch.cuda.is_available() else "cpu"
             with warnings.catch_warnings():
-                self.vad_model = whisper.load_model(get_config().vad.whisper_model)
+                warnings.simplefilter("ignore")
+                self.vad_model = whisper.load_faster_whisper(get_config().vad.whisper_model, device=self.device)
             logger.info(f"Whisper model '{get_config().vad.whisper_model}' loaded.")
         return self.vad_model
 
@@ -181,11 +184,12 @@ class WhisperVADProcessor(VADProcessor):
 
         # Transcribe the audio using Whisper
         with warnings.catch_warnings():
+            warnings.simplefilter("ignore")
             result: WhisperResult = self.vad_model.transcribe(temp_wav, vad=True, language=get_config().vad.language,
                                                              temperature=0.0)
         voice_activity = []
 
-        logger.debug(result.to_dict())
+        logger.debug(json.dumps(result.to_dict(), indent=2))
 
         # Process the segments to extract tokens, timestamps, and confidence
         for i, segment in enumerate(result.segments):

{gamesentenceminer-2.15.3.dist-info → gamesentenceminer-2.15.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: GameSentenceMiner
-Version: 2.15.3
+Version: 2.15.5
 Summary: A tool for mining sentences from games. Update: Overlay?
 Author-email: Beangate <bpwhelan95@gmail.com>
 License: MIT License
@@ -47,11 +47,12 @@ Requires-Dist: betterproto==2.0.0b7
 Requires-Dist: obsws-python~=1.7.2
 Requires-Dist: numpy==2.2.6
 Requires-Dist: regex
+Requires-Dist: faster-whisper~=1.2.0
 Dynamic: license-file
 
 # GSM - An Immersion toolkit for Games.
 
-### English | [日本語](../docs/ja/README.md) | [简体中文](../docs/zh/README.md).
+### English | [日本語](docs/ja/README.md) | [简体中文](docs/zh/README.md).
 
 An application designed to assist with language learning through games.
 

{gamesentenceminer-2.15.3.dist-info → gamesentenceminer-2.15.5.dist-info}/RECORD

@@ -1,10 +1,10 @@
 GameSentenceMiner/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 GameSentenceMiner/anki.py,sha256=4Tq6OGjfN-5tYorYRWiih7FZjSKMG6amrLv6DFKkFQc,25344
-GameSentenceMiner/config_gui.py,sha256=G36MLR1UcdiLB6V3T25_ggGVnt5B4Vj1pS76nQQMqpk,139669
+GameSentenceMiner/config_gui.py,sha256=i79PrY2pP8_VKvIL7uoDv5cgHvCCQBIe0mS_YnX2AVg,140792
 GameSentenceMiner/gametext.py,sha256=fgBgLchezpauWELE9Y5G3kVCLfAneD0X4lJFoI3FYbs,10351
-GameSentenceMiner/gsm.py,sha256=4mJn5v4WKqKAJEtph5e0v4YPVDOpvFN1ylV2vQvf_Dg,31913
-GameSentenceMiner/obs.py,sha256=99V4WvBhbBTEGI1o3dlGzhqnktKFUxPc1-5vOBcV0lk,26296
-GameSentenceMiner/vad.py,sha256=YCn4ZIc6_Q3IGOr5QNMiheVT3Ma5nisn8-V8xD53Mw4,19236
+GameSentenceMiner/gsm.py,sha256=t2GAhMwVEHUzCdqM4tIgAzBUvNmt_Gec515iePacD6k,31945
+GameSentenceMiner/obs.py,sha256=EyAYhaLvMjoeC-3j7fuvkqZN5logFFanPfb8Wn1C6m0,27296
+GameSentenceMiner/vad.py,sha256=WbXLwiGhHOMterYSAdXPdW209h1mF9WsIdTiWER2vOE,19542
 GameSentenceMiner/ai/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 GameSentenceMiner/ai/ai_prompting.py,sha256=41xdBzE88Jlt12A0D-T_cMfLO5j6MSxfniOptpwNZm0,24068
 GameSentenceMiner/assets/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -15,21 +15,21 @@ GameSentenceMiner/assets/icon32.png,sha256=Kww0hU_qke9_22wBuO_Nq0Dv2SfnOLwMhCyGg
 GameSentenceMiner/assets/icon512.png,sha256=HxUj2GHjyQsk8NV433256UxU9phPhtjCY-YB_7W4sqs,192487
 GameSentenceMiner/assets/icon64.png,sha256=N8xgdZXvhqVQP9QUK3wX5iqxX9LxHljD7c-Bmgim6tM,9301
 GameSentenceMiner/assets/pickaxe.png,sha256=VfIGyXyIZdzEnVcc4PmG3wszPMO1W4KCT7Q_nFK6eSE,1403829
-GameSentenceMiner/locales/en_us.json,sha256=FAnvsCfsFzWyxYKZKh8HKHsAahi3Oa4wGVekTTN2WGI,26587
-GameSentenceMiner/locales/ja_jp.json,sha256=-v0ng0psD88-C4XjYazJL0Rn0gwQU7b2VYspvdatDO4,28326
-GameSentenceMiner/locales/zh_cn.json,sha256=X5nw6tsu7ACaZIuSUDSUUjG8qPUwmqyG3TKcPbWSIYw,24654
+GameSentenceMiner/locales/en_us.json,sha256=4lCV34FnDOe0c02qHlHnfujQedmqHSL-feN3lYCCCfs,26744
+GameSentenceMiner/locales/ja_jp.json,sha256=LNLo2qIugMcDGiPbSo018zVAU8K_HG8Q4zvIcsHUzTA,28517
+GameSentenceMiner/locales/zh_cn.json,sha256=lZYB3HAcxhVCSVWcnvuepuCvn6_Y2mvd0-SKJEYx_ko,24829
 GameSentenceMiner/ocr/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 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=8aIpAHSPPByox5qcU4SX-_ECDgQZVEwrXdj4A8AQZ6U,28437
+GameSentenceMiner/ocr/owocr_helper.py,sha256=v1xIfKUwKZNEUUvFNzzalTmIl_Qj_ygFEX4AJszcAVA,31290
 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=JXUboda00-1GYzYYDTiYcPaeWKKwvMdQ-q_CHVB7h10,70014
-GameSentenceMiner/owocr/owocr/run.py,sha256=xbBpyFCVfITZDztsRLT8_sX6BGf1o5LxOPxE9zUWfQc,79975
+GameSentenceMiner/owocr/owocr/ocr.py,sha256=vRTMKLzi6GDBFZWCyf0tYi6es3cP1cvQOBjZqaZmnBg,70482
+GameSentenceMiner/owocr/owocr/run.py,sha256=ctzAhX8nwTYy7E-tqiYFHK51XfY8Y_ze7rBHbDkVPqI,81240
 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
@@ -37,11 +37,11 @@ GameSentenceMiner/tools/furigana_filter_preview.py,sha256=BXv7FChPEJW_VeG5XYt6su
 GameSentenceMiner/tools/ss_selector.py,sha256=cbjMxiKOCuOfbRvLR_PCRlykBrGtm1LXd6u5czPqkmc,4793
 GameSentenceMiner/tools/window_transparency.py,sha256=GtbxbmZg0-UYPXhfHff-7IKZyY2DKe4B9GdyovfmpeM,8166
 GameSentenceMiner/util/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-GameSentenceMiner/util/configuration.py,sha256=JVwaqvfrUrOUiA0kZcznDsCo9hJkJqBpVztyI6JA-YU,40201
+GameSentenceMiner/util/configuration.py,sha256=cpgusOu4lItCBsZyB8QoAJaXjDovIXNlqyKzh2GMYzw,40241
 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=bSvBSvLFmABogPp-quXcQrN-meWvl5NRB6gFEluoNNg,15142
+GameSentenceMiner/util/get_overlay_coords.py,sha256=P5tI7H0cnveGs33aQdvJGy9DV6aIAGh8K8Al1XjNPzw,15114
 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.15.3.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-gamesentenceminer-2.15.3.dist-info/METADATA,sha256=4zXzdtgHkL9Tv-ZNqDJr5mZ9ra6O8UpACup5X0zOy7M,7317
-gamesentenceminer-2.15.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-gamesentenceminer-2.15.3.dist-info/entry_points.txt,sha256=2APEP25DbfjSxGeHtwBstMH8mulVhLkqF_b9bqzU6vQ,65
-gamesentenceminer-2.15.3.dist-info/top_level.txt,sha256=V1hUY6xVSyUEohb0uDoN4UIE6rUZ_JYx8yMyPGX4PgQ,18
-gamesentenceminer-2.15.3.dist-info/RECORD,,
+gamesentenceminer-2.15.5.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+gamesentenceminer-2.15.5.dist-info/METADATA,sha256=yHcF-77fNZT7lLRKXwrMLPN7-zhrW0bLtm5OJ2-ORTA,7348
+gamesentenceminer-2.15.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+gamesentenceminer-2.15.5.dist-info/entry_points.txt,sha256=2APEP25DbfjSxGeHtwBstMH8mulVhLkqF_b9bqzU6vQ,65
+gamesentenceminer-2.15.5.dist-info/top_level.txt,sha256=V1hUY6xVSyUEohb0uDoN4UIE6rUZ_JYx8yMyPGX4PgQ,18
+gamesentenceminer-2.15.5.dist-info/RECORD,,