GameSentenceMiner 2.18.9__py3-none-any.whl → 2.18.11__py3-none-any.whl

GameSentenceMiner/owocr/owocr/ocr.py

@@ -277,11 +277,12 @@ class GoogleLens:
     key = 'l'
     available = False
 
-    def __init__(self, lang='ja'):
+    def __init__(self, lang='ja', get_furigana_sens_from_file=True):
         import regex
         self.regex = get_regex(lang)
         self.initial_lang = lang
         self.punctuation_regex = regex.compile(r'[\p{P}\p{S}]')
+        self.get_furigana_sens_from_file = get_furigana_sens_from_file
         if 'betterproto' not in sys.modules:
             logger.warning('betterproto not available, Google Lens will not work!')
         else:
@@ -289,10 +290,10 @@ class GoogleLens:
             logger.info('Google Lens ready')
 
     def __call__(self, img, furigana_filter_sensitivity=0, return_coords=False):
-        if furigana_filter_sensitivity != None:
+        if self.get_furigana_sens_from_file:
             furigana_filter_sensitivity = get_furigana_filter_sensitivity()
         else:
-            furigana_filter_sensitivity = 0
+            furigana_filter_sensitivity = furigana_filter_sensitivity
         lang = get_ocr_language()
         img, is_path = input_to_pil_image(img)
         if lang != self.initial_lang:
@@ -362,6 +363,12 @@ class GoogleLens:
         text = response_dict['objects_response']['text']
         skipped = []
         previous_line = None
+        filtered_response_dict = response_dict
+        if furigana_filter_sensitivity:
+            import copy
+            filtered_response_dict = copy.deepcopy(response_dict)
+            filtered_paragraphs = []
+        
         if 'text_layout' in text:
             for paragraph in text['text_layout']['paragraphs']:
                 if previous_line:
@@ -376,25 +383,40 @@ class GoogleLens:
                     # logger.info(avg_height * 2)
                     if vertical_space > avg_height * 2:
                         res += 'BLANK_LINE\n'
+                passed_furigana_filter_lines = []
                 for line in paragraph['lines']:
                     if furigana_filter_sensitivity:
                         line_width = line['geometry']['bounding_box']['width'] * img.width
                         line_height = line['geometry']['bounding_box']['height'] * img.height
+                        passes = False
                         for word in line['words']:
                             if self.punctuation_regex.findall(word['plain_text']):
                                 res += word['plain_text'] + word['text_separator']
                                 continue
                             if line_width > furigana_filter_sensitivity and line_height > furigana_filter_sensitivity:
                                 res += word['plain_text'] + word['text_separator']
+                                passes = True
                             else:
                                 skipped.extend(word['plain_text'])
                                 continue
+                        if passes:
+                            passed_furigana_filter_lines.append(line)
                     else:
                         for word in line['words']:
                             res += word['plain_text'] + word['text_separator']
                     res += '\n'
 
+                if furigana_filter_sensitivity and passed_furigana_filter_lines:
+                    # Create a filtered paragraph with only the passing lines
+                    filtered_paragraph = paragraph.copy()
+                    filtered_paragraph['lines'] = passed_furigana_filter_lines
+                    filtered_paragraphs.append(filtered_paragraph)
+                
                 previous_line = paragraph
+            
+            if furigana_filter_sensitivity:
+                filtered_response_dict['objects_response']['text']['text_layout']['paragraphs'] = filtered_paragraphs
+            
             res += '\n'
             # logger.info(
             #     f"Skipped {len(skipped)} chars due to furigana filter sensitivity: {furigana_filter_sensitivity}")
@@ -438,7 +460,7 @@ class GoogleLens:
         #             res += '\n'
         
         if return_coords:
-            x = (True, res, response_dict)
+            x = (True, res, filtered_response_dict)
         else:
             x = (True, res)
 
@@ -869,11 +891,12 @@ class OneOCR:
     key = 'z'
     available = False
 
-    def __init__(self, config={}, lang='ja'):
+    def __init__(self, config={}, lang='ja', get_furigana_sens_from_file=True):
         import regex
         self.initial_lang = lang
         self.regex = get_regex(lang)
         self.punctuation_regex = regex.compile(r'[\p{P}\p{S}]')
+        self.get_furigana_sens_from_file = get_furigana_sens_from_file
         if sys.platform == 'win32':
             if int(platform.release()) < 10:
                 logger.warning('OneOCR is not supported on Windows older than 10!')
@@ -921,10 +944,10 @@ class OneOCR:
 
     def __call__(self, img, furigana_filter_sensitivity=0, return_coords=False, multiple_crop_coords=False, return_one_box=True, return_dict=False):
         lang = get_ocr_language()
-        if furigana_filter_sensitivity != None:
+        if self.get_furigana_sens_from_file:
             furigana_filter_sensitivity = get_furigana_filter_sensitivity()
         else:
-            furigana_filter_sensitivity = 0
+            furigana_filter_sensitivity = furigana_filter_sensitivity
         if lang != self.initial_lang:
             self.initial_lang = lang
             self.regex = get_regex(lang)
@@ -958,6 +981,7 @@ class OneOCR:
                 skipped = []
                 boxes = []
                 if furigana_filter_sensitivity > 0:
+                    passing_lines = []
                     for line in filtered_lines:
                         line_x1, line_x2, line_x3, line_x4 = line['bounding_rect']['x1'], line['bounding_rect']['x2'], \
                             line['bounding_rect']['x3'], line['bounding_rect']['x4']
@@ -965,16 +989,20 @@ class OneOCR:
                             line['bounding_rect']['y3'], line['bounding_rect']['y4']
                         line_width = max(line_x2 - line_x1, line_x3 - line_x4)
                         line_height = max(line_y3 - line_y1, line_y4 - line_y2)
-                        for char in line['words']:
-                            if self.punctuation_regex.findall(char['text']):
+                        
+                        # Check if the line passes the size filter
+                        if line_width > furigana_filter_sensitivity and line_height > furigana_filter_sensitivity:
+                            # Line passes - include all its text and add to passing_lines
+                            for char in line['words']:
                                 res += char['text']
-                                continue
-                            if line_width > furigana_filter_sensitivity and line_height > furigana_filter_sensitivity:
-                                res += char['text']
-                            else:
+                            passing_lines.append(line)
+                        else:
+                            # Line fails - only include punctuation, skip the rest
+                            for char in line['words']:
                                 skipped.extend(char for char in line['text'])
-                                continue
                         res += '\n'
+                    filtered_lines = passing_lines
+                    return_resp = {'text': res, 'text_angle': ocr_resp['text_angle'], 'lines': passing_lines}
                     # logger.info(
                     #     f"Skipped {len(skipped)} chars due to furigana filter sensitivity: {furigana_filter_sensitivity}")
                     # widths, heights = [], []
@@ -1012,6 +1040,7 @@ class OneOCR:
                     #     res += '\n'
                 else:
                     res = ocr_resp['text']
+                    return_resp = ocr_resp
                     
                 if multiple_crop_coords:
                     for line in filtered_lines:
@@ -1042,7 +1071,7 @@ class OneOCR:
         if return_one_box:
             x.append(crop_coords)
         if return_dict:
-            x.append(ocr_resp)
+            x.append(return_resp)
         if is_path:
             img.close()
         return x

GameSentenceMiner/tools/furigana_filter_preview.py

@@ -6,9 +6,42 @@ import threading
 import regex
 
 from GameSentenceMiner import obs
-from GameSentenceMiner.util.configuration import logger
+from GameSentenceMiner.util.configuration import logger, get_overlay_config
 from GameSentenceMiner.owocr.owocr.ocr import GoogleLens, OneOCR
 
+def get_overlay_screenshot() -> Image.Image:
+    """
+    Captures a screenshot from the configured overlay monitor using mss.
+    
+    Returns:
+        A PIL Image object of the screenshot from the overlay monitor.
+    """
+    try:
+        import mss
+        overlay_config = get_overlay_config()
+        monitor_index = overlay_config.monitor_to_capture
+        
+        with mss.mss() as sct:
+            # mss.monitors[0] is all monitors combined, mss.monitors[1] is the first monitor
+            # So we need to add 1 to the monitor_index to get the correct monitor
+            monitor = sct.monitors[monitor_index + 1]
+            screenshot = sct.grab(monitor)
+            
+            # Convert to PIL Image
+            img = Image.frombytes("RGB", screenshot.size, screenshot.bgra, "raw", "BGRX")
+            logger.info(f"Screenshot captured from monitor {monitor_index + 1} ({img.width}x{img.height})")
+            return img
+            
+    except ImportError:
+        logger.error("mss library not found. Please install it to use overlay functionality.")
+        raise
+    except IndexError:
+        logger.error(f"Monitor index {monitor_index + 1} not found. Available monitors: {len(sct.monitors) - 1}")
+        raise
+    except Exception as e:
+        logger.error(f"Failed to capture overlay screenshot: {e}")
+        raise
+
 def get_ocr_results_from_image(image_obj: Image.Image) -> tuple:
     """
     This is the function where you will plug in your OCR logic.
@@ -34,7 +67,8 @@ class FuriganaFilterVisualizer:
         self.ocr1_result = None
         self.ocr2_result = None
         self.current_ocr = 1
-        self.master.title("Furigana Filter Visualizer - Lens")
+        self.title_prefix = "Furigana Filter Visualizer"
+        self.master.title(f"{self.title_prefix} - Lens")
 
         self.words_data = []
         self.lines_data = []
@@ -84,6 +118,12 @@ class FuriganaFilterVisualizer:
 
         self.punctuation_regex = regex.compile(r'[\p{P}\p{S}]')
         self.master.protocol("WM_DELETE_WINDOW", self.on_ok)
+    
+    def set_title_prefix(self, prefix: str):
+        """Set the title prefix and update the current title."""
+        self.title_prefix = prefix
+        ocr_name = "Lens" if self.current_ocr == 1 else "OneOCR"
+        self.master.title(f"{self.title_prefix} - {ocr_name}")
 
     def update_with_ocr_data(self, ocr1_result, ocr2_result):
         """Called by the background thread to populate the GUI with OCR data."""
@@ -123,10 +163,10 @@ class FuriganaFilterVisualizer:
         # Change to oneocr or lens, in title too
         if self.current_ocr == 1:
             self.swap_button.config(text="Switch to OneOCR")
-            self.master.title("Furigana Filter Visualizer - Lens")
+            self.master.title(f"{self.title_prefix} - Lens")
         else:
             self.swap_button.config(text="Switch to Lens")
-            self.master.title("Furigana Filter Visualizer - OneOCR")
+            self.master.title(f"{self.title_prefix} - OneOCR")
         self.pre_process_word_geometries()
         self.update_filter_visualization(self.slider.get())
 
@@ -243,17 +283,22 @@ class FuriganaFilterVisualizer:
         for words that pass the sensitivity filter.
         """
         sensitivity = float(slider_value)
-        self.slider_value_label.config(text=f"{sensitivity:.0f} px")
+        # Only update the label if it exists (GUI is fully initialized)
+        if hasattr(self, 'slider_value_label'):
+            self.slider_value_label.config(text=f"{sensitivity:.0f} px")
 
         for rect_id in self.drawn_rects:
             self.canvas.delete(rect_id)
         self.drawn_rects.clear()
 
+        # Set color based on current OCR: green for Lens (OCR 1), blue for OneOCR (OCR 2)
+        outline_color = 'green' if self.current_ocr == 1 else 'blue'
+        
         for line_data in self.lines_data:
             if line_data['px_w'] > sensitivity and line_data['px_h'] > sensitivity:
                 x1, y1, x2, y2 = line_data['coords']
                 rect_id = self.canvas.create_rectangle(
-                    x1, y1, x2, y2, outline='blue', width=2
+                    x1, y1, x2, y2, outline=outline_color, width=2
                 )
                 self.drawn_rects.append(rect_id)
 
@@ -289,29 +334,64 @@ def scale_down_width_height(width, height):
 
 def main():
     import sys
-    current_furigana_sensitivity = int(sys.argv[1]) if len(sys.argv) > 1 else 0
+    
+    # Parse command line arguments
+    current_furigana_sensitivity = 0
+    use_overlay = False
+    
+    if len(sys.argv) > 1:
+        # Check if any argument is "overlay" or "--overlay"
+        args = sys.argv[1:]
+        if "overlay" in args or "--overlay" in args:
+            use_overlay = True
+            # Remove overlay flags and use remaining numeric argument as sensitivity
+            numeric_args = [arg for arg in args if arg not in ["overlay", "--overlay"] and arg.isdigit()]
+            if numeric_args:
+                current_furigana_sensitivity = int(numeric_args[0])
+        else:
+            # Assume first argument is sensitivity
+            try:
+                current_furigana_sensitivity = int(args[0])
+            except ValueError:
+                logger.warning(f"Invalid sensitivity value: {args[0]}. Using default value 0.")
 
     """Main execution function."""
-    try:
-        logger.info("Connecting to OBS...")
-        obs.connect_to_obs_sync()
-    except Exception as e:
-        logger.error(f"Failed to connect to OBS. Please ensure OBS is running and the WebSocket server is enabled. Error: {e}")
-        return
-
-    logger.info("Taking OBS screenshot...")
-    screenshot_img = obs.get_screenshot_PIL(compression=90, img_format='jpg')
+    if use_overlay:
+        logger.info("Using overlay mode - capturing from configured monitor...")
+        try:
+            screenshot_img = get_overlay_screenshot()
+        except Exception as e:
+            logger.error(f"Failed to get overlay screenshot: {e}")
+            return
+    else:
+        try:
+            logger.info("Connecting to OBS...")
+            obs.connect_to_obs_sync()
+        except Exception as e:
+            logger.error(f"Failed to connect to OBS. Please ensure OBS is running and the WebSocket server is enabled. Error: {e}")
+            return
 
-    screenshot_img = screenshot_img.resize(scale_down_width_height(screenshot_img.width, screenshot_img.height), Image.LANCZOS)
+        logger.info("Taking OBS screenshot...")
+        screenshot_img = obs.get_screenshot_PIL(compression=90, img_format='jpg')
 
-    if not screenshot_img:
-        logger.error("Failed to get screenshot from OBS.")
-        return
+        if not screenshot_img:
+            logger.error("Failed to get screenshot from OBS.")
+            return
 
-    logger.info(f"Screenshot received ({screenshot_img.width}x{screenshot_img.height}).")
+    # Scale down the image for performance
+    screenshot_img = screenshot_img.resize(scale_down_width_height(screenshot_img.width, screenshot_img.height), Image.LANCZOS)
+    
+    source_type = "overlay monitor" if use_overlay else "OBS"
+    logger.info(f"Screenshot received from {source_type} ({screenshot_img.width}x{screenshot_img.height}).")
 
     root = tk.Tk()
     app = FuriganaFilterVisualizer(root, screenshot_img, current_furigana_sensitivity)
+    
+    # Update window title to reflect source
+    if use_overlay:
+        overlay_config = get_overlay_config()
+        monitor_num = overlay_config.monitor_to_capture + 1
+        app.set_title_prefix(f"Furigana Filter Visualizer - Overlay Monitor {monitor_num}")
 
     def ocr_worker():
         logger.info("Starting OCR process in background thread...")

GameSentenceMiner/ui/config_gui.py

@@ -5,6 +5,7 @@ import os
 import subprocess
 import sys
 import time
+import re
 import tkinter as tk
 from tkinter import filedialog, messagebox, simpledialog, scrolledtext, font
 from PIL import Image, ImageTk
@@ -318,7 +319,39 @@ class ConfigApp:
         
         print(dialog.selected_path)
         return dialog.selected_path
-        
+    
+    
+    # IMPLEMENT LATER,FOR NOW JUST RUN THE FILE
+    # def show_furigana_filter_selector(self, current_sensitivity):
+    #     """
+    #     Displays a modal dialog for the user to select the furigana filter sensitivity.
+
+    #     Args:
+    #         current_sensitivity (int): The current sensitivity setting.
+    #     Returns: int: The selected sensitivity setting, or None if canceled.
+    #     """
+    #     dialog = FuriganaFilterSelectorDialog(self.window,
+    #                                           self,
+    #                                           current_sensitivity=current_sensitivity)
+    #     return dialog.selected_sensitivity
+
+    def show_minimum_character_size_selector(self, current_size):
+        """
+        Opens an external tool for selecting the minimum character size.
+
+        Args:
+            current_sensitivity (int): The current sensitivity setting.
+        Returns: int: The selected sensitivity setting, or None if canceled.
+        """
+        # Run the file directly with the current python interpreter and get stdout
+        result = subprocess.run([sys.executable, '-m', 'GameSentenceMiner.tools.furigana_filter_preview', str(current_size), 'overlay'], capture_output=True, text=True)
+        if result.returncode == 0:
+            # Parse the output for RESULT:[value]
+            match = re.search(r"RESULT:\[(\d+)\]", result.stdout)
+            if match:
+                return int(match.group(1))
+        return None
+
     def create_vars(self):
         """
         Initializes all the tkinter variables used in the configuration GUI.
@@ -462,6 +495,7 @@ class ConfigApp:
         self.periodic_value = tk.BooleanVar(value=self.settings.overlay.periodic)
         self.periodic_interval_value = tk.StringVar(value=str(self.settings.overlay.periodic_interval))
         self.scan_delay_value = tk.StringVar(value=str(self.settings.overlay.scan_delay))
+        self.overlay_minimum_character_size_value = tk.StringVar(value=str(self.settings.overlay.minimum_character_size))
         
         # Master Config Settings
         self.switch_to_default_if_not_found_value = tk.BooleanVar(value=self.master_config.switch_to_default_if_not_found)
@@ -703,6 +737,7 @@ class ConfigApp:
                 scan_delay=float(self.scan_delay_value.get()),
                 periodic=float(self.periodic_value.get()),
                 periodic_interval=float(self.periodic_interval_value.get()),
+                minimum_character_size=int(self.overlay_minimum_character_size_value.get()),
             )
             # wip=WIP(
             #     overlay_websocket_port=int(self.overlay_websocket_port_value.get()),
@@ -2387,6 +2422,19 @@ class ConfigApp:
         ttk.Entry(overlay_frame, textvariable=self.periodic_interval_value).grid(row=self.current_row, column=1, sticky='EW', pady=2)
         self.current_row += 1
 
+        # Minimum Character Size
+        minimum_character_size_i18n = overlay_i18n.get('minimum_character_size', {})
+        HoverInfoLabelWidget(overlay_frame, text=minimum_character_size_i18n.get('label', 'Minimum Character Size:'),
+                             tooltip=minimum_character_size_i18n.get('tooltip', 'Minimum size of characters to be detected.'),
+                             row=self.current_row, column=0)
+        ttk.Entry(overlay_frame, textvariable=self.overlay_minimum_character_size_value).grid(row=self.current_row, column=1, sticky='EW', pady=2)
+        # button to open minimum character size Finder
+        ttk.Button(overlay_frame, text=overlay_i18n.get('minimum_character_size_finder_button', 
+                                                        'Minimum Character Size Finder'), 
+                   command=lambda: self.open_minimum_character_size_selector(self.overlay_minimum_character_size_value.get()), bootstyle="outline").grid(row=self.current_row, column=2, padx=5, pady=2)
+
+        self.current_row += 1
+
         if self.monitors:
             # Ensure the index is valid
             monitor_index = self.settings.overlay.monitor_to_capture
@@ -2397,6 +2445,10 @@ class ConfigApp:
         
         self.add_reset_button(overlay_frame, "overlay", self.current_row, 0, self.create_overlay_tab)
 
+    def open_minimum_character_size_selector(self, size):
+        new_size = self.show_minimum_character_size_selector(size)
+        self.overlay_minimum_character_size_value.set(new_size)
+
     @new_tab
     def create_wip_tab(self):
         if self.wip_tab is None:

GameSentenceMiner/ui/furigana_filter_preview.py

@@ -0,0 +1,410 @@
+import tkinter as tk
+from tkinter import ttk
+from PIL import Image, ImageTk
+import threading
+
+import regex
+
+from GameSentenceMiner import obs
+from GameSentenceMiner.util.configuration import logger, get_overlay_config
+from GameSentenceMiner.owocr.owocr.ocr import GoogleLens, OneOCR
+
+def get_overlay_screenshot() -> Image.Image:
+    """
+    Captures a screenshot from the configured overlay monitor using mss.
+    
+    Returns:
+        A PIL Image object of the screenshot from the overlay monitor.
+    """
+    try:
+        import mss
+        overlay_config = get_overlay_config()
+        monitor_index = overlay_config.monitor_to_capture
+        
+        with mss.mss() as sct:
+            # mss.monitors[0] is all monitors combined, mss.monitors[1] is the first monitor
+            # So we need to add 1 to the monitor_index to get the correct monitor
+            monitor = sct.monitors[monitor_index + 1]
+            screenshot = sct.grab(monitor)
+            
+            # Convert to PIL Image
+            img = Image.frombytes("RGB", screenshot.size, screenshot.bgra, "raw", "BGRX")
+            logger.info(f"Screenshot captured from monitor {monitor_index + 1} ({img.width}x{img.height})")
+            return img
+            
+    except ImportError:
+        logger.error("mss library not found. Please install it to use overlay functionality.")
+        raise
+    except IndexError:
+        logger.error(f"Monitor index {monitor_index + 1} not found. Available monitors: {len(sct.monitors) - 1}")
+        raise
+    except Exception as e:
+        logger.error(f"Failed to capture overlay screenshot: {e}")
+        raise
+
+def get_ocr_results_from_image(image_obj: Image.Image) -> tuple:
+    """
+    This is the function where you will plug in your OCR logic.
+
+    Args:
+        image_obj: A PIL Image object of the screenshot (used by your actual OCR call).
+
+    Returns:
+        A tuple containing the OCR results from both engines.
+    """
+    lens = GoogleLens()
+    oneocr = OneOCR()
+    oneocr_res = oneocr(image_obj, return_dict=True)
+    res = lens(image_obj, return_coords=True)
+    
+    return res[2], oneocr_res[3]
+
+
+class FuriganaFilterVisualizer:
+    def __init__(self, master, image: Image.Image, current_furigana_sensitivity: int = 0):
+        self.master = master
+        self.image = image
+        self.ocr1_result = None
+        self.ocr2_result = None
+        self.current_ocr = 1
+        self.title_prefix = "Furigana Filter Visualizer"
+        self.master.title(f"{self.title_prefix} - Lens")
+
+        self.words_data = []
+        self.lines_data = []
+        self.drawn_rects = []
+
+        main_frame = tk.Frame(master)
+        main_frame.pack(fill=tk.BOTH, expand=True)
+
+        self.photo_image = ImageTk.PhotoImage(self.image)
+        self.canvas = tk.Canvas(main_frame, width=self.image.width, height=self.image.height)
+        self.canvas.pack(side=tk.TOP, fill=tk.BOTH, expand=True)
+        self.canvas.create_image(0, 0, image=self.photo_image, anchor=tk.NW)
+
+        self.loading_bg = self.canvas.create_rectangle(
+            self.image.width/2 - 100, self.image.height/2 - 25,
+            self.image.width/2 + 100, self.image.height/2 + 25,
+            fill="black", outline="white", width=2
+        )
+        self.loading_text = self.canvas.create_text(
+            self.image.width / 2, self.image.height / 2,
+            text="Loading OCR data...", fill="white", font=("Helvetica", 16)
+        )
+
+        self.control_frame = tk.Frame(main_frame, padx=10, pady=10)
+        self.control_frame.pack(side=tk.BOTTOM, fill=tk.X)
+
+        ttk.Label(self.control_frame, text="Furigana Filter Sensitivity:").pack(side=tk.LEFT, padx=(0, 10))
+
+        self.slider = ttk.Scale(
+            self.control_frame, from_=0, to=100, orient=tk.HORIZONTAL, command=self.update_filter_visualization
+        )
+        self.slider.set(current_furigana_sensitivity)
+        self.slider.pack(side=tk.LEFT, fill=tk.X, expand=True)
+
+        self.slider_value_label = ttk.Label(self.control_frame, text=f"{self.slider.get():.0f} px", width=6)
+        self.slider_value_label.pack(side=tk.LEFT, padx=(10, 0))
+        
+        self.swap_button = ttk.Button(self.control_frame, text="Switch to OneOCR", command=self.swap_ocr)
+        self.swap_button.pack(side=tk.LEFT, padx=(10, 0))
+            
+        self.ok_button = ttk.Button(self.control_frame, text="OK", command=self.on_ok)
+        self.ok_button.pack(side=tk.LEFT, padx=(10, 0))
+        
+        self.slider.config(state=tk.DISABLED)
+        self.swap_button.config(state=tk.DISABLED)
+        self.ok_button.config(state=tk.DISABLED)
+
+        self.punctuation_regex = regex.compile(r'[\p{P}\p{S}]')
+        self.master.protocol("WM_DELETE_WINDOW", self.on_ok)
+    
+    def set_title_prefix(self, prefix: str):
+        """Set the title prefix and update the current title."""
+        self.title_prefix = prefix
+        ocr_name = "Lens" if self.current_ocr == 1 else "OneOCR"
+        self.master.title(f"{self.title_prefix} - {ocr_name}")
+
+    def update_with_ocr_data(self, ocr1_result, ocr2_result):
+        """Called by the background thread to populate the GUI with OCR data."""
+        self.ocr1_result = ocr1_result
+        self.ocr2_result = ocr2_result
+
+        # Remove loading message
+        self.canvas.delete(self.loading_bg)
+        self.canvas.delete(self.loading_text)
+
+        if not self.ocr1_result:
+            logger.error("OCR processing failed or returned no data.")
+            self.canvas.create_text(
+                self.image.width / 2, self.image.height / 2,
+                text="OCR Failed!", fill="red", font=("Helvetica", 16)
+            )
+            # Still enable OK button to allow closing
+            self.ok_button.config(state=tk.NORMAL)
+            return
+
+        # Enable controls
+        self.slider.config(state=tk.NORMAL)
+        self.ok_button.config(state=tk.NORMAL)
+        if self.ocr2_result:
+            self.swap_button.config(state=tk.NORMAL)
+        
+        # Process and display initial data
+        self.pre_process_word_geometries()
+        self.update_filter_visualization(self.slider.get())
+
+    def on_ok(self):
+        print(f"RESULT:[{self.slider.get():.0f}]")
+        self.master.destroy()
+
+    def swap_ocr(self):
+        self.current_ocr = 2 if self.current_ocr == 1 else 1
+        # Change to oneocr or lens, in title too
+        if self.current_ocr == 1:
+            self.swap_button.config(text="Switch to OneOCR")
+            self.master.title(f"{self.title_prefix} - Lens")
+        else:
+            self.swap_button.config(text="Switch to Lens")
+            self.master.title(f"{self.title_prefix} - OneOCR")
+        self.pre_process_word_geometries()
+        self.update_filter_visualization(self.slider.get())
+
+    def pre_process_word_geometries(self):
+        """
+        Parses the OCR result structure (supports both original and new JSON formats),
+        calculates absolute pixel values, and stores them for high-performance updates.
+        """
+        img_w, img_h = self.image.size
+        logger.info(f"Processing word geometries for image size {img_w}x{img_h}...")
+
+        # Select the current OCR result
+        ocr_result = self.ocr1_result if self.current_ocr == 1 else self.ocr2_result
+        if not ocr_result:
+            return
+        self.words_data.clear()
+        self.lines_data.clear()
+
+        # Try to detect the format: oneocr has 'lines' as a top-level key
+        if 'lines' in ocr_result:
+            for line in ocr_result.get('lines', []):
+                for word in line.get('words', []):
+                    try:
+                        bbox = word['bounding_rect']
+                        x1 = bbox['x1']
+                        y1 = bbox['y1']
+                        x2 = bbox['x3']
+                        y2 = bbox['y3']
+                        px_w = abs(x2 - x1)
+                        px_h = abs(y2 - y1)
+                        self.words_data.append({
+                            'text': word.get('text', ''),
+                            'px_w': px_w,
+                            'px_h': px_h,
+                            'coords': (x1, y1, x2, y2)
+                        })
+                    except Exception as e:
+                        logger.warning(f"Skipping malformed word data (new format): {e}. Data: {word}")
+                        continue
+                try:
+                    bbox = line['bounding_rect']
+                    x1 = bbox['x1']
+                    y1 = bbox['y1']
+                    x2 = bbox['x3']
+                    y2 = bbox['y3']
+                    px_w = abs(x2 - x1)
+                    px_h = abs(y2 - y1)
+                    self.lines_data.append({
+                        'text': line.get('text', ''),
+                        'px_w': px_w,
+                        'px_h': px_h,
+                        'coords': (x1, y1, x2, y2)
+                    })
+                except Exception as e:
+                    logger.warning(f"Skipping malformed line data (new format): {e}. Data: {line}")
+                    continue
+        else:
+            # Lens format (nested paragraphs/lines/words)
+            text_layout = ocr_result.get('objects_response', {}).get('text', {}).get('text_layout', {})
+            if not text_layout:
+                logger.error("Could not find 'text_layout' in the OCR response.")
+                return
+            for paragraph in text_layout.get('paragraphs', []):
+                for line in paragraph.get('lines', []):
+                    for word in line.get('words', []):
+                        try:
+                            bbox_pct = word['geometry']['bounding_box']
+                            width_pct = bbox_pct['width']
+                            height_pct = bbox_pct['height']
+                            top_left_x_pct = bbox_pct['center_x'] - (width_pct / 2)
+                            top_left_y_pct = bbox_pct['center_y'] - (height_pct / 2)
+                            px_w = width_pct * img_w
+                            px_h = height_pct * img_h
+                            x1 = top_left_x_pct * img_w
+                            y1 = top_left_y_pct * img_h
+                            x2 = x1 + px_w
+                            y2 = y1 + px_h
+                            self.words_data.append({
+                                'text': word.get('plain_text', ''),
+                                'px_w': px_w,
+                                'px_h': px_h,
+                                'coords': (x1, y1, x2, y2)
+                            })
+                        except (KeyError, TypeError) as e:
+                            logger.warning(f"Skipping malformed word data (orig format): {e}. Data: {word}")
+                            continue
+                    try:
+                        line_bbox = line['geometry']['bounding_box']
+                        width_pct = line_bbox['width']
+                        height_pct = line_bbox['height']
+                        top_left_x_pct = line_bbox['center_x'] - (width_pct / 2)
+                        top_left_y_pct = line_bbox['center_y'] - (height_pct / 2)
+                        px_w = width_pct * img_w
+                        px_h = height_pct * img_h
+                        x1 = top_left_x_pct * img_w
+                        y1 = top_left_y_pct * img_h
+                        x2 = x1 + px_w
+                        y2 = y1 + px_h
+                        self.lines_data.append({
+                            'text': ''.join([w.get('plain_text', '') for w in line.get('words', [])]),
+                            'px_w': px_w,
+                            'px_h': px_h,
+                            'coords': (x1, y1, x2, y2)
+                        })
+                    except (KeyError, TypeError) as e:
+                        logger.warning(f"Skipping malformed line data (orig format): {e}. Data: {line}")
+                        continue
+        logger.info(f"Successfully pre-processed {len(self.lines_data)} lines.")
+        
+
+    def update_filter_visualization(self, slider_value):
+        """
+        Called on every slider move. Clears old rectangles and draws new ones
+        for words that pass the sensitivity filter.
+        """
+        sensitivity = float(slider_value)
+        # Only update the label if it exists (GUI is fully initialized)
+        if hasattr(self, 'slider_value_label'):
+            self.slider_value_label.config(text=f"{sensitivity:.0f} px")
+
+        for rect_id in self.drawn_rects:
+            self.canvas.delete(rect_id)
+        self.drawn_rects.clear()
+
+        # Set color based on current OCR: green for Lens (OCR 1), blue for OneOCR (OCR 2)
+        outline_color = 'green' if self.current_ocr == 1 else 'blue'
+        
+        for line_data in self.lines_data:
+            if line_data['px_w'] > sensitivity and line_data['px_h'] > sensitivity:
+                x1, y1, x2, y2 = line_data['coords']
+                rect_id = self.canvas.create_rectangle(
+                    x1, y1, x2, y2, outline=outline_color, width=2
+                )
+                self.drawn_rects.append(rect_id)
+
+def scale_down_width_height(width, height):
+        if width == 0 or height == 0:
+            return width, height
+        aspect_ratio = width / height
+        if aspect_ratio > 2.66:
+            # Ultra-wide (32:9) - use 1920x540
+            return 1920, 540
+        elif aspect_ratio > 2.33:
+            # 21:9 - use 1920x800
+            return 1920, 800
+        elif aspect_ratio > 1.77:
+            # 16:9 - use 1280x720
+            return 1280, 720
+        elif aspect_ratio > 1.6:
+            # 16:10 - use 1280x800
+            return 1280, 800
+        elif aspect_ratio > 1.33:
+            # 4:3 - use 960x720
+            return 960, 720
+        elif aspect_ratio > 1.25:
+            # 5:4 - use 900x720
+            return 900, 720
+        elif aspect_ratio > 1.5:
+            # 3:2 - use 1080x720
+            return 1080, 720
+        else:
+            # Default/fallback - use original resolution
+            print(f"Unrecognized aspect ratio {aspect_ratio}. Using original resolution.")
+            return width, height
+
+def main():
+    import sys
+    
+    # Parse command line arguments
+    current_furigana_sensitivity = 0
+    use_overlay = False
+    
+    if len(sys.argv) > 1:
+        # Check if any argument is "overlay" or "--overlay"
+        args = sys.argv[1:]
+        if "overlay" in args or "--overlay" in args:
+            use_overlay = True
+            # Remove overlay flags and use remaining numeric argument as sensitivity
+            numeric_args = [arg for arg in args if arg not in ["overlay", "--overlay"] and arg.isdigit()]
+            if numeric_args:
+                current_furigana_sensitivity = int(numeric_args[0])
+        else:
+            # Assume first argument is sensitivity
+            try:
+                current_furigana_sensitivity = int(args[0])
+            except ValueError:
+                logger.warning(f"Invalid sensitivity value: {args[0]}. Using default value 0.")
+
+    """Main execution function."""
+    if use_overlay:
+        logger.info("Using overlay mode - capturing from configured monitor...")
+        try:
+            screenshot_img = get_overlay_screenshot()
+        except Exception as e:
+            logger.error(f"Failed to get overlay screenshot: {e}")
+            return
+    else:
+        try:
+            logger.info("Connecting to OBS...")
+            obs.connect_to_obs_sync()
+        except Exception as e:
+            logger.error(f"Failed to connect to OBS. Please ensure OBS is running and the WebSocket server is enabled. Error: {e}")
+            return
+
+        logger.info("Taking OBS screenshot...")
+        screenshot_img = obs.get_screenshot_PIL(compression=90, img_format='jpg')
+
+        if not screenshot_img:
+            logger.error("Failed to get screenshot from OBS.")
+            return
+
+    # Scale down the image for performance
+    screenshot_img = screenshot_img.resize(scale_down_width_height(screenshot_img.width, screenshot_img.height), Image.LANCZOS)
+    
+    source_type = "overlay monitor" if use_overlay else "OBS"
+    logger.info(f"Screenshot received from {source_type} ({screenshot_img.width}x{screenshot_img.height}).")
+
+    root = tk.Tk()
+    app = FuriganaFilterVisualizer(root, screenshot_img, current_furigana_sensitivity)
+    
+    # Update window title to reflect source
+    if use_overlay:
+        overlay_config = get_overlay_config()
+        monitor_num = overlay_config.monitor_to_capture + 1
+        app.set_title_prefix(f"Furigana Filter Visualizer - Overlay Monitor {monitor_num}")
+
+    def ocr_worker():
+        logger.info("Starting OCR process in background thread...")
+        try:
+            ocr1_data, ocr2_data = get_ocr_results_from_image(screenshot_img)
+            root.after(0, app.update_with_ocr_data, ocr1_data, ocr2_data)
+        except Exception as e:
+            logger.error(f"Error in OCR background thread: {e}")
+            root.after(0, app.update_with_ocr_data, None, None)
+
+    threading.Thread(target=ocr_worker, daemon=True).start()
+
+    root.mainloop()
+
+if __name__ == "__main__":
+    main()

GameSentenceMiner/util/configuration.py

@@ -5,6 +5,7 @@ import os
 import shutil
 import threading
 import inspect
+import re
 
 from dataclasses import dataclass, field
 from logging.handlers import RotatingFileHandler
@@ -409,7 +410,6 @@ class General:
         except ValueError:
             return "Unknown"
 
-
 @dataclass_json
 @dataclass
 class Paths:
@@ -424,9 +424,11 @@ class Paths:
 
     def __post_init__(self):
         if self.folder_to_watch:
-            self.folder_to_watch = os.path.normpath(self.folder_to_watch)
+            self.folder_to_watch = os.path.normpath(self.folder_to_watch).replace("\\", "/")
+            self.folder_to_watch = re.sub(r'/+', '/', self.folder_to_watch)
         if self.output_folder:
-            self.output_folder = os.path.normpath(self.output_folder)
+            self.output_folder = os.path.normpath(self.output_folder).replace("\\", "/")
+            self.output_folder = re.sub(r'/+', '/', self.output_folder)
 
 
 @dataclass_json
@@ -647,6 +649,16 @@ class Ai:
         # Change Legacy Model Name
         if self.gemini_model == 'gemini-2.5-flash-lite-preview-06-17':
             self.gemini_model = 'gemini-2.5-flash-lite'
+            
+    def is_configured(self) -> bool:
+        if self.enabled:
+            if self.provider == AI_GEMINI and self.gemini_api_key and self.gemini_model:
+                return True
+            if self.provider == AI_GROQ and self.groq_api_key and self.groq_model:
+                return True
+            if self.provider == AI_OPENAI and self.open_ai_api_key and self.open_ai_model and self.open_ai_url:
+                return True
+        return False
 
 
 class OverlayEngine(str, Enum):
@@ -662,6 +674,7 @@ class Overlay:
     periodic: bool = False
     periodic_interval: float = 1.0
     scan_delay: float = 0.25
+    minimum_character_size: int = 0
 
     def __post_init__(self):
         if self.monitor_to_capture == -1:

GameSentenceMiner/util/get_overlay_coords.py

@@ -141,8 +141,8 @@ class OverlayProcessor:
             if self.config.overlay.websocket_port and all([GoogleLens, get_regex]):
                 logger.info("Initializing OCR engines...")
                 if OneOCR:
-                    self.oneocr = OneOCR(lang=get_ocr_language())
-                self.lens = GoogleLens(lang=get_ocr_language())
+                    self.oneocr = OneOCR(lang=get_ocr_language(), get_furigana_sens_from_file=False)
+                self.lens = GoogleLens(lang=get_ocr_language(), get_furigana_sens_from_file=False)
                 self.ocr_language = get_ocr_language()
                 self.regex = get_regex(self.ocr_language)
                 logger.info("OCR engines initialized.")
@@ -253,7 +253,6 @@ class OverlayProcessor:
         if not mss:
             raise RuntimeError("MSS screenshot library is not installed.")
         with mss.mss() as sct:
-            logger.info(get_overlay_config())
             monitor = self.get_monitor_workarea(get_overlay_config().monitor_to_capture)  # Get primary monitor work area
             sct_img = sct.grab(monitor)
             img = Image.frombytes('RGB', sct_img.size, sct_img.bgra, 'raw', 'BGRX')
@@ -338,9 +337,12 @@ class OverlayProcessor:
                 return_coords=True,
                 multiple_crop_coords=True,
                 return_one_box=False,
-                furigana_filter_sensitivity=None, # Disable furigana filtering
+                furigana_filter_sensitivity=get_overlay_config().minimum_character_size,
             )
             
+            if not crop_coords_list:
+                return        
+            
             # Check for cancellation after OneOCR
             if asyncio.current_task().cancelled():
                 raise asyncio.CancelledError()
@@ -388,7 +390,7 @@ class OverlayProcessor:
         res = self.lens(
             composite_image,
             return_coords=True,
-            furigana_filter_sensitivity=None # Disable furigana filtering
+            furigana_filter_sensitivity=get_overlay_config().minimum_character_size
         )
         
         # Check for cancellation after Google Lens
@@ -455,6 +457,8 @@ class OverlayProcessor:
 
         for para in paragraphs:
             for line in para.get("lines", []):
+                # if not self.regex.match(line.get("plain_text", "")):
+                #     continue
                 line_text_parts = []
                 word_list = []
 
@@ -541,6 +545,9 @@ class OverlayProcessor:
         """
         converted_results = []
         for item in oneocr_results:
+            # Check Regex
+            # if not self.regex.match(item.get("text", "")):
+            #     continue
             bbox = item.get("bounding_rect", {})
             if not bbox:
                 continue

GameSentenceMiner/web/texthooking_page.py

@@ -217,6 +217,9 @@ def translate_line():
     text = data.get('text', '').strip()
     if event_id is None:
         return jsonify({'error': 'Missing id'}), 400
+    
+    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
     line = get_line_by_id(event_id)
     if line is None:
         return jsonify({'error': 'Invalid id'}), 400

{gamesentenceminer-2.18.9.dist-info → gamesentenceminer-2.18.11.dist-info}/METADATA

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

{gamesentenceminer-2.18.9.dist-info → gamesentenceminer-2.18.11.dist-info}/RECORD

@@ -27,25 +27,26 @@ GameSentenceMiner/owocr/owocr/__init__.py,sha256=87hfN5u_PbL_onLfMACbc0F5j4KyIK9
 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=7VCTBl4-8mO9P73olLMihUFtu3idBdyZIWP6XQhCte4,70484
+GameSentenceMiner/owocr/owocr/ocr.py,sha256=8cqZEUF90UlV3jBIvxKBga6YBFGjNBCVu1UiBcwISG0,72215
 GameSentenceMiner/owocr/owocr/run.py,sha256=Z7VkoFrsoQbMTHc6CmwpcMzsOROK9A_RJRwhlxw15oA,81871
 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
-GameSentenceMiner/tools/furigana_filter_preview.py,sha256=BXv7FChPEJW_VeG5XYt6suAsMKVArsjr3cEduE9KhYg,13642
+GameSentenceMiner/tools/furigana_filter_preview.py,sha256=DAT2-j6vSDHr9ufk6PiaLikEsbIp56B_OHIEeYLMwlk,17135
 GameSentenceMiner/tools/ss_selector.py,sha256=ob2oJdiYreDMMau7CvsglpnhZ1CDnJqop3lV54-PjRo,4782
 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=ohpWlPTvKn-_5_lpINdKZciR0k8RWRfnDrfuzyJgItc,15242
-GameSentenceMiner/ui/config_gui.py,sha256=4baqfL33oMshmqm903GZok32Y4JIEV-3K9gf5gxAJDU,152131
+GameSentenceMiner/ui/config_gui.py,sha256=9Ak6DocxTuHWrNXYGd2W-82oUGTgaD8F25Ibge_HWSc,155064
+GameSentenceMiner/ui/furigana_filter_preview.py,sha256=DAT2-j6vSDHr9ufk6PiaLikEsbIp56B_OHIEeYLMwlk,17135
 GameSentenceMiner/ui/screenshot_selector.py,sha256=AKML87MpgYQeSuj1F10GngpNrn9qp06zLLzNRwrQWM8,8900
 GameSentenceMiner/util/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 GameSentenceMiner/util/audio_player.py,sha256=-yFsf0qoTSS1ga5rCmEJZJGUSJzXCvfZHY3t0NxycDk,7896
-GameSentenceMiner/util/configuration.py,sha256=lwo73S3xnIMPq8lWSWM6N0pd08A4-JvrejypT3ZvTr8,47483
+GameSentenceMiner/util/configuration.py,sha256=txJKUVCwLgIzg0JobxiKnpzTGlCpM3rVdVimVWau6Zw,48178
 GameSentenceMiner/util/db.py,sha256=1DjGjlwWnPefmQfzvMqqFPW0a0qeO-fIXE1YqKiok18,32000
 GameSentenceMiner/util/electron_config.py,sha256=KfeJToeFFVw0IR5MKa-gBzpzaGrU-lyJbR9z-sDEHYU,8767
 GameSentenceMiner/util/ffmpeg.py,sha256=cAzztfY36Xf2WvsJDjavoiMOvA9ac2GVdCrSB4LzHk4,29007
-GameSentenceMiner/util/get_overlay_coords.py,sha256=MFl_JOjwzD0D0iZBPcq5Dgy32YPMKqRrugL0WsfMEu4,24819
+GameSentenceMiner/util/get_overlay_coords.py,sha256=TJz3iVimiwhRLwkYNB1uOZnDR4BEWWUWYjoJEe7uSQs,25160
 GameSentenceMiner/util/gsm_utils.py,sha256=mASECTmN10c2yPL4NEfLg0Y0YWwFso1i6r_hhJPR3MY,10974
 GameSentenceMiner/util/model.py,sha256=R-_RYTYLSDNgBoVTPuPBcIHeOznIqi_vBzQ7VQ20WYk,6727
 GameSentenceMiner/util/notification.py,sha256=YBhf_mSo_i3cjBz-pmeTPx3wchKiG9BK2VBdZSa2prQ,4597
@@ -65,7 +66,7 @@ GameSentenceMiner/web/events.py,sha256=6Vyz5c9MdpMIa7Zqljqhap2XFQnAVYJ0CdQV64TSZ
 GameSentenceMiner/web/gsm_websocket.py,sha256=B0VKpxmsRu0WRh5nFWlpDPBQ6-K2ed7TEIa0O6YWeoo,4166
 GameSentenceMiner/web/service.py,sha256=6cgUmDgtp3ZKzuPFszowjPoq-BDtC1bS3ux6sykeaqo,6662
 GameSentenceMiner/web/stats.py,sha256=zIK0ZzyInvvlJh87KhAKYl2CCuMJWW6Wyv7UssURFbE,22366
-GameSentenceMiner/web/texthooking_page.py,sha256=IHRy3VTMAwJeGjTNr3TgjHgxe--g5jZcnHmNzxILXQE,15698
+GameSentenceMiner/web/texthooking_page.py,sha256=fyMz74cfv4qPlA29UVJH0YhsuXtUL2aTEWNh4PwVaP4,15876
 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
@@ -125,9 +126,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.18.9.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-gamesentenceminer-2.18.9.dist-info/METADATA,sha256=4CeXXcMgBMAwMH_61VDFQWr_xyt-5Fg4XDsQ2sfJA6s,7487
-gamesentenceminer-2.18.9.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-gamesentenceminer-2.18.9.dist-info/entry_points.txt,sha256=2APEP25DbfjSxGeHtwBstMH8mulVhLkqF_b9bqzU6vQ,65
-gamesentenceminer-2.18.9.dist-info/top_level.txt,sha256=V1hUY6xVSyUEohb0uDoN4UIE6rUZ_JYx8yMyPGX4PgQ,18
-gamesentenceminer-2.18.9.dist-info/RECORD,,
+gamesentenceminer-2.18.11.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+gamesentenceminer-2.18.11.dist-info/METADATA,sha256=x2IbmM6IgBD1ASP88yxHCsXhaweR2ZFrs8r6ZnVnICk,7488
+gamesentenceminer-2.18.11.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+gamesentenceminer-2.18.11.dist-info/entry_points.txt,sha256=2APEP25DbfjSxGeHtwBstMH8mulVhLkqF_b9bqzU6vQ,65
+gamesentenceminer-2.18.11.dist-info/top_level.txt,sha256=V1hUY6xVSyUEohb0uDoN4UIE6rUZ_JYx8yMyPGX4PgQ,18
+gamesentenceminer-2.18.11.dist-info/RECORD,,