GameSentenceMiner 2.19.6__py3-none-any.whl → 2.19.8__py3-none-any.whl

GameSentenceMiner/anki.py

@@ -28,7 +28,7 @@ import re
 import platform
 import sys
 
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from typing import Dict, Any, List
 
 # Global variables to track state
@@ -58,6 +58,8 @@ class MediaAssets:
     final_prev_screenshot_path: str = ''
     final_video_path: str = ''
 
+    extra_tags: List[str] = field(default_factory=list)
+
 
 def _determine_update_conditions(last_note: 'AnkiCard') -> (bool, bool):
     """Determine if audio and picture fields should be updated."""
@@ -83,7 +85,10 @@ def _generate_media_files(reuse_audio: bool, game_line: 'GameLine', video_path:
         assets.screenshot_in_anki = anki_result.screenshot_in_anki
         assets.prev_screenshot_in_anki = anki_result.prev_screenshot_in_anki
         assets.video_in_anki = anki_result.video_in_anki
+        assets.extra_tags = anki_result.extra_tags
         return assets
+    
+    assets.extra_tags = []
 
     # --- Generate new media files ---
     if config.anki.picture_field and config.screenshot.enabled:
@@ -242,7 +247,7 @@ def update_anki_card(last_note: 'AnkiCard', note=None, audio_path='', video_path
         
         # Add NSFW tag if checkbox was selected
         if add_nsfw_tag:
-            tags.append("NSFW")
+            assets.extra_tags.append("NSFW")
 
     # 5. If creating new media, store files in Anki's collection. Then update note fields.
     if not use_existing_files:
@@ -266,6 +271,9 @@ def update_anki_card(last_note: 'AnkiCard', note=None, audio_path='', video_path
         if config.audio.external_tool and config.audio.external_tool_enabled:
             anki_media_audio_path = os.path.join(config.audio.anki_media_collection, assets.audio_in_anki)
             open_audio_in_external(anki_media_audio_path)
+            
+    for extra_tag in assets.extra_tags:
+        tags.append(extra_tag)
 
     # 6. Asynchronously update the note in Anki
     run_new_thread(lambda: check_and_update_note(last_note, note, tags))
@@ -284,7 +292,8 @@ def update_anki_card(last_note: 'AnkiCard', note=None, audio_path='', video_path
             multi_line=bool(selected_lines and len(selected_lines) > 1),
             video_in_anki=assets.video_in_anki or '',
             word_path=word_path,
-            word=tango
+            word=tango,
+            extra_tags=assets.extra_tags
         )
     
     # 9. Update the local application database with final paths

GameSentenceMiner/locales/en_us.json

@@ -358,6 +358,10 @@
           "hotkey_updates_anki": {
             "label": "Screenshot Hotkey Updates Anki:",
             "tooltip": "Enable to allow Screenshot hotkey/button to update the latest anki card."
+          },
+          "trim_black_bars": {
+            "label": "Trim Black Bars:",
+            "tooltip": "Automatically trim black bars from screenshots. Useful for games with letterboxing/pillarboxing (e.g., 4:3 games on 16:9 displays)."
           }
         },
         "audio": {

GameSentenceMiner/locales/ja_jp.json

@@ -357,6 +357,10 @@
           "hotkey_updates_anki": {
             "label": "ホットキーでAnkiを更新:",
             "tooltip": "撮影ホットキーで最新のAnkiカードを更新できるようにします。"
+          },
+          "trim_black_bars": {
+            "label": "黒帯をトリミング:",
+            "tooltip": "スクリーンショットから黒帯を自動的にトリミングします。レターボックス/ピラーボックスのあるゲーム（16:9ディスプレイ上の4:3ゲームなど）に便利です。"
           }
         },
         "audio": {

GameSentenceMiner/locales/zh_cn.json

@@ -358,6 +358,10 @@
           "hotkey_updates_anki": {
             "label": "截图热键更新 Anki:",
             "tooltip": "允许截图热键/按钮更新最新的 Anki 卡片。"
+          },
+          "trim_black_bars": {
+            "label": "裁剪黑边:",
+            "tooltip": "自动裁剪截图中的黑边。适用于有信箱/柱状框的游戏（例如在 16:9 显示器上的 4:3 游戏）。"
           }
         },
         "audio": {

GameSentenceMiner/obs.py

@@ -565,6 +565,24 @@ def get_active_source():
         return None
     return get_source_from_scene(current_game)
 
+def get_active_video_sources():
+    current_game = get_current_game()
+    if not current_game:
+        return None
+    scene_items_response = []
+    try:
+        with connection_pool.get_client() as client:
+            client: obs.ReqClient
+            response = client.get_scene_item_list(name=current_game)
+            scene_items_response = response.scene_items if response else []
+    except Exception as e:
+        logger.error(f"Error getting scene items for active video source: {e}")
+        return None
+    if not scene_items_response:
+        return None
+    video_sources = ['window_capture', 'game_capture', 'monitor_capture']
+    return [item for item in scene_items_response if item.get('inputKind') in video_sources]
+
 def get_record_directory():
     try:
         with connection_pool.get_client() as client:
@@ -709,32 +727,142 @@ def get_screenshot_base64(compression=75, width=None, height=None):
         return None
     
 
-def get_screenshot_PIL(source_name=None, compression=75, img_format='png', width=None, height=None, retry=3):
+def get_screenshot_PIL_from_source(source_name, compression=75, img_format='png', width=None, height=None, retry=3):
+    """
+    Get a PIL Image screenshot from a specific OBS source.
+    
+    Args:
+        source_name: The name of the OBS source to capture
+        compression: Image quality (0-100)
+        img_format: Image format ('png' or 'jpg')
+        width: Optional width to resize
+        height: Optional height to resize
+        retry: Number of retry attempts
+        
+    Returns:
+        PIL.Image or None if failed
+    """
     import io
     import base64
     from PIL import Image
+    
     if not source_name:
-        source_name = get_active_source().get('sourceName', None)
-    if not source_name:
-        logger.error("No active source found in the current scene.")
+        logger.error("No source name provided.")
         return None
-    while True:
-        with connection_pool.get_client() as client:
-            client: obs.ReqClient
-            response = client.get_source_screenshot(name=source_name, img_format=img_format, quality=compression, width=width, height=height)
+        
+    for attempt in range(retry):
         try:
-            response.image_data = response.image_data.split(',', 1)[-1]  # Remove data:image/png;base64, prefix if present
+            with connection_pool.get_client() as client:
+                client: obs.ReqClient
+                response = client.get_source_screenshot(name=source_name, img_format=img_format, quality=compression, width=width, height=height)
+            
+            if response and hasattr(response, 'image_data') and response.image_data:
+                image_data = response.image_data.split(',', 1)[-1]  # Remove data:image/png;base64, prefix if present
+                image_data = base64.b64decode(image_data)
+                img = Image.open(io.BytesIO(image_data)).convert("RGBA")
+                return img
         except AttributeError:
-            retry -= 1
-            if retry <= 0:
-                logger.error(f"Error getting screenshot: {response}")
+            if attempt >= retry - 1:
+                logger.error(f"Error getting screenshot from source '{source_name}': Invalid response")
                 return None
+            time.sleep(0.1)
+        except Exception as e:
+            logger.error(f"Error getting screenshot from source '{source_name}': {e}")
+            return None
+    
+    return None
+
+
+def get_best_source_for_screenshot():
+    """
+    Get the best available video source dict based on priority and image validation.
+    
+    Priority order: window_capture > game_capture > monitor_capture
+    
+    Returns:
+        The source dict of the best available source, or None if no valid source found.
+    """
+    return get_screenshot_PIL(return_source_dict=True)
+
+
+def get_screenshot_PIL(source_name=None, compression=75, img_format='png', width=None, height=None, retry=3, return_source_dict=False):
+    """
+    Get a PIL Image screenshot. If no source_name is provided, automatically selects
+    the best available source based on priority and validates it has actual image data.
+    
+    Priority order: window_capture > game_capture > monitor_capture
+    
+    Args:
+        source_name: Optional specific OBS source name. If None, auto-selects best source.
+        compression: Image quality (0-100)
+        img_format: Image format ('png' or 'jpg')
+        width: Optional width to resize
+        height: Optional height to resize
+        retry: Number of retry attempts
+        return_source_dict: If True, returns only the source dict. If False, returns only the PIL.Image.
+        
+    Returns:
+        PIL.Image if return_source_dict=False, or source dict if return_source_dict=True.
+        Returns None if failed.
+    """
+    import io
+    import base64
+    from PIL import Image
+    
+    # If source_name is provided, use it directly
+    if source_name:
+        if return_source_dict:
+            # Need to find the source dict for this source_name
+            current_sources = get_active_video_sources()
+            if current_sources:
+                for src in current_sources:
+                    if src.get('sourceName') == source_name:
+                        return src
+            return None
+        img = get_screenshot_PIL_from_source(source_name, compression, img_format, width, height, retry)
+        return img
+    
+    # Get all available video sources
+    current_sources = get_active_video_sources()
+    if not current_sources:
+        logger.error("No active video sources found in the current scene.")
+        return None
+    
+    # Priority: window_capture (0) > game_capture (1) > monitor_capture (2)
+    priority_map = {'window_capture': 0, 'game_capture': 1, 'monitor_capture': 2}
+    
+    # Sort sources by priority
+    sorted_sources = sorted(
+        current_sources,
+        key=lambda x: priority_map.get(x.get('inputKind'), 999)
+    )
+    
+    # Try each source in priority order
+    for source in sorted_sources:
+        found_source_name = source.get('sourceName')
+        if not found_source_name:
             continue
-        if response and response.image_data:
-            image_data = response.image_data.split(',', 1)[-1]  # Remove data:image/png;base64, prefix if present
-            image_data = base64.b64decode(image_data)
-            img = Image.open(io.BytesIO(image_data)).convert("RGBA")
-            return img
+            
+        img = get_screenshot_PIL_from_source(found_source_name, compression, img_format, width, height, retry)
+        
+        if img:
+            # Validate that the image has actual content (not completely empty/black)
+            try:
+                extrema = img.getextrema()
+                if isinstance(extrema[0], tuple):
+                    is_empty = all(e[0] == e[1] for e in extrema)
+                else:
+                    is_empty = extrema[0] == extrema[1]
+                
+                if not is_empty:
+                    return source if return_source_dict else img
+                else:
+                    logger.debug(f"Source '{found_source_name}' returned an empty image, trying next source")
+            except Exception as e:
+                logger.warning(f"Failed to validate image from source '{found_source_name}': {e}")
+                # If validation fails, still return the image as it might be valid
+                return source if return_source_dict else img
+    
     return None
 
     
@@ -915,6 +1043,13 @@ def create_scene():
 if __name__ == '__main__':
     logging.basicConfig(level=logging.INFO)
     connect_to_obs_sync()
+    try:
+        with connection_pool.get_client() as client:
+            client: obs.ReqClient
+            resp = client.get_scene_item_list(get_current_scene())
+            print(resp.scene_items)
+    except Exception as e:
+        print(f"Error: {e}")
     
     # outputs = get_output_list()
     # print(outputs)

GameSentenceMiner/ocr/owocr_area_selector.py

@@ -54,8 +54,11 @@ class ScreenSelector:
             raise RuntimeError("mss is required for screen selection.")
 
         if self.use_obs_screenshot:
-            print("Using OBS screenshot as target.")
-            self.screenshot_img = obs.get_screenshot_PIL(compression=75)
+            sources = obs.get_active_video_sources()
+            best_source = obs.get_best_source_for_screenshot()
+            if len(sources) > 1:
+                logger.warning(f"Warning: Multiple active video sources found in OBS. Using '{best_source.get('sourceName')}' for screenshot. Please ensure only one source is active for best results.")
+            self.screenshot_img = obs.get_screenshot_PIL(compression=100, img_format='jpg')
             # print(screenshot_base64)
             if not self.screenshot_img:
                 raise RuntimeError("Failed to get OBS screenshot.")

GameSentenceMiner/ocr/owocr_helper.py

@@ -391,7 +391,7 @@ def text_callback(text, orig_text, time, img=None, came_from_ss=False, filtering
                     stable_time = last_meiki_crop_time
                     previous_img_local = previous_img
                     pre_crop_image = previous_img_local
-                    ocr2_image = get_ocr2_image(crop_coords, og_image=previous_img_local, ocr2_engine=get_ocr_ocr2())
+                    ocr2_image = get_ocr2_image(crop_coords, og_image=previous_img_local, ocr2_engine=get_ocr_ocr2(), extra_padding=10)
                     # Use the earlier timestamp for when the stable crop started if available
                     # ocr2_image.show()
                     second_ocr_queue.put((text, stable_time, ocr2_image, filtering, pre_crop_image))
@@ -482,22 +482,54 @@ done = False
 # Create a queue for tasks
 second_ocr_queue = queue.Queue()
 
-def get_ocr2_image(crop_coords, og_image: Image.Image, ocr2_engine=None):
+def get_ocr2_image(crop_coords, og_image: Image.Image, ocr2_engine=None, extra_padding=0):
     """
     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():
+        """Return a (possibly cropped) PIL.Image based on the original image and padding."""
         logger.debug("Returning original image for OCR2 (no cropping or optimization).")
+        # Convert bytes to PIL.Image if necessary
+        img = og_image
+        if isinstance(og_image, (bytes, bytearray)):
+            try:
+                img = Image.open(io.BytesIO(og_image)).convert('RGB')
+            except Exception:
+                # If conversion fails, just return og_image as-is
+                return og_image
+
         if not crop_coords or not get_ocr_optimize_second_scan():
-            return og_image
+            return img
+
         x1, y1, x2, y2 = crop_coords
-        x1 = min(max(0, x1), og_image.width)
-        y1 = min(max(0, y1), og_image.height)
-        x2 = min(max(0, x2), og_image.width)
-        y2 = min(max(0, y2), og_image.height)
-        og_image.save(os.path.join(get_temporary_directory(), "pre_oneocrcrop.png"))
-        return og_image.crop((x1, y1, x2, y2))
+        # Apply integer padding (can be negative to shrink)
+        pad = int(extra_padding or 0)
+        x1 = x1 - pad
+        y1 = y1 - pad
+        x2 = x2 + pad
+        y2 = y2 + pad
+
+        # Clamp coordinates to image bounds
+        x1 = min(max(0, int(x1)), img.width)
+        y1 = min(max(0, int(y1)), img.height)
+        x2 = min(max(0, int(x2)), img.width)
+        y2 = min(max(0, int(y2)), img.height)
+
+        # Ensure at least a 1-pixel width/height
+        if x2 <= x1:
+            x2 = min(img.width, x1 + 1)
+            x1 = max(0, x2 - 1)
+        if y2 <= y1:
+            y2 = min(img.height, y1 + 1)
+            y1 = max(0, y2 - 1)
+
+        try:
+            img.save(os.path.join(get_temporary_directory(), "pre_oneocrcrop.png"))
+        except Exception:
+            # don't fail just because we couldn't save a debug image
+            logger.debug("Could not save pre_oneocrcrop.png for debugging")
+        return img.crop((x1, y1, x2, y2))
     
     # TODO Get rid of this check, and just always convert to full res
     LOCAL_OCR_ENGINES = ['easyocr', 'oneocr', 'rapidocr', 'mangaocr', 'winrtocr']
@@ -541,16 +573,33 @@ def get_ocr2_image(crop_coords, og_image: Image.Image, ocr2_engine=None):
     x2 = int(crop_coords[2] * width_ratio)
     y2 = int(crop_coords[3] * height_ratio)
 
+    # Scale padding separately for X and Y
+    pad_x = int(round((extra_padding or 0) * width_ratio))
+    pad_y = int(round((extra_padding or 0) * height_ratio))
+
+    x1 = x1 - pad_x
+    y1 = y1 - pad_y
+    x2 = x2 + pad_x
+    y2 = y2 + pad_y
+
     # Clamp coordinates to image bounds
-    x1 = min(max(0, x1), img.width)
-    y1 = min(max(0, y1), img.height)
-    x2 = min(max(0, x2), img.width)
-    y2 = min(max(0, y2), img.height)
-    
+    x1 = min(max(0, int(x1)), img.width)
+    y1 = min(max(0, int(y1)), img.height)
+    x2 = min(max(0, int(x2)), img.width)
+    y2 = min(max(0, int(y2)), img.height)
+
+    # Ensure at least a 1-pixel width/height
+    if x2 <= x1:
+        x2 = min(img.width, x1 + 1)
+        x1 = max(0, x2 - 1)
+    if y2 <= y1:
+        y2 = min(img.height, y1 + 1)
+        y1 = max(0, y2 - 1)
+
     logger.debug(f"Scaled crop coordinates: {(x1, y1, x2, y2)}")
-    
+
     img = run.apply_ocr_config_to_image(img, ocr_config_local, is_secondary=False)
-    
+
     ret = img.crop((x1, y1, x2, y2))
     return ret
 
@@ -763,7 +812,7 @@ if __name__ == "__main__":
             try:
                 while not done:
                     time.sleep(1)
-            except KeyboardInterrupt as e:
+            except KeyboardInterrupt:
                 pass
         else:
             print("Failed to load OCR configuration. Please check the logs.")

GameSentenceMiner/owocr/owocr/run.py

@@ -1038,7 +1038,8 @@ class OBSScreenshotThread(threading.Thread):
     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()
+        current_sources = obs.get_active_video_sources()
+        self.current_source = source if source else obs.get_best_source_for_screenshot()
         logger.debug(f"Current OBS source: {self.current_source}")
         self.source_width = self.current_source.get(
             "sceneItemTransform").get("sourceWidth") or self.width
@@ -1056,6 +1057,8 @@ class OBSScreenshotThread(threading.Thread):
                 f"Using source dimensions: {self.width}x{self.height}")
         self.current_source_name = self.current_source.get(
             "sourceName") or None
+        if len(current_sources) > 1:
+            logger.error(f"Multiple active video sources found in OBS. Using {self.current_source_name} for Screenshot. Please ensure only one source is active for best results.")
         self.current_scene = scene if scene else obs.get_current_game()
         self.ocr_config = get_scene_ocr_config(refresh=True)
         if not self.ocr_config:
@@ -1394,7 +1397,7 @@ def process_and_write_results(img_or_path, write_to=None, last_result=None, filt
     if res:
         if 'provider' in text:
             if write_to == 'callback':
-                logger.opt(ansi=True).info(f"{len(text['boxes'])} text boxes recognized using Meiki:")
+                logger.opt(ansi=True).info(f"{len(text['boxes'])} text boxes recognized in {end_time - start_time:0.03f}s using Meiki:")
                 txt_callback('', '', ocr_start_time,
                              img_or_path, is_second_ocr, filtering, text.get('crop_coords', None), meiki_boxes=text.get('boxes', []))
                 return str(text), str(text)

GameSentenceMiner/ui/config_gui.py

@@ -449,6 +449,7 @@ class ConfigApp:
         self.screenshot_timing_value = tk.StringVar(value=self.settings.screenshot.screenshot_timing_setting)
         self.use_screenshot_selector_value = tk.BooleanVar(value=self.settings.screenshot.use_screenshot_selector)
         self.animated_screenshot_value = tk.BooleanVar(value=self.settings.screenshot.animated)
+        self.trim_black_bars_value = tk.BooleanVar(value=self.settings.screenshot.trim_black_bars_wip)
 
         # Audio Settings
         self.audio_enabled_value = tk.BooleanVar(value=self.settings.audio.enabled)
@@ -703,6 +704,7 @@ class ConfigApp:
                 seconds_after_line=float(self.seconds_after_line_value.get()) if self.seconds_after_line_value.get() else 0.0,
                 screenshot_timing_setting=self.screenshot_timing_value.get(),
                 use_screenshot_selector=self.use_screenshot_selector_value.get(),
+                trim_black_bars_wip=self.trim_black_bars_value.get(),
             ),
             audio=Audio(
                 enabled=self.audio_enabled_value.get(),
@@ -771,6 +773,7 @@ class ConfigApp:
                 use_canned_context_prompt=self.use_canned_context_prompt_value.get(),
                 custom_prompt=self.custom_prompt.get("1.0", tk.END).strip(),
                 dialogue_context_length=int(self.ai_dialogue_context_length_value.get()),
+                custom_texthooker_prompt=self.custom_texthooker_prompt.get("1.0", tk.END).strip(),
             ),
             overlay=Overlay(
                 websocket_port=int(self.overlay_websocket_port_value.get()),
@@ -1765,6 +1768,14 @@ class ConfigApp:
             row=self.current_row, column=1, sticky='W', pady=2)
         self.current_row += 1
 
+        trim_black_bars_i18n = ss_i18n.get('trim_black_bars', {})
+        HoverInfoLabelWidget(screenshot_frame, text=trim_black_bars_i18n.get('label', '...'),
+                             tooltip=trim_black_bars_i18n.get('tooltip', '...'),
+                             row=self.current_row, column=0)
+        ttk.Checkbutton(screenshot_frame, variable=self.trim_black_bars_value, bootstyle="round-toggle").grid(
+            row=self.current_row, column=1, sticky='W', pady=2)
+        self.current_row += 1
+
         self.add_reset_button(screenshot_frame, "screenshot", self.current_row, 0, self.create_screenshot_tab)
 
         for col in range(3):
@@ -2299,6 +2310,16 @@ class ConfigApp:
         self.custom_prompt.insert(tk.END, self.settings.ai.custom_prompt)
         self.custom_prompt.grid(row=self.current_row, column=1, sticky='EW', pady=2)
         self.current_row += 1
+        
+        custom_texthooker_prompt_i18n = ai_i18n.get('custom_texthooker_prompt', {})
+        HoverInfoLabelWidget(ai_frame, text=custom_texthooker_prompt_i18n.get('label', 'Custom Texthooker Prompt:'), tooltip=custom_texthooker_prompt_i18n.get('tooltip', 'Custom Prompt to use for Texthooker Translate Button.'),
+                             row=self.current_row, column=0)
+        self.custom_texthooker_prompt = scrolledtext.ScrolledText(ai_frame, width=50, height=5, font=("TkDefaultFont", 9),
+                                                                   relief="solid", borderwidth=1,
+                                                                   highlightbackground=ttk.Style().colors.border)
+        self.custom_texthooker_prompt.insert(tk.END, self.settings.ai.custom_texthooker_prompt)
+        self.custom_texthooker_prompt.grid(row=self.current_row, column=1, sticky='EW', pady=2)
+        self.current_row += 1
 
         self.add_reset_button(ai_frame, "ai", self.current_row, 0, self.create_ai_tab)
 

GameSentenceMiner/ui/screenshot_selector.py

@@ -1,4 +1,6 @@
+import math
 import os
+import re
 import subprocess
 import json
 import tkinter as tk
@@ -6,8 +8,9 @@ from tkinter import messagebox
 import ttkbootstrap as ttk
 from PIL import Image, ImageTk
 
+from GameSentenceMiner.util import ffmpeg
 from GameSentenceMiner.util.gsm_utils import sanitize_filename
-from GameSentenceMiner.util.configuration import get_temporary_directory, logger, ffmpeg_base_command_list, get_ffprobe_path
+from GameSentenceMiner.util.configuration import get_config, get_temporary_directory, logger, ffmpeg_base_command_list, get_ffprobe_path, ffmpeg_base_command_list_info
 
 
 class ScreenshotSelectorDialog(tk.Toplevel):
@@ -65,7 +68,7 @@ class ScreenshotSelectorDialog(tk.Toplevel):
         # Force always on top to ensure visibility
 
     def _extract_frames(self, video_path, timestamp, mode):
-        """Extracts frames using ffmpeg. Encapsulated from the original script."""
+        """Extracts frames using ffmpeg, with automatic black bar removal."""
         temp_dir = os.path.join(
             get_temporary_directory(False),
             "screenshot_frames",
@@ -87,17 +90,36 @@ class ScreenshotSelectorDialog(tk.Toplevel):
             logger.warning(f"Timestamp {timestamp_number} exceeds video duration {video_duration}.")
             return [], None
 
+        video_filters = []
+
+        if get_config().screenshot.trim_black_bars_wip:
+            crop_filter = ffmpeg.find_black_bars(video_path, timestamp_number)
+            if crop_filter:
+                video_filters.append(crop_filter)
+
+        # Always add the frame extraction filter
+        video_filters.append(f"fps=1/{0.25}")
+
         try:
+            # Build the final command for frame extraction
             command = ffmpeg_base_command_list + [
-                "-y",
+                "-y",                          # Overwrite output files without asking
                 "-ss", str(timestamp_number),
-                "-i", video_path,
-                "-vf", f"fps=1/{0.25}",
+                "-i", video_path
+            ]
+            
+            # Chain all collected filters (crop and fps) together with a comma
+            command.extend(["-vf", ",".join(video_filters)])
+            
+            command.extend([
                 "-vframes", "20",
                 os.path.join(temp_dir, "frame_%02d.png")
-            ]
+            ])
+            
+            logger.debug(f"Executing frame extraction command: {' '.join(command)}")
             subprocess.run(command, check=True, capture_output=True, text=True)
 
+            # The rest of your logic remains the same
             for i in range(1, 21):
                 frame_path = os.path.join(temp_dir, f"frame_{i:02d}.png")
                 if os.path.exists(frame_path):
@@ -122,7 +144,7 @@ class ScreenshotSelectorDialog(tk.Toplevel):
         except Exception as e:
             logger.error(f"An unexpected error occurred during frame extraction: {e}")
             return [], None
-
+        
     def _build_image_grid(self, image_paths, golden_frame):
         """Creates and displays the grid of selectable images."""
         self.images = [] # Keep a reference to images to prevent garbage collection

GameSentenceMiner/util/configuration.py

@@ -12,7 +12,7 @@ from logging.handlers import RotatingFileHandler
 from os.path import expanduser
 from sys import platform
 import time
-from typing import List, Dict
+from typing import Any, List, Dict
 import sys
 from enum import Enum
 
@@ -59,6 +59,28 @@ supported_formats = {
     'm4a': 'aac',
 }
 
+KNOWN_ASPECT_RATIOS = [
+    # --- Classic / Legacy ---
+    {"name": "4:3 (SD / Retro Games)", "ratio": 4 / 3},
+    {"name": "5:4 (Old PC Monitors)", "ratio": 5 / 4},
+    {"name": "3:2 (Handheld / GBA / DS / DSLR)", "ratio": 3 / 2},
+
+    # --- Modern Displays ---
+    {"name": "16:10 (PC Widescreen)", "ratio": 16 / 10},
+    {"name": "16:9 (Standard HD / 1080p / 4K)", "ratio": 16 / 9},
+    {"name": "18:9 (Mobile / Some Modern Laptops)", "ratio": 18 / 9},
+    {"name": "19.5:9 (Modern Smartphones)", "ratio": 19.5 / 9},
+    {"name": "21:9 (UltraWide)", "ratio": 21 / 9},
+    {"name": "24:10 (UltraWide+)", "ratio": 24 / 10},
+    {"name": "32:9 (Super UltraWide)", "ratio": 32 / 9},
+
+    # --- Vertical / Mobile ---
+    {"name": "9:16 (Portrait Mode)", "ratio": 9 / 16},
+    {"name": "3:4 (Portrait 4:3)", "ratio": 3 / 4},
+    {"name": "1:1 (Square / UI Capture)", "ratio": 1 / 1},
+]
+
+KNOWN_ASPECT_RATIOS_DICT = {item["name"]: item["ratio"] for item in KNOWN_ASPECT_RATIOS}
 
 def is_linux():
     return platform == 'linux'
@@ -490,6 +512,7 @@ class Screenshot:
     use_new_screenshot_logic: bool = False
     screenshot_timing_setting: str = 'beginning'  # 'middle', 'end'
     use_screenshot_selector: bool = False
+    trim_black_bars_wip: bool = True
 
     def __post_init__(self):
         if not self.screenshot_timing_setting and self.use_beginning_of_line_as_screenshot:
@@ -632,6 +655,7 @@ class Ai:
     use_canned_translation_prompt: bool = True
     use_canned_context_prompt: bool = False
     custom_prompt: str = ''
+    custom_texthooker_prompt: str = ''
     dialogue_context_length: int = 10
 
     def __post_init__(self):
@@ -1321,10 +1345,11 @@ class AnkiUpdateResult:
     video_in_anki: str = ''
     word_path: str = ''
     word: str = ''
+    extra_tags: List[str] = field(default_factory=list)
 
     @staticmethod
     def failure():
-        return AnkiUpdateResult(success=False, audio_in_anki='', screenshot_in_anki='', prev_screenshot_in_anki='', sentence_in_anki='', multi_line=False, video_in_anki='', word_path='', word='')
+        return AnkiUpdateResult(success=False, audio_in_anki='', screenshot_in_anki='', prev_screenshot_in_anki='', sentence_in_anki='', multi_line=False, video_in_anki='', word_path='', word='', extra_tags=[])
 
 
 @dataclass_json
@@ -1376,6 +1401,8 @@ def get_ffprobe_path():
 
 ffmpeg_base_command_list = [get_ffmpeg_path(), "-hide_banner", "-loglevel", "error", '-nostdin']
 
+ffmpeg_base_command_list_info = [get_ffmpeg_path(), "-hide_banner", "-loglevel", "info", '-nostdin']
+
 
 # logger.debug(f"Running in development mode: {is_dev}")
 # logger.debug(f"Running on Beangate's PC: {is_beangate}")

GameSentenceMiner/util/ffmpeg.py

@@ -1,5 +1,6 @@
 import json
 import os
+import re
 import subprocess
 import sys
 import tempfile
@@ -12,8 +13,8 @@ import shutil
 
 from GameSentenceMiner import obs
 from GameSentenceMiner.ui.config_gui import ConfigApp
-from GameSentenceMiner.util.configuration import ffmpeg_base_command_list, get_ffprobe_path, logger, get_config, \
-    get_temporary_directory, gsm_state, is_linux
+from GameSentenceMiner.util.configuration import ffmpeg_base_command_list, get_ffprobe_path, get_master_config, logger, get_config, \
+    get_temporary_directory, gsm_state, is_linux, ffmpeg_base_command_list_info, KNOWN_ASPECT_RATIOS
 from GameSentenceMiner.util.gsm_utils import make_unique_file_name, get_file_modification_time
 from GameSentenceMiner.util import configuration
 from GameSentenceMiner.util.text_log import initial_time
@@ -223,53 +224,307 @@ def get_screenshot(video_file, screenshot_timing, try_selector=False):
             return output
         else:
             logger.error("Frame extractor script failed to run or returned no output, defaulting")
+
     output_image = make_unique_file_name(os.path.join(
         get_temporary_directory(), f"{obs.get_current_game(sanitize=True)}.{get_config().screenshot.extension}"))
-    # FFmpeg command to extract the last frame of the video
+    
+    # Base command for extracting the frame
     ffmpeg_command = ffmpeg_base_command_list + [
         "-ss", f"{screenshot_timing}",
         "-i", f"{video_file}",
         "-vframes", "1"  # Extract only one frame
     ]
+    
+    video_filters = []
+
+    if get_config().screenshot.trim_black_bars_wip:
+        crop_filter = find_black_bars(video_file, screenshot_timing)
+        if crop_filter:
+            video_filters.append(crop_filter)
+
+    if get_config().screenshot.width or get_config().screenshot.height:
+        # Add scaling to the filter chain
+        scale_filter = f"scale={get_config().screenshot.width or -1}:{get_config().screenshot.height or -1}"
+        video_filters.append(scale_filter)
+
+    # If we have any filters (crop, scale, etc.), chain them together with commas
+    if video_filters:
+        ffmpeg_command.extend(["-vf", ",".join(video_filters)])
 
     if get_config().screenshot.custom_ffmpeg_settings:
         ffmpeg_command.extend(get_config().screenshot.custom_ffmpeg_settings.replace("\"", "").split(" "))
     else:
-        ffmpeg_command.extend(["-compression_level", "6", "-q:v", get_config().screenshot.quality])
-
-    if get_config().screenshot.width or get_config().screenshot.height:
-        ffmpeg_command.extend(
-            ["-vf", f"scale={get_config().screenshot.width or -1}:{get_config().screenshot.height or -1}"])
+        # Ensure quality settings are strings
+        ffmpeg_command.extend(["-compression_level", "6", "-q:v", str(get_config().screenshot.quality)])
 
     ffmpeg_command.append(f"{output_image}")
 
-    logger.debug(f"FFMPEG SS Command: {ffmpeg_command}")
+    logger.debug(f"FFMPEG SS Command: {' '.join(map(str, ffmpeg_command))}")
 
     try:
+        # Changed the retry loop to be more robust
         for i in range(3):
-            logger.debug(" ".join(ffmpeg_command))
-            result = subprocess.run(ffmpeg_command)
-            if result.returncode != 0 and i < 2:
-                raise RuntimeError(f"FFmpeg command failed with return code {result.returncode}")
-            else:
-                break
+            logger.debug("Executing FFmpeg command...")
+            result = subprocess.run(ffmpeg_command, capture_output=True, text=True)
+            if result.returncode == 0:
+                break # Success!
+            logger.warning(f"FFmpeg attempt {i+1} failed. Stderr: {result.stderr}")
+            if i == 2: # Last attempt failed
+                 raise RuntimeError(f"FFmpeg command failed after 3 attempts. Stderr: {result.stderr}")
     except Exception as e:
         logger.error(f"Error running FFmpeg command: {e}. Defaulting to standard PNG.")
         output_image = make_unique_file_name(os.path.join(
             get_temporary_directory(),
             f"{obs.get_current_game(sanitize=True)}.png"))
-        ffmpeg_command = ffmpeg_base_command_list + [
+        # Fallback command without any complex filters
+        fallback_command = ffmpeg_base_command_list + [
             "-ss", f"{screenshot_timing}",
             "-i", video_file,
             "-vframes", "1",
             output_image
         ]
-        subprocess.run(ffmpeg_command)
+        subprocess.run(fallback_command)
 
     logger.debug(f"Screenshot saved to: {output_image}")
 
     return output_image
 
+def get_video_dimensions(video_file):
+    """Get the width and height of a video file."""
+    try:
+        ffprobe_command = [
+            get_ffprobe_path(),
+            "-v", "error",
+            "-select_streams", "v:0",
+            "-show_entries", "stream=width,height",
+            "-of", "json",
+            video_file
+        ]
+        
+        result = subprocess.run(
+            ffprobe_command,
+            capture_output=True,
+            text=True,
+            check=True
+        )
+        
+        output = json.loads(result.stdout)
+        width = output['streams'][0]['width']
+        height = output['streams'][0]['height']
+        return width, height
+    except Exception as e:
+        logger.error(f"Error getting video dimensions: {e}")
+        return None, None
+
+# How close the detected ratio needs to be to a known ratio to snap (e.g., 0.05 = 5%)
+RATIO_TOLERANCE = 0.05
+
+def _calculate_target_crop(orig_width, orig_height, target_ratio):
+    """
+    Calculates the new dimensions and offsets for a target aspect ratio.
+    
+    Returns: A tuple (new_width, new_height, x_offset, y_offset)
+    """
+    orig_ratio = orig_width / orig_height
+
+    if abs(orig_ratio - target_ratio) < 0.01: # Already at the target ratio
+        return orig_width, orig_height, 0, 0
+
+    if orig_ratio > target_ratio:
+        # Original is wider than target (pillarbox scenario)
+        # Keep original height, calculate new width
+        new_width = round(orig_height * target_ratio)
+        new_height = orig_height
+        x_offset = round((orig_width - new_width) / 2)
+        y_offset = 0
+    else:
+        # Original is narrower than target (letterbox scenario)
+        # Keep original width, calculate new height
+        new_width = orig_width
+        new_height = round(orig_width / target_ratio)
+        x_offset = 0
+        y_offset = round((orig_height - new_height) / 2)
+
+    # Ensure dimensions are even for compatibility
+    new_width = new_width if new_width % 2 == 0 else new_width - 1
+    new_height = new_height if new_height % 2 == 0 else new_height - 1
+    x_offset = x_offset if x_offset % 2 == 0 else x_offset - 1
+    y_offset = y_offset if y_offset % 2 == 0 else y_offset - 1
+    
+    return new_width, new_height, x_offset, y_offset
+
+
+def find_black_bars_with_ratio_snapping(video_file, screenshot_timing):
+    logger.info("Attempting to detect black bars with aspect ratio snapping...")
+    crop_filter = None
+    try:
+        orig_width, orig_height = get_video_dimensions(video_file)
+        if not orig_width or not orig_height:
+            logger.warning("Could not determine video dimensions. Skipping black bar detection.")
+            return None
+        
+        orig_aspect = orig_width / orig_height
+        logger.debug(f"Original video dimensions: {orig_width}x{orig_height} (Ratio: {orig_aspect:.3f})")
+        
+        cropdetect_command = ffmpeg_base_command_list_info + [
+            "-i", video_file,
+            "-ss", f"{screenshot_timing}",
+            "-t", "5", # Analyze for 5 seconds
+            "-vf", "cropdetect=limit=16", # limit=16 for near-black detection, 24 is too aggressive
+            "-f", "null", "-"
+        ]
+        
+        result = subprocess.run(
+            cropdetect_command, 
+            capture_output=True, 
+            text=True, 
+            check=False
+        )
+        
+        crop_lines = re.findall(r"crop=\d+:\d+:\d+:\d+", result.stderr)
+        if not crop_lines:
+            logger.info("cropdetect did not find any black bars to remove.")
+            return None
+            
+        last_crop_params = crop_lines[-1]
+        match = re.match(r"crop=(\d+):(\d+):(\d+):(\d+)", last_crop_params)
+        if not match:
+            logger.warning(f"Could not parse cropdetect output: {last_crop_params}")
+            return None
+
+        detected_width = int(match.group(1))
+        detected_height = int(match.group(2))
+        
+        if detected_width == orig_width and detected_height == orig_height:
+            logger.info("cropdetect suggests no cropping is needed.")
+            return None
+
+        detected_aspect = detected_width / detected_height
+        logger.debug(f"cropdetect suggests crop to: {detected_width}x{detected_height} (Ratio: {detected_aspect:.3f})")
+
+        best_match = None
+        min_diff = float('inf')
+
+        for known in KNOWN_ASPECT_RATIOS:
+            diff = abs(detected_aspect - known["ratio"]) / known["ratio"]
+            if diff < min_diff:
+                min_diff = diff
+                best_match = known
+        
+        get_master_config().scenes_info
+        
+        if best_match and min_diff <= RATIO_TOLERANCE:
+            target_name = best_match["name"]
+            target_ratio = best_match["ratio"]
+            logger.info(
+                f"Detected ratio ({detected_aspect:.3f}) is close to {target_name} ({target_ratio:.3f}). "
+                f"Snapping to the standard ratio."
+            )
+            
+            crop_width, crop_height, crop_x, crop_y = _calculate_target_crop(
+                orig_width, orig_height, target_ratio
+            )
+            
+            area_ratio = (crop_width * crop_height) / (orig_width * orig_height)
+            if area_ratio < 0.50:
+                logger.warning(
+                    f"Calculated crop would remove too much video ({1 - area_ratio:.1%}). "
+                    "Skipping crop to avoid false detection."
+                )
+                return None
+            
+            crop_filter = f"crop={crop_width}:{crop_height}:{crop_x}:{crop_y}"
+            logger.info(f"Applying snapped aspect ratio filter: {crop_filter}")
+            
+        else:
+            logger.info(
+                f"Detected crop ratio ({detected_aspect:.3f}) is not close enough to any known standard. "
+                "Skipping crop to avoid non-standard results."
+            )
+            return None
+
+    except Exception as e:
+        logger.error(f"Error during black bar detection: {e}. Proceeding without cropping.")
+    
+    return crop_filter
+
+def find_black_bars(video_file, screenshot_timing):
+    logger.info("Attempting to detect black bars...")
+    crop_filter = None
+    try:
+        # Get original video dimensions
+        orig_width, orig_height = get_video_dimensions(video_file)
+        if not orig_width or not orig_height:
+            logger.warning("Could not determine video dimensions. Skipping black bar detection.")
+            return None
+        
+        logger.debug(f"Original video dimensions: {orig_width}x{orig_height}")
+        
+        cropdetect_command = ffmpeg_base_command_list_info + [
+            "-i", video_file,
+            "-ss", f"{screenshot_timing}", # Start near the screenshot time
+            "-t", "1",                     # Analyze for 1 second
+            "-vf", "cropdetect=limit=16",  # limit=0 means true black only, round=2 for even dimensions
+            "-f", "null", "-"              # Discard video output
+        ]
+        
+        result = subprocess.run(
+            cropdetect_command, 
+            capture_output=True, 
+            text=True, 
+            check=False
+        )
+        
+        crop_lines = re.findall(r"crop=\d+:\d+:\d+:\d+", result.stderr)
+        if crop_lines:
+            crop_params = crop_lines[-1]
+            print(crop_params)
+            # Parse crop parameters: crop=width:height:x:y
+            match = re.match(r"crop=(\d+):(\d+):(\d+):(\d+)", crop_params)
+            if match:
+                crop_width = int(match.group(1))
+                crop_height = int(match.group(2))
+                
+                # Calculate what percentage of the original video would remain
+                area_ratio = (crop_width * crop_height) / (orig_width * orig_height)
+                
+                # Calculate aspect ratios
+                orig_aspect = orig_width / orig_height
+                crop_aspect = crop_width / crop_height
+                aspect_diff = abs(orig_aspect - crop_aspect) / orig_aspect
+                
+                logger.debug(f"Crop would be {crop_width}x{crop_height} ({area_ratio:.1%} of original area)")
+                logger.debug(f"Original aspect ratio: {orig_aspect:.3f}, Crop aspect ratio: {crop_aspect:.3f}, Difference: {aspect_diff:.1%}")
+                
+                # Safeguards:
+                # 1. Crop must retain at least 25% of the original video area
+                # 2. Aspect ratio must not change by more than 30%
+                if area_ratio < 0.25:
+                    logger.warning(f"Crop would remove too much of the video ({area_ratio:.1%} remaining). Skipping crop to avoid false detection.")
+                    return None
+                
+                if aspect_diff > 0.30:
+                    for ratio in KNOWN_ASPECT_RATIOS:
+                        known_ratio = ratio["ratio"]
+                        known_diff = abs(crop_aspect - known_ratio) / known_ratio
+                        if known_diff < RATIO_TOLERANCE:
+                            logger.info(f"Crop aspect ratio ({crop_aspect:.3f}) is close to known ratio {ratio['name']} ({known_ratio:.3f}). Accepting crop.")
+                            break
+                    else:
+                        logger.warning(f"Crop would significantly change aspect ratio ({aspect_diff:.1%} difference). Skipping crop to avoid false detection.")
+                        return None
+                
+                crop_filter = crop_params
+                logger.info(f"Detected valid black bars. Applying filter: {crop_filter}")
+            else:
+                logger.warning("Could not parse crop parameters.")
+        else:
+            logger.debug("cropdetect did not find any black bars to remove.")
+            
+    except Exception as e:
+        logger.error(f"Error during black bar detection: {e}. Proceeding without cropping.")
+    return crop_filter
+
 def get_screenshot_for_line(video_file, game_line, try_selector=False):
     return get_screenshot(video_file, get_screenshot_time(video_file, game_line), try_selector)
 

GameSentenceMiner/web/gsm_websocket.py

@@ -77,10 +77,12 @@ class WebsocketServerThread(threading.Thread):
             self._event.set()
             while True:
                 try:
-                    self.server = start_server = websockets.serve(self.server_handler,
-                                                                  get_config().advanced.localhost_bind_address,
-                                                                  self.get_ws_port_func(),
-                                                                  max_size=1000000000)
+                    self.server = start_server = websockets.serve(
+                        self.server_handler,
+                        get_config().advanced.localhost_bind_address,
+                        self.get_ws_port_func(),
+                        max_size=1000000000,
+                    )
                     async with start_server:
                         await stop_event.wait()
                     return

GameSentenceMiner/web/texthooking_page.py

@@ -235,19 +235,23 @@ def translate_line():
     if event_id is None:
         return jsonify({'error': 'Missing id'}), 400
     
-    prompt = f"""
-    **Professional Game Localization Task**
+    
+    if get_config().ai.custom_texthooker_prompt:
+        prompt = get_config().ai.custom_texthooker_prompt.strip()
+    else:
+        prompt = f"""
+        **Professional Game Localization Task**
 
-    **Task Directive:**
-    Translate ONLY the provided line of game dialogue specified below into natural-sounding, context-aware {get_config().general.get_native_language_name()}. The translation must preserve the original tone and intent of the source.
+        **Task Directive:**
+        Translate ONLY the provided line of game dialogue specified below into natural-sounding, context-aware {get_config().general.get_native_language_name()}. The translation must preserve the original tone and intent of the source.
 
-    **Output Requirements:**
-    - Provide only the single, best {get_config().general.get_native_language_name()} translation.
-    - Use expletives if they are natural for the context and enhance the translation's impact, but do not over-exaggerate.
-    - Do not include notes, alternatives, explanations, or any other surrounding text. Absolutely nothing but the translated line.
+        **Output Requirements:**
+        - Provide only the single, best {get_config().general.get_native_language_name()} translation.
+        - Use expletives if they are natural for the context and enhance the translation's impact, but do not over-exaggerate.
+        - Do not include notes, alternatives, explanations, or any other surrounding text. Absolutely nothing but the translated line.
 
-    **Line to Translate:**
-    """
+        **Line to Translate:**
+        """
 
     if not get_config().ai.is_configured():
         return jsonify({'error': 'AI translation is not properly configured. Please check your settings in the "AI" Tab.'}), 400
@@ -277,19 +281,20 @@ def translate_multiple():
     
     language = get_config().general.get_native_language_name() if get_config().general.native_language else "English"
     
+    
     translate_multiple_lines_prompt = f"""
-**Professional Game Localization Task**
-Translate the following lines of game dialogue into natural-sounding, context-aware {language}:
-
-**Output Requirements**
-- Maintain the original tone and style of the dialogue.
-- Ensure that the translation is contextually appropriate for the game.
-- Pay attention to character names and any specific terminology used in the game.
-- Maintain Formatting and newline structure of the given lines. It should be very human readable as a dialogue.
-- Do not include any notes, alternatives, explanations, or any other surrounding text. Absolutely nothing but the translated lines.
-
-**Lines to Translate:**
-"""
+    **Professional Game Localization Task**
+    Translate the following lines of game dialogue into natural-sounding, context-aware {language}:
+
+    **Output Requirements**
+    - Maintain the original tone and style of the dialogue.
+    - Ensure that the translation is contextually appropriate for the game.
+    - Pay attention to character names and any specific terminology used in the game.
+    - Maintain Formatting and newline structure of the given lines. It should be very human readable as a dialogue.
+    - Do not include any notes, alternatives, explanations, or any other surrounding text. Absolutely nothing but the translated lines.
+
+    **Lines to Translate:**
+    """
 
     translation = get_ai_prompt_result(get_all_lines(), text,
                                         lines[0], get_current_game(), custom_prompt=translate_multiple_lines_prompt)

{gamesentenceminer-2.19.6.dist-info → gamesentenceminer-2.19.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: GameSentenceMiner
-Version: 2.19.6
+Version: 2.19.8
 Summary: A tool for mining sentences from games. Update: Dependencies, replay buffer based line searching, and bug fixes.
 Author-email: Beangate <bpwhelan95@gmail.com>
 License: MIT License

{gamesentenceminer-2.19.6.dist-info → gamesentenceminer-2.19.8.dist-info}/RECORD

@@ -1,8 +1,8 @@
 GameSentenceMiner/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-GameSentenceMiner/anki.py,sha256=jySFPzDYz0vItb12kwZ-rm9WmtxO8Kr41wK1JdwRnU4,29638
+GameSentenceMiner/anki.py,sha256=5hp5WsNp7spazjQF9rZrNzOoQ2ZPFIl2sTdU5oDSWRE,29924
 GameSentenceMiner/gametext.py,sha256=4PPm7QSWDmvsyooVjFANkd1Vnoy5ixbGRMHfYfhwGs0,13320
 GameSentenceMiner/gsm.py,sha256=dg41VMDLzR3U8-Xm1oHGfU2JKL8cyH-WacqY6tLrWyM,36164
-GameSentenceMiner/obs.py,sha256=QLeJujJk48L0mphmPHa0hE46P09qQx34z41lla1ud-o,37977
+GameSentenceMiner/obs.py,sha256=TuTTHJ09S4uEwh0dJx4B5LnQlL-sTIKj8Xap5YsZ3KU,43160
 GameSentenceMiner/vad.py,sha256=iMSsoUZ7-aNoWKzDKfOHdB3Zk5U2hV7x5hqTny6rj08,21501
 GameSentenceMiner/ai/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 GameSentenceMiner/ai/ai_prompting.py,sha256=mq9Odv_FpohXagU-OoSZbLWttdrEl1M1NiqnodeUpD8,29126
@@ -14,21 +14,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=0NZRbq0zr-kCpKDAa2HJUhgOj2pmEIHgwGq-jgTcZ3s,28747
-GameSentenceMiner/locales/ja_jp.json,sha256=huwh6rRAsJmQ5pUXr7gIG5EnpCsF-d_JvOhFg8KxiB8,30786
-GameSentenceMiner/locales/zh_cn.json,sha256=soD29x8PefZ5M4t70nB61WeSkKdinP_ZbCLVb-toajw,26625
+GameSentenceMiner/locales/en_us.json,sha256=V79_n1GGqDXOwTnNXPtsfD0Zvs4apMJTlZGUAGjnlBs,28989
+GameSentenceMiner/locales/ja_jp.json,sha256=N_T6VtU8la2PAefUeZN3_sM88qxBIR4SPXA7ngRV4mk,31118
+GameSentenceMiner/locales/zh_cn.json,sha256=Dx-CbeUa2hGfRl1st1O0j-jOCnITQ87tjQYZxdSUPOE,26853
 GameSentenceMiner/ocr/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 GameSentenceMiner/ocr/gsm_ocr_config.py,sha256=Ov04c-nKzh3sADxO-5JyZWVe4DlrHM9edM9tc7-97Jo,5970
 GameSentenceMiner/ocr/ocrconfig.py,sha256=_tY8mjnzHMJrLS8E5pHqYXZjMuLoGKYgJwdhYgN-ny4,6466
-GameSentenceMiner/ocr/owocr_area_selector.py,sha256=4MjItlaZ78Smxa3uxMxbjU0n2z_IBTG-iBpDB9COSL8,29270
-GameSentenceMiner/ocr/owocr_helper.py,sha256=MZFKA252lQE1M39tUTtccX3vLaPRJrWfBzWvfxNq3B8,35310
+GameSentenceMiner/ocr/owocr_area_selector.py,sha256=1-PlCOpam8-D4tGQVuhxeVVQc9sy5Mfyvcyqgj2Vqyw,29587
+GameSentenceMiner/ocr/owocr_helper.py,sha256=JljPwcMLqu6KJz3Q9unKLXAVNzSwZkhvJohJ0NccW-o,36879
 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=yVrLr8nNgvLRB-pPvkyhw07zkAiWrCf85SvgfQBquEk,95309
-GameSentenceMiner/owocr/owocr/run.py,sha256=y90fHSbbjH4BeMlxH_xjKU3uJzfJgdKo6nUqwNcdUJs,82455
+GameSentenceMiner/owocr/owocr/run.py,sha256=4fyA6r4LLOJWIehwNHPfnZOb_2ebDGtS9i5bhZ3DsNo,82779
 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,15 +37,15 @@ GameSentenceMiner/tools/ss_selector.py,sha256=ob2oJdiYreDMMau7CvsglpnhZ1CDnJqop3
 GameSentenceMiner/tools/window_transparency.py,sha256=GtbxbmZg0-UYPXhfHff-7IKZyY2DKe4B9GdyovfmpeM,8166
 GameSentenceMiner/ui/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 GameSentenceMiner/ui/anki_confirmation.py,sha256=krrT3q3anTtXNTPHz5ahXSd4genEnEvS07v1JYftBFg,15174
-GameSentenceMiner/ui/config_gui.py,sha256=JHXlD6CE7o4YH1M85JSvGqc2-pNfuAyLgkztUn6ho1w,158268
+GameSentenceMiner/ui/config_gui.py,sha256=EpxWuwrTBKOrsg4kf9w_iT5oybhtanlFG6XtH98W9Ng,159987
 GameSentenceMiner/ui/furigana_filter_preview.py,sha256=DAT2-j6vSDHr9ufk6PiaLikEsbIp56B_OHIEeYLMwlk,17135
-GameSentenceMiner/ui/screenshot_selector.py,sha256=7QvDhOMpA0ej8x_lYtu6fhmrWbM1GCg-dps3XVWwk1Q,8234
+GameSentenceMiner/ui/screenshot_selector.py,sha256=MnR1MZWRUeHXCFTHc5ACK3WS08f9MUK5fJ6IQEGdCEY,9127
 GameSentenceMiner/util/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 GameSentenceMiner/util/audio_player.py,sha256=-yFsf0qoTSS1ga5rCmEJZJGUSJzXCvfZHY3t0NxycDk,7896
-GameSentenceMiner/util/configuration.py,sha256=0E_LGBZL6K_P2oIHo-nI5OA6SPDk9SXdTf5ycF1-VeQ,47579
+GameSentenceMiner/util/configuration.py,sha256=X6AFueDXi-HabDCGf8u44Z1rPO8XR6Wal3SvGz7hcbI,48806
 GameSentenceMiner/util/db.py,sha256=iCHUzlgOJgNjQ5-oDa7gnDWmzdlEryOzbXfn9ToQPfY,33034
 GameSentenceMiner/util/electron_config.py,sha256=KfeJToeFFVw0IR5MKa-gBzpzaGrU-lyJbR9z-sDEHYU,8767
-GameSentenceMiner/util/ffmpeg.py,sha256=cAzztfY36Xf2WvsJDjavoiMOvA9ac2GVdCrSB4LzHk4,29007
+GameSentenceMiner/util/ffmpeg.py,sha256=iJAo2GUF0B4SDhG9rp-xaA94VSAc00aY1SyRRZ-i_1w,39730
 GameSentenceMiner/util/games_table.py,sha256=VM68MAsdyE6tpdwM4bDSk67qioBOvsEO8-TpnRmUnSo,12003
 GameSentenceMiner/util/get_overlay_coords.py,sha256=jQ0hcrEh9CfvjlBRJez3Ly-er4MjBWC2zirA-hYz5hQ,26462
 GameSentenceMiner/util/gsm_utils.py,sha256=mASECTmN10c2yPL4NEfLg0Y0YWwFso1i6r_hhJPR3MY,10974
@@ -65,10 +65,10 @@ GameSentenceMiner/web/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3h
 GameSentenceMiner/web/anki_api_endpoints.py,sha256=r30OTT3YVfgbF6aJ-EGWZLF-j2D9L63jLkRXMycU0p8,23681
 GameSentenceMiner/web/database_api.py,sha256=wJGFwrPbB7qQMIqwg0w6hn_henFhjAUCIpwjhdUNMGU,89903
 GameSentenceMiner/web/events.py,sha256=RJ8tIK8WUn7Fbgny23UJWrZ1SlhYzzT5p55E1uXRwDs,2747
-GameSentenceMiner/web/gsm_websocket.py,sha256=B0VKpxmsRu0WRh5nFWlpDPBQ6-K2ed7TEIa0O6YWeoo,4166
+GameSentenceMiner/web/gsm_websocket.py,sha256=jX1JS89FHIwGK7sJIYwu9-drE1_0YIsqGNLo9o3GybQ,4087
 GameSentenceMiner/web/service.py,sha256=6cgUmDgtp3ZKzuPFszowjPoq-BDtC1bS3ux6sykeaqo,6662
 GameSentenceMiner/web/stats.py,sha256=LYMhekifcQo-cbfy2--b6vycKcu8RAoTnQA4TefcS6U,29037
-GameSentenceMiner/web/texthooking_page.py,sha256=jnEBnxDj37BEbi1AGsiEk3GNOqBLsd9znIKC1OuO8jM,15068
+GameSentenceMiner/web/texthooking_page.py,sha256=IJNvprv3crWzYE9pWQMI30XPTkdwOdhanBgnIqAWdYQ,15283
 GameSentenceMiner/web/static/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 GameSentenceMiner/web/static/apple-touch-icon.png,sha256=OcMI8af_68DA_tweOsQ5LytTyMwm7-hPW07IfrOVgEs,46132
 GameSentenceMiner/web/static/favicon-96x96.png,sha256=lOePzjiKl1JY2J1kT_PMdyEnrlJmi5GWbmXJunM12B4,16502
@@ -135,9 +135,9 @@ GameSentenceMiner/web/templates/components/kanji_grid/thousand_character_classic
 GameSentenceMiner/web/templates/components/kanji_grid/wanikani_levels.json,sha256=8wjnnaYQqmho6t5tMxrIAc03512A2tYhQh5dfsQnfAM,11372
 GameSentenceMiner/web/templates/components/kanji_grid/words_hk_frequency_list.json,sha256=wRkqZNPzz6DT9OTPHpXwfqW96Qb96stCQNNgOL-ZdKk,17535
 GameSentenceMiner/wip/__init___.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-gamesentenceminer-2.19.6.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-gamesentenceminer-2.19.6.dist-info/METADATA,sha256=UsYLvq5EK3i2B84SK2JvJ9tyKLXFa0KsZY7Jnl2JAsg,8180
-gamesentenceminer-2.19.6.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-gamesentenceminer-2.19.6.dist-info/entry_points.txt,sha256=2APEP25DbfjSxGeHtwBstMH8mulVhLkqF_b9bqzU6vQ,65
-gamesentenceminer-2.19.6.dist-info/top_level.txt,sha256=V1hUY6xVSyUEohb0uDoN4UIE6rUZ_JYx8yMyPGX4PgQ,18
-gamesentenceminer-2.19.6.dist-info/RECORD,,
+gamesentenceminer-2.19.8.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+gamesentenceminer-2.19.8.dist-info/METADATA,sha256=4M3TSSE1ZAO0GVyam1krpDM7tZkvxMyE5KsMzNUGBYM,8180
+gamesentenceminer-2.19.8.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+gamesentenceminer-2.19.8.dist-info/entry_points.txt,sha256=2APEP25DbfjSxGeHtwBstMH8mulVhLkqF_b9bqzU6vQ,65
+gamesentenceminer-2.19.8.dist-info/top_level.txt,sha256=V1hUY6xVSyUEohb0uDoN4UIE6rUZ_JYx8yMyPGX4PgQ,18
+gamesentenceminer-2.19.8.dist-info/RECORD,,