GameSentenceMiner 2.9.22__py3-none-any.whl → 2.9.24__py3-none-any.whl

GameSentenceMiner/config_gui.py

@@ -226,6 +226,9 @@ class ConfigApp:
                 trim_beginning=self.vad_trim_beginning.get(),
                 beginning_offset=float(self.vad_beginning_offset.get()),
                 add_audio_on_no_results=self.add_audio_on_no_results.get(),
+                language=self.language.get(),
+                cut_and_splice_segments=self.cut_and_splice_segments.get(),
+                splice_padding=float(self.splice_padding.get()) if self.splice_padding.get() else 0.0,
             ),
             advanced=Advanced(
                 audio_player_path=self.audio_player_path.get(),
@@ -497,6 +500,18 @@ class ConfigApp:
         ttk.Checkbutton(vad_frame, variable=self.add_audio_on_no_results).grid(row=self.current_row, column=1, sticky='W')
         self.add_label_and_increment_row(vad_frame, "Add audio even if no results are found by VAD.", row=self.current_row, column=2)
 
+        ttk.Label(vad_frame, text="Cut and Splice Segments:").grid(row=self.current_row, column=0, sticky='W')
+        self.cut_and_splice_segments = tk.BooleanVar(value=self.settings.vad.cut_and_splice_segments)
+        ttk.Checkbutton(vad_frame, variable=self.cut_and_splice_segments).grid(row=self.current_row, column=1, sticky='W')
+        self.add_label_and_increment_row(vad_frame, "Enable to cut and splice audio segments together based on VAD results.", row=self.current_row, column=2)
+
+        ttk.Label(vad_frame, text="Splice Padding (seconds):").grid(row=self.current_row, column=0, sticky='W')
+        self.splice_padding = ttk.Entry(vad_frame)
+        self.splice_padding.insert(0, str(self.settings.vad.splice_padding))
+        self.splice_padding.grid(row=self.current_row, column=1)
+        self.add_label_and_increment_row(vad_frame, "Padding in seconds added to spliced audio segments. WARNING: This may result in duplicated voicelines if too high!", row=self.current_row, column=2)
+
+
 
     @new_tab
     def create_paths_tab(self):

GameSentenceMiner/gsm.py

@@ -10,7 +10,8 @@ os.environ.pop('TCL_LIBRARY', None)
 from GameSentenceMiner.util.gsm_utils import wait_for_stable_file, make_unique_file_name, run_new_thread
 from GameSentenceMiner.util.communication.send import send_restart_signal
 from GameSentenceMiner.util.downloader.download_tools import download_obs_if_needed, download_ffmpeg_if_needed
-from GameSentenceMiner.vad import vad_processor, VADResult
+from GameSentenceMiner.vad import vad_processor
+from GameSentenceMiner.util.model import VADResult
 
 try:
     import os.path

GameSentenceMiner/ocr/owocr_area_selector.py

@@ -269,7 +269,7 @@ class ScreenSelector:
         """Saves rectangles to the config file, using percentages if window is targeted."""
         # Use the window geometry found during __init__ for consistency during save
         window_geom_to_save = self.target_window_geometry
-        save_coord_system = COORD_SYSTEM_ABSOLUTE  # Default if no window
+        save_coord_system = COORD_SYSTEM_PERCENTAGE  # Default if no window
 
         config_path = self.get_scene_ocr_config()
         print(f"Saving rectangles to: {config_path}")
@@ -334,6 +334,8 @@ class ScreenSelector:
                 serializable_rects.append(rect_data)
 
             # Prepare final data structure for JSON
+            if not self.rectangles or len(self.rectangles) == 0:
+                save_coord_system = COORD_SYSTEM_PERCENTAGE
             save_data = {
                 "scene": obs.get_current_scene() or "default_scene",
                 "window": self.window_name,  # Store targeted window name

GameSentenceMiner/ocr/owocr_helper.py

@@ -82,7 +82,7 @@ def get_ocr_config(window=None) -> OCRConfig:
     scene = sanitize_filename(obs.get_current_scene())
     config_path = ocr_config_dir / f"{scene}.json"
     if not config_path.exists():
-        ocr_config = OCRConfig(scene=scene, window=window, rectangles=[], coordinate_system="")
+        ocr_config = OCRConfig(scene=scene, window=window, rectangles=[], coordinate_system="percentage")
         with open(config_path, 'w', encoding="utf-8") as f:
             json.dump(ocr_config.to_dict(), f, indent=4)
         return ocr_config
@@ -212,7 +212,7 @@ def do_second_ocr(ocr1_text, time, img, filtering):
     global twopassocr, ocr2, last_ocr2_result
     try:
         orig_text, text = run.process_and_write_results(img, None, last_ocr2_result, filtering, None,
-                                                        engine=ocr2)
+                                                        engine=ocr2, furigana_filter_sensitivity=furigana_filter_sensitivity)
         if fuzz.ratio(last_ocr2_result, text) >= 90:
             logger.info("Seems like the same text from previous ocr2 result, not sending")
             return
@@ -341,27 +341,31 @@ def run_oneocr(ocr_config: OCRConfig, rectangles):
         exclusions = list(rect.coordinates for rect in list(filter(lambda x: x.is_excluded, rectangles)))
 
     run.init_config(False)
-    run.run(read_from="screencapture" if not ssonly else "clipboard" if ss_clipboard else "",
-            read_from_secondary="clipboard" if ss_clipboard and not ssonly else None,
-            write_to="callback",
-            screen_capture_area=screen_area,
-            # screen_capture_monitor=monitor_config['index'],
-            screen_capture_window=ocr_config.window if ocr_config and ocr_config.window else None,
-            screen_capture_only_active_windows=get_requires_open_window(),
-            screen_capture_delay_secs=get_ocr_scan_rate(), engine=ocr1,
-            text_callback=text_callback,
-            screen_capture_exclusions=exclusions,
-            language=language,
-            monitor_index=None,
-            ocr1=ocr1,
-            ocr2=ocr2,
-            gsm_ocr_config=ocr_config,
-            screen_capture_areas=screen_areas)
+    try:
+        run.run(read_from="screencapture" if not ssonly else "clipboard" if ss_clipboard else "",
+                read_from_secondary="clipboard" if ss_clipboard and not ssonly else None,
+                write_to="callback",
+                screen_capture_area=screen_area,
+                # screen_capture_monitor=monitor_config['index'],
+                screen_capture_window=ocr_config.window if ocr_config and ocr_config.window else None,
+                screen_capture_only_active_windows=get_requires_open_window(),
+                screen_capture_delay_secs=get_ocr_scan_rate(), engine=ocr1,
+                text_callback=text_callback,
+                screen_capture_exclusions=exclusions,
+                language=language,
+                monitor_index=None,
+                ocr1=ocr1,
+                ocr2=ocr2,
+                gsm_ocr_config=ocr_config,
+                screen_capture_areas=screen_areas,
+                furigana_filter_sensitivity=furigana_filter_sensitivity)
+    except Exception as e:
+        logger.exception(f"Error running OneOCR: {e}")
     done = True
 
 
 
-def add_ss_hotkey():
+def add_ss_hotkey(ss_hotkey="ctrl+shift+g"):
     import keyboard
     cropper = ScreenCropper()
     filtering = TextFiltering()
@@ -369,9 +373,23 @@ def add_ss_hotkey():
         print("Taking screenshot...")
         img = cropper.run()
         do_second_ocr("", datetime.now(), img, filtering)
-
-    keyboard.add_hotkey('ctrl+shift+g', capture)
-    print("Press Ctrl+Shift+G to take a screenshot.")
+    try:
+        raise Exception("Forcing keyboard hotkey setup, this is a test.")
+        keyboard.add_hotkey(ss_hotkey, capture)
+        print(f"Press {ss_hotkey} to take a screenshot.")
+    except Exception as e:
+        logger.error(f"Error setting up screenshot hotkey with keyboard, Attempting Backup: {e}")
+        logger.debug(e)
+        pynput_hotkey = ss_hotkey.replace("ctrl", "<ctrl>").replace("shift", "<shift>").replace("alt", "<alt>")
+        try:
+            from pynput import keyboard as pynput_keyboard
+            listener = pynput_keyboard.GlobalHotKeys({
+                pynput_hotkey: capture
+            })
+            listener.start()
+            print(f"Press {pynput_hotkey} to take a screenshot.")
+        except Exception as e:
+            logger.error(f"Error setting up screenshot hotkey with pynput, Screenshot Hotkey Will not work: {e}")
 
 
 def get_window(window_name):
@@ -402,7 +420,7 @@ def set_force_stable_hotkey():
     print("Press Ctrl+Shift+F to toggle force stable mode.")
 
 if __name__ == "__main__":
-    global ocr1, ocr2, twopassocr, language, ss_clipboard, ss, ocr_config
+    global ocr1, ocr2, twopassocr, language, ss_clipboard, ss, ocr_config, furigana_filter_sensitivity
     import sys
 
     import argparse
@@ -415,6 +433,8 @@ if __name__ == "__main__":
     parser.add_argument("--ssonly", action="store_true", help="Use screenshot-only mode")
     parser.add_argument("--clipboard", action="store_true", help="Use clipboard for input")
     parser.add_argument("--window", type=str, help="Specify the window name for OCR")
+    parser.add_argument("--furigana_filter_sensitivity", type=float, default=0, help="Furigana Filter Sensitivity for OCR (default: 0)")
+    parser.add_argument("--manual_ocr_hotkey", type=str, default="ctrl+shift+g", help="Hotkey for manual OCR (default: ctrl+shift+g)")
 
     args = parser.parse_args()
 
@@ -425,9 +445,11 @@ if __name__ == "__main__":
     ssonly = args.ssonly
     ss_clipboard = args.clipboard
     window_name = args.window
-    logger.info(f"Received arguments: ocr1={ocr1}, ocr2={ocr2}, twopassocr={twopassocr}")
+    furigana_filter_sensitivity = args.furigana_filter_sensitivity
+    ss_hotkey = args.manual_ocr_hotkey.lower()
+
+    logger.info(f"Received arguments: {vars(args)}")
     # set_force_stable_hotkey()
-    set_dpi_awareness()
     ocr_config = None
     if not ssonly:
         ocr_config: OCRConfig = get_ocr_config(window=window_name)
@@ -443,6 +465,7 @@ if __name__ == "__main__":
                     logger.error(f"Window '{ocr_config.window}' not found within 30 seconds.")
                     sys.exit(1)
             logger.info(f"Starting OCR with configuration: Window: {ocr_config.window}, Rectangles: {ocr_config.rectangles}, Engine 1: {ocr1}, Engine 2: {ocr2}, Two-pass OCR: {twopassocr}")
+    set_dpi_awareness()
     if ssonly or ocr_config:
         rectangles = ocr_config.rectangles if ocr_config and ocr_config.rectangles else []
         oneocr_threads = []
@@ -453,7 +476,7 @@ if __name__ == "__main__":
             worker_thread.start()
         websocket_server_thread = WebsocketServerThread(read=True)
         websocket_server_thread.start()
-        add_ss_hotkey()
+        add_ss_hotkey(ss_hotkey)
         try:
             while not done:
                 time.sleep(1)

GameSentenceMiner/owocr/owocr/__init__.py

@@ -1 +1 @@
-from owocr.ocr import *
+from GameSentenceMiner.owocr.owocr.ocr import *

GameSentenceMiner/owocr/owocr/ocr.py

@@ -17,6 +17,8 @@ from google.generativeai import GenerationConfig
 from loguru import logger
 import requests
 
+from GameSentenceMiner.util.configuration import get_app_directory, get_temporary_directory
+
 try:
     from manga_ocr import MangaOcr as MOCR
 except ImportError:
@@ -73,9 +75,10 @@ except ImportError:
 
 try:
     import betterproto
-    from .lens_betterproto import *
+    from GameSentenceMiner.owocr.owocr.lens_betterproto import *
     import random
 except ImportError:
+    print('Google Lens not available, please install betterproto package!')
     pass
 
 try:
@@ -174,7 +177,7 @@ class MangaOcr:
             self.available = True
             logger.info('Manga OCR ready')
 
-    def __call__(self, img):
+    def __call__(self, img, furigana_filter_sensitivity=0):
         img = input_to_pil_image(img)
         if not img:
             return (False, 'Invalid image provided')
@@ -204,7 +207,7 @@ class GoogleVision:
             except:
                 logger.warning('Error parsing Google credentials, Google Vision will not work!')
 
-    def __call__(self, img):
+    def __call__(self, img, furigana_filter_sensitivity=0):
         img = input_to_pil_image(img)
         if not img:
             return (False, 'Invalid image provided')
@@ -234,13 +237,14 @@ class GoogleLens:
     available = False
 
     def __init__(self):
+        self.kana_kanji_regex = re.compile(r'[\u3041-\u3096\u30A1-\u30FA\u4E00-\u9FFF]')
         if 'betterproto' not in sys.modules:
             logger.warning('betterproto not available, Google Lens will not work!')
         else:
             self.available = True
             logger.info('Google Lens ready')
 
-    def __call__(self, img):
+    def __call__(self, img, furigana_filter_sensitivity=0):
         img = input_to_pil_image(img)
         if not img:
             return (False, 'Invalid image provided')
@@ -269,7 +273,7 @@ class GoogleLens:
         image_data = self._preprocess(img)
         request.objects_request.image_data.payload.image_bytes = image_data[0]
         request.objects_request.image_data.image_metadata.width = image_data[1]
-        request.objects_request.image_data.image_metadata.height = image_data[2] 
+        request.objects_request.image_data.image_metadata.height = image_data[2]
 
         payload = request.SerializeToString()
 
@@ -299,15 +303,59 @@ class GoogleLens:
         response_proto = LensOverlayServerResponse().FromString(res.content)
         response_dict = response_proto.to_dict(betterproto.Casing.SNAKE)
 
+        # with open(os.path.join(get_temporary_directory(), 'glens_response.json'), 'w', encoding='utf-8') as f:
+        #     json.dump(response_dict, f, indent=4, ensure_ascii=False)
         res = ''
         text = response_dict['objects_response']['text']
-        if 'text_layout' in text:
-            paragraphs = text['text_layout']['paragraphs']
-            for paragraph in paragraphs:
-                for line in paragraph['lines']:
-                    for word in line['words']:
-                        res += word['plain_text'] + word['text_separator']
-                res += '\n'
+        if furigana_filter_sensitivity > 0:
+            if 'text_layout' in text:
+                for paragraph in text['text_layout']['paragraphs']:
+                    for line in paragraph['lines']:
+                        if furigana_filter_sensitivity < line['geometry']['bounding_box']['width'] * img.width and furigana_filter_sensitivity < line['geometry']['bounding_box']['height'] * img.height:
+                            for word in line['words']:
+                                res += word['plain_text'] + word['text_separator']
+                        else:
+                            continue
+                        res += '\n'
+
+            # widths = []
+            # heights = []
+            # if 'text_layout' in text:
+            #     paragraphs = text['text_layout']['paragraphs']
+            #     for paragraph in paragraphs:
+            #         for line in paragraph['lines']:
+            #             for word in line['words']:
+            #                 if self.kana_kanji_regex.search(word['plain_text']) is None:
+            #                     continue
+            #                 widths.append(word['geometry']['bounding_box']['width'])
+            #                 heights.append(word['geometry']['bounding_box']['height'])
+            #
+            # max_width = max(sorted(widths)[:-max(1, len(widths) // 10)]) if len(widths) > 1 else 0
+            # max_height = max(sorted(heights)[:-max(1, len(heights) // 10)]) if len(heights) > 1 else 0
+            #
+            # required_width = max_width * furigana_filter_sensitivity
+            # required_height = max_height * furigana_filter_sensitivity
+            #
+            # if 'text_layout' in text:
+            #     paragraphs = text['text_layout']['paragraphs']
+            #     for paragraph in paragraphs:
+            #         for line in paragraph['lines']:
+            #             if furigana_filter_sensitivity == 0 or line['geometry']['bounding_box']['width'] > required_width or line['geometry']['bounding_box']['height'] > required_height:
+            #                 for word in line['words']:
+            #                         res += word['plain_text'] + word['text_separator']
+            #             else:
+            #                 continue
+            #         res += '\n'
+        else:
+            if 'text_layout' in text:
+                paragraphs = text['text_layout']['paragraphs']
+                for paragraph in paragraphs:
+                    for line in paragraph['lines']:
+                        for word in line['words']:
+                                res += word['plain_text'] + word['text_separator']
+                        else:
+                            continue
+                    res += '\n'
 
         x = (True, res)
 
@@ -339,7 +387,7 @@ class GoogleLensWeb:
             self.available = True
             logger.info('Google Lens (web) ready')
 
-    def __call__(self, img):
+    def __call__(self, img, furigana_filter_sensitivity=0):
         img = input_to_pil_image(img)
         if not img:
             return (False, 'Invalid image provided')
@@ -432,7 +480,7 @@ class Bing:
         self.available = True
         logger.info('Bing ready')
 
-    def __call__(self, img):
+    def __call__(self, img, furigana_filter_sensitivity=0):
         img = input_to_pil_image(img)
         if not img:
             return (False, 'Invalid image provided')
@@ -568,7 +616,7 @@ class AppleVision:
             self.available = True
             logger.info('Apple Vision ready')
 
-    def __call__(self, img):
+    def __call__(self, img, furigana_filter_sensitivity=0):
         img = input_to_pil_image(img)
         if not img:
             return (False, 'Invalid image provided')
@@ -647,7 +695,7 @@ class AppleLiveText:
             self.available = True
             logger.info('Apple Live Text ready')
 
-    def __call__(self, img):
+    def __call__(self, img, furigana_filter_sensitivity=0):
         img = input_to_pil_image(img)
         if not img:
             return (False, 'Invalid image provided')
@@ -704,7 +752,7 @@ class WinRTOCR:
             except:
                 logger.warning('Error reading URL from config, WinRT OCR will not work!')
 
-    def __call__(self, img):
+    def __call__(self, img, furigana_filter_sensitivity=0):
         img = input_to_pil_image(img)
         if not img:
             return (False, 'Invalid image provided')
@@ -727,6 +775,7 @@ class WinRTOCR:
 
         x = (True, res)
 
+
         # img.close()
         return x
 
@@ -740,6 +789,7 @@ class OneOCR:
     available = False
 
     def __init__(self, config={}):
+        self.kana_kanji_regex = re.compile(r'[\u3041-\u3096\u30A1-\u30FA\u4E00-\u9FFF]')
         if sys.platform == 'win32':
             if int(platform.release()) < 10:
                 logger.warning('OneOCR is not supported on Windows older than 10!')
@@ -761,7 +811,7 @@ class OneOCR:
             except:
                 logger.warning('Error reading URL from config, OneOCR will not work!')
 
-    def __call__(self, img):
+    def __call__(self, img, furigana_filter_sensitivity=0):
         img = input_to_pil_image(img)
         if img.width < 51 or img.height < 51:
             new_width = max(img.width, 51)
@@ -782,7 +832,60 @@ class OneOCR:
                 if x_coords and y_coords:
                     crop_coords = (min(x_coords) - 5, min(y_coords) - 5, max(x_coords) + 5, max(y_coords) + 5)
 
-                res = ocr_resp['text']
+                # with open(os.path.join(get_temporary_directory(), 'oneocr_response.json'), 'w',
+                #           encoding='utf-8') as f:
+                #     json.dump(ocr_resp, f, indent=4, ensure_ascii=False)
+                res = ''
+                if furigana_filter_sensitivity > 0:
+                    for line in ocr_resp['lines']:
+                        if self.kana_kanji_regex.search(line['text']) is None:
+                            continue
+                        x1, x2, x3, x4 = line['bounding_rect']['x1'], line['bounding_rect']['x2'], \
+                            line['bounding_rect']['x3'], line['bounding_rect']['x4']
+                        y1, y2, y3, y4 = line['bounding_rect']['y1'], line['bounding_rect']['y2'], \
+                            line['bounding_rect']['y3'], line['bounding_rect']['y4']
+                        width = max(x2 - x1, x3 - x4)
+                        height = max(y3 - y1, y4 - y2)
+                        if width > furigana_filter_sensitivity and height > furigana_filter_sensitivity:
+                            res += line['text']
+                        else:
+                            continue
+                        res += '\n'
+                    # widths, heights = [], []
+                    # for line in ocr_resp['lines']:
+                    #     for word in line['words']:
+                    #         if self.kana_kanji_regex.search(word['text']) is None:
+                    #             continue
+                    #         # x1, x2, x3, x4 = line['bounding_rect']['x1'], line['bounding_rect']['x2'], line['bounding_rect']['x3'], line['bounding_rect']['x4']
+                    #         # y1, y2, y3, y4 = line['bounding_rect']['y1'], line['bounding_rect']['y2'], line['bounding_rect']['y3'], line['bounding_rect']['y4']
+                    #         x1, x2, x3, x4 = word['bounding_rect']['x1'], word['bounding_rect']['x2'], \
+                    #         word['bounding_rect']['x3'], word['bounding_rect']['x4']
+                    #         y1, y2, y3, y4 = word['bounding_rect']['y1'], word['bounding_rect']['y2'], \
+                    #         word['bounding_rect']['y3'], word['bounding_rect']['y4']
+                    #         widths.append(max(x2 - x1, x3 - x4))
+                    #         heights.append(max(y2 - y1, y3 - y4))
+                    #
+                    #
+                    # max_width = max(sorted(widths)[:-max(1, len(widths) // 10)]) if len(widths) > 1 else 0
+                    # max_height = max(sorted(heights)[:-max(1, len(heights) // 10)]) if len(heights) > 1 else 0
+                    #
+                    # required_width = max_width * furigana_filter_sensitivity
+                    # required_height = max_height * furigana_filter_sensitivity
+                    # for line in ocr_resp['lines']:
+                    #     for word in line['words']:
+                    #         x1, x2, x3, x4 = word['bounding_rect']['x1'], word['bounding_rect']['x2'], \
+                    #         word['bounding_rect']['x3'], word['bounding_rect']['x4']
+                    #         y1, y2, y3, y4 = word['bounding_rect']['y1'], word['bounding_rect']['y2'], \
+                    #         word['bounding_rect']['y3'], word['bounding_rect']['y4']
+                    #         width = max(x2 - x1, x3 - x4)
+                    #         height = max(y2 - y1, y3 - y4)
+                    #         if furigana_filter_sensitivity == 0 or width > required_width or height > required_height:
+                    #             res += word['text']
+                    #         else:
+                    #             continue
+                    #     res += '\n'
+                else:
+                    res = ocr_resp['text']
             except RuntimeError as e:
                 return (False, e)
         else:
@@ -825,7 +928,7 @@ class AzureImageAnalysis:
             except:
                 logger.warning('Error parsing Azure credentials, Azure Image Analysis will not work!')
 
-    def __call__(self, img):
+    def __call__(self, img, furigana_filter_sensitivity=0):
         img = input_to_pil_image(img)
         if not img:
             return (False, 'Invalid image provided')
@@ -877,7 +980,7 @@ class EasyOCR:
             self.available = True
             logger.info('EasyOCR ready')
 
-    def __call__(self, img):
+    def __call__(self, img, furigana_filter_sensitivity=0):
         img = input_to_pil_image(img)
         if not img:
             return (False, 'Invalid image provided')
@@ -923,7 +1026,7 @@ class RapidOCR:
             self.available = True
             logger.info('RapidOCR ready')
 
-    def __call__(self, img):
+    def __call__(self, img, furigana_filter_sensitivity=0):
         img = input_to_pil_image(img)
         if not img:
             return (False, 'Invalid image provided')
@@ -957,7 +1060,7 @@ class OCRSpace:
         except:
             logger.warning('Error reading API key from config, OCRSpace will not work!')
 
-    def __call__(self, img):
+    def __call__(self, img, furigana_filter_sensitivity=0):
         img = input_to_pil_image(img)
         if not img:
             return (False, 'Invalid image provided')
@@ -1027,7 +1130,7 @@ class GeminiOCR:
         except Exception as e:
             logger.error(f'Error configuring google-generativeai: {e}')
 
-    def __call__(self, img):
+    def __call__(self, img, furigana_filter_sensitivity=0):
         if not self.available:
             return (False, 'GeminiOCR is not available due to missing API key or configuration error.')
 
@@ -1089,7 +1192,7 @@ class GroqOCR:
         except Exception as e:
             logger.error(f'Error initializing Groq client: {e}')
 
-    def __call__(self, img):
+    def __call__(self, img, furigana_filter_sensitivity=0):
         if not self.available:
             return (False, 'GroqOCR is not available due to missing API key or configuration error.')
 
@@ -1139,3 +1242,61 @@ class GroqOCR:
 
     def _preprocess(self, img):
         return base64.b64encode(pil_image_to_bytes(img, png_compression=1)).decode('utf-8')
+
+# class LocalOCR:
+#     name = 'local_ocr'
+#     readable_name = 'Local OCR'
+#     key = '-'
+#     available = False
+#
+#     def __init__(self):
+#         self.requests_session = requests.Session()
+#         self.available = True
+#         # logger.info('Local OCR ready') # Uncomment if you have a logger defined
+#
+#     def __call__(self, img, furigana_filter_sensitivity=0):
+#         if not isinstance(img, Image.Image):
+#             try:
+#                 img = Image.open(io.BytesIO(img))
+#             except Exception:
+#                 return (False, 'Invalid image provided')
+#
+#         img = input_to_pil_image(img)
+#
+#         img_base64 = self._preprocess(img)
+#         if not img_base64:
+#             return (False, 'Image preprocessing failed (e.g., too big after resize)!')
+#
+#         api_url = 'http://localhost:2333/api/ocr'
+#         # Send as JSON with base64 encoded image
+#         json_data = {
+#             'image': img_base64
+#         }
+#
+#         try:
+#             res = self.requests_session.post(api_url, json=json_data, timeout=5)
+#             print(res.content)
+#         except requests.exceptions.Timeout:
+#             return (False, 'Request timeout!')
+#         except requests.exceptions.ConnectionError:
+#             return (False, 'Connection error!')
+#
+#         if res.status_code != 200:
+#             return (False, f'Error: {res.status_code} - {res.text}')
+#
+#         try:
+#             data = res.json()
+#             # Assuming the local OCR service returns text in a 'text' key
+#             extracted_text = data.get('text', '')
+#             return (True, extracted_text)
+#         except requests.exceptions.JSONDecodeError:
+#             return (False, 'Invalid JSON response from OCR service!')
+#
+#     def _preprocess(self, img):
+#         return base64.b64encode(pil_image_to_bytes(img, png_compression=1)).decode('utf-8')
+
+# lens = GoogleLens()
+#
+# res, text = lens(Image.open('test_furigana.png'), furigana_filter_sensitivity=.6)  # Example usage
+#
+# print(text)

GameSentenceMiner/owocr/owocr/run.py

@@ -315,7 +315,6 @@ class TextFiltering:
         self.kana_kanji_regex = re.compile(r'[\u3041-\u3096\u30A1-\u30FA\u4E00-\u9FFF]')
         self.chinese_common_regex = re.compile(r'[\u4E00-\u9FFF]')
         self.english_regex = re.compile(r'[a-zA-Z0-9.,!?;:"\'()\[\]{}]')
-        self.kana_kanji_regex = re.compile(r'[\u3041-\u3096\u30A1-\u30FA\u4E00-\u9FFF]')
         self.chinese_common_regex = re.compile(r'[\u4E00-\u9FFF]')
         self.english_regex = re.compile(r'[a-zA-Z0-9.,!?;:"\'()\[\]{}]')
         self.korean_regex = re.compile(r'[\uAC00-\uD7AF]')
@@ -880,7 +879,7 @@ def on_window_minimized(minimized):
     screencapture_window_visible = not minimized
 
 
-def process_and_write_results(img_or_path, write_to=None, last_result=None, filtering=None, notify=None, engine=None, ocr_start_time=None):
+def process_and_write_results(img_or_path, write_to=None, last_result=None, filtering=None, notify=None, engine=None, ocr_start_time=None, furigana_filter_sensitivity=0):
     global engine_index
     if auto_pause_handler:
         auto_pause_handler.stop()
@@ -896,7 +895,7 @@ def process_and_write_results(img_or_path, write_to=None, last_result=None, filt
     engine_color = config.get_general('engine_color')
 
     start_time = time.time()
-    result = engine_instance(img_or_path)
+    result = engine_instance(img_or_path, furigana_filter_sensitivity)
     res, text, crop_coords = (*result, None)[:3]
 
 
@@ -909,7 +908,7 @@ def process_and_write_results(img_or_path, write_to=None, last_result=None, filt
                     last_result = []
                 break
         start_time = time.time()
-        result = engine_instance(img_or_path)
+        result = engine_instance(img_or_path, furigana_filter_sensitivity)
         res, text, crop_coords = (*result, None)[:3]
 
     end_time = time.time()
@@ -989,6 +988,7 @@ def run(read_from=None,
         ocr1=None,
         ocr2=None,
         gsm_ocr_config=None,
+        furigana_filter_sensitivity=None,
         ):
     """
     Japanese OCR client
@@ -1243,7 +1243,7 @@ def run(read_from=None,
             break
         elif img:
             if filter_img:
-                res, _ = process_and_write_results(img, write_to, last_result, filtering, notify, ocr_start_time=ocr_start_time)
+                res, _ = process_and_write_results(img, write_to, last_result, filtering, notify, ocr_start_time=ocr_start_time, furigana_filter_sensitivity=furigana_filter_sensitivity)
                 if res:
                     last_result = (res, engine_index)
             else:

GameSentenceMiner/util/configuration.py

@@ -207,6 +207,8 @@ class VAD:
     trim_beginning: bool = False
     beginning_offset: float = -0.25
     add_audio_on_no_results: bool = False
+    cut_and_splice_segments: bool = False
+    splice_padding: float = 0.1
 
     def is_silero(self):
         return self.selected_vad_model == SILERO or self.backup_vad_model == SILERO

GameSentenceMiner/util/ffmpeg.py

@@ -7,6 +7,7 @@ from GameSentenceMiner import obs
 from GameSentenceMiner.util.gsm_utils import make_unique_file_name, get_file_modification_time
 from GameSentenceMiner.util import configuration
 from GameSentenceMiner.util.configuration import *
+from GameSentenceMiner.util.model import VADResult
 from GameSentenceMiner.util.text_log import initial_time
 
 
@@ -18,6 +19,13 @@ def get_ffprobe_path():
 
 ffmpeg_base_command_list = [get_ffmpeg_path(), "-hide_banner", "-loglevel", "error", '-nostdin']
 
+supported_formats = {
+    'opus': 'libopus',
+    'mp3': 'libmp3lame',
+    'ogg': 'libvorbis',
+    'aac': 'aac',
+    'm4a': 'aac',
+}
 
 def call_frame_extractor(video_path, timestamp):
     """
@@ -247,14 +255,6 @@ def get_audio_codec(video_path):
 
 
 def get_audio_and_trim(video_path, game_line, next_line_time, anki_card_creation_time):
-    supported_formats = {
-        'opus': 'libopus',
-        'mp3': 'libmp3lame',
-        'ogg': 'libvorbis',
-        'aac': 'aac',
-        'm4a': 'aac',
-    }
-
     codec = get_audio_codec(video_path)
 
     if codec == get_config().audio.extension:
@@ -528,23 +528,59 @@ def convert_audio_to_mp3(input_audio):
 
 
 # Trim the audio using FFmpeg based on detected speech timestamps
-def trim_audio(input_audio, start_time, end_time, output_audio):
+def trim_audio(input_audio, start_time, end_time, output_audio, trim_beginning=False, fade_in_duration=0.05,
+               fade_out_duration=0.05):
     command = ffmpeg_base_command_list.copy()
 
     command.extend(['-i', input_audio])
 
-    if get_config().vad.trim_beginning and start_time > 0:
+    if trim_beginning and start_time > 0:
         logger.debug(f"trimming beginning to {start_time}")
         command.extend(['-ss', f"{start_time:.2f}"])
 
+    fade_filter = []
+    if fade_in_duration > 0:
+        fade_filter.append(f'afade=t=in:d={fade_in_duration}')
+    if fade_out_duration > 0:
+        fade_filter.append(f'afade=t=out:st={end_time - fade_out_duration:.2f}:d={fade_out_duration}')
+    #     fade_filter.append(f'afade=t=out:d={fade_out_duration}')
+
     command.extend([
         '-to', f"{end_time:.2f}",
-        '-c', 'copy',
-        output_audio
     ])
 
+    if fade_filter:
+        command.extend(['-af', f'afade=t=in:d={fade_in_duration},afade=t=out:st={end_time - fade_out_duration:.2f}:d={fade_out_duration}'])
+        command.extend(['-c:a', supported_formats[get_config().audio.extension]])
+    else:
+        command.extend(['-c', 'copy'])
+
+    command.append(output_audio)
+
     logger.debug(" ".join(command))
 
+    try:
+        subprocess.run(command, check=True)
+    except subprocess.CalledProcessError as e:
+        logger.error(f"FFmpeg command failed with error: {e}")
+        logger.error(f"Command: {' '.join(command)}")
+    except FileNotFoundError:
+        logger.error("FFmpeg not found. Please ensure FFmpeg is installed and in your PATH.")
+
+
+def combine_audio_files(audio_files, output_file):
+    if not audio_files:
+        logger.error("No audio files provided for combination.")
+        return
+
+    command = ffmpeg_base_command_list + [
+        "-i", "concat:" + "|".join(audio_files),
+        "-c", "copy",
+        output_file
+    ]
+
+    logger.debug("Combining audio files with command: " + " ".join(command))
+
     subprocess.run(command)
 
 

GameSentenceMiner/util/model.py

@@ -175,3 +175,25 @@ class AnkiCard:
                     return True, key
 
         return False, None
+
+
+class VADResult:
+    def __init__(self, success: bool, start: float, end: float, model: str, segments: list = None, output_audio: str = None):
+        self.success = success
+        self.start = start
+        self.end = end
+        self.model = model
+        self.segments = segments if segments is not None else []
+        self.output_audio = None
+
+    def __repr__(self):
+        return f"VADResult(success={self.success}, start={self.start}, end={self.end}, model={self.model}, output_audio={self.output_audio})"
+
+    def trim_successful_string(self):
+        if self.success:
+            if get_config().vad.trim_beginning:
+                return f"Trimmed audio from {self.start:.2f} to {self.end:.2f} seconds using {self.model}."
+            else:
+                return f"Trimmed end of audio to {self.end:.2f} seconds using {self.model}."
+        else:
+            return f"Failed to trim audio using {self.model}."

GameSentenceMiner/vad.py

@@ -1,31 +1,15 @@
 import subprocess
 import tempfile
+import time
 import warnings
 from abc import abstractmethod, ABC
 
 from GameSentenceMiner.util import configuration, ffmpeg
 from GameSentenceMiner.util.configuration import *
 from GameSentenceMiner.util.ffmpeg import get_ffprobe_path
+from GameSentenceMiner.util.gsm_utils import make_unique_file_name, run_new_thread
+from GameSentenceMiner.util.model import VADResult
 
-class VADResult:
-    def __init__(self, success: bool, start: float, end: float, model: str, output_audio: str = None):
-        self.success = success
-        self.start = start
-        self.end = end
-        self.model = model
-        self.output_audio = None
-
-    def __repr__(self):
-        return f"VADResult(success={self.success}, start={self.start}, end={self.end}, model={self.model}, output_audio={self.output_audio})"
-
-    def trim_successful_string(self):
-        if self.success:
-            if get_config().vad.trim_beginning:
-                return f"Trimmed audio from {self.start:.2f} to {self.end:.2f} seconds using {self.model}."
-            else:
-                return f"Trimmed end of audio to {self.end:.2f} seconds using {self.model}."
-        else:
-            return f"Failed to trim audio using {self.model}."
 
 class VADSystem:
     def __init__(self):
@@ -108,6 +92,29 @@ class VADProcessor(ABC):
         )
         return float(result.stdout.strip())
 
+    @staticmethod
+    def extract_audio_and_combine_segments(input_audio, segments, output_audio, padding=0.2):
+        files = []
+        ffmpeg_threads = []
+        logger.info(f"Extracting {len(segments)} segments from {input_audio} with padding {padding} seconds.")
+        for segment in segments:
+            logger.info(segment)
+            temp_file = make_unique_file_name(os.path.join(get_temporary_directory(), "segment." + get_config().audio.extension))
+            files.append(temp_file)
+            ffmpeg_threads.append(run_new_thread(lambda: ffmpeg.trim_audio(input_audio, segment['start'] - padding, segment['end'] + padding, temp_file, trim_beginning=True)))
+            time.sleep(0.1)  # Small delay to ensure unique file names
+
+        for thread in ffmpeg_threads:
+            thread.join()
+
+        if len(files) > 1:
+            ffmpeg.combine_audio_files(files, output_audio)
+            # for file in files:
+            #     os.remove(file)
+        else:
+            shutil.move(files[0], output_audio)
+
+
     def process_audio(self, input_audio, output_audio, game_line):
         voice_activity = self._detect_voice_activity(input_audio)
 
@@ -124,8 +131,11 @@ class VADProcessor(ABC):
             if 0 > audio_length - voice_activity[-1]['start'] + get_config().audio.beginning_offset:
                 end_time = voice_activity[-2]['end']
 
-        ffmpeg.trim_audio(input_audio, start_time + get_config().vad.beginning_offset, end_time + get_config().audio.end_offset, output_audio)
-        return VADResult(True, start_time + get_config().vad.beginning_offset, end_time + get_config().audio.end_offset, self.vad_system_name, output_audio)
+        if get_config().vad.cut_and_splice_segments:
+            self.extract_audio_and_combine_segments(input_audio, voice_activity, output_audio, padding=get_config().vad.splice_padding)
+        else:
+            ffmpeg.trim_audio(input_audio, start_time + get_config().vad.beginning_offset, end_time + get_config().audio.end_offset, output_audio, trim_beginning=get_config().vad.trim_beginning, fade_in_duration=0, fade_out_duration=0)
+        return VADResult(True, start_time + get_config().vad.beginning_offset, end_time + get_config().audio.end_offset, self.vad_system_name, voice_activity, output_audio)
 
 class SileroVADProcessor(VADProcessor):
     def __init__(self):
@@ -176,17 +186,23 @@ class WhisperVADProcessor(VADProcessor):
         # Process the segments to extract tokens, timestamps, and confidence
         for segment in result.segments:
             logger.debug(segment.to_dict())
-            for word in segment.words:
-                logger.debug(word.to_dict())
-                confidence = word.probability
-                if confidence > .1:
-                    logger.debug(word)
-                    voice_activity.append({
-                        'text': word.word,
-                        'start': word.start,
-                        'end': word.end,
-                        'confidence': word.probability
-                    })
+            voice_activity.append({
+                'text': segment.text,
+                'start': segment.start,
+                'end': segment.end,
+                'confidence': segment.avg_logprob
+            })
+            # for word in segment.words:
+            #     logger.debug(word.to_dict())
+            #     confidence = word.probability
+            #     if confidence > .1:
+            #         logger.debug(word)
+            #         voice_activity.append({
+            #             'text': word.word,
+            #             'start': word.start,
+            #             'end': word.end,
+            #             'confidence': word.probability
+            #         })
 
         # Analyze the detected words to decide whether to use the audio
         should_use = False
@@ -342,4 +358,10 @@ class GroqVADProcessor(VADProcessor):
             logger.error(f"Error detecting voice with Groq: {e}")
             return [], 0.0
 
-vad_processor = VADSystem()
+vad_processor = VADSystem()
+
+# test_vad = SileroVADProcessor()
+#
+# if os.path.exists(r"C:\Users\Beangate\GSM\Electron App\test\after_splice.opus"):
+#     os.remove(r"C:\Users\Beangate\GSM\Electron App\test\after_splice.opus")
+# test_vad.process_audio(r"C:\Users\Beangate\GSM\Electron App\test\before_splice.opus", r"C:\Users\Beangate\GSM\Electron App\test\after_splice.opus", None)

{gamesentenceminer-2.9.22.dist-info → gamesentenceminer-2.9.24.dist-info}/METADATA

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

{gamesentenceminer-2.9.22.dist-info → gamesentenceminer-2.9.24.dist-info}/RECORD

@@ -1,10 +1,10 @@
 GameSentenceMiner/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 GameSentenceMiner/anki.py,sha256=hNHBIoJRrsWIhLe0sehOYPXTWzPREeXl4gYCPHUCaiE,16331
-GameSentenceMiner/config_gui.py,sha256=iAOLD47sQW67kzBcZKSQ0Dwctc1ngZK1lwSVIaLpQPI,83559
+GameSentenceMiner/config_gui.py,sha256=xQXFrDfsjbWxuX0PwGn2jjv0mfRZEZ_MdUU3iMASiB4,84788
 GameSentenceMiner/gametext.py,sha256=nAwGMQSrmc6sUAw-OAURK2n6MG5Ecm6psJ7YF9q5KTA,6623
-GameSentenceMiner/gsm.py,sha256=b3hOjaPGHn_3_G_0Ro43bX84oLX8SltfKEX_LtujX0U,24127
+GameSentenceMiner/gsm.py,sha256=oM4l0UP6_h66AVEZqdIShs264A3LEgmSDTlp-gp048o,24167
 GameSentenceMiner/obs.py,sha256=YG8LwBf9BTsGbROm_Uq6LhFDSrbf3jgogp78rBbJq94,14728
-GameSentenceMiner/vad.py,sha256=TbP3NVdjfB1TFJeB0QpOXZysgo_UHHKLdx95pYmM0JI,14902
+GameSentenceMiner/vad.py,sha256=kWJ6c3v0iJInIiwU9ANYQvweqGi3PpeN_eegJLybfIM,16148
 GameSentenceMiner/ai/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 GameSentenceMiner/ai/ai_prompting.py,sha256=0jBAnngNwmc3dqJiVWe_QRy4Syr-muV-ML2rq0FiUtU,10215
 GameSentenceMiner/assets/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -18,22 +18,22 @@ GameSentenceMiner/assets/pickaxe.png,sha256=VfIGyXyIZdzEnVcc4PmG3wszPMO1W4KCT7Q_
 GameSentenceMiner/ocr/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 GameSentenceMiner/ocr/gsm_ocr_config.py,sha256=fEQ2o2NXksGRHpueO8c4TfAp75GEdAtAr1ngTFOsdpg,2257
 GameSentenceMiner/ocr/ocrconfig.py,sha256=_tY8mjnzHMJrLS8E5pHqYXZjMuLoGKYgJwdhYgN-ny4,6466
-GameSentenceMiner/ocr/owocr_area_selector.py,sha256=71trzwz9Isyy-kN9mLS8vIX-giC8Lkin4slLXaxudac,47162
-GameSentenceMiner/ocr/owocr_helper.py,sha256=7XpuLT8ezdrEXiODyXgh1X7iNbW7OI-QrSgEmTBMaqQ,19505
+GameSentenceMiner/ocr/owocr_area_selector.py,sha256=BXjHh1-NWwDeQ623MkwdR2hu6HBQAk5stpbiLE2WX_4,47289
+GameSentenceMiner/ocr/owocr_helper.py,sha256=idjVB8Ln9PwNUFZMOtRkq7wAhbteU7-haRM7Cf_wmY4,20979
 GameSentenceMiner/ocr/ss_picker.py,sha256=Ck2K9JliXhY_7a7nS0BVsoAmzwPFFtsW_TxHCcfxT00,4274
-GameSentenceMiner/owocr/owocr/__init__.py,sha256=opjBOyGGyEqZCE6YdZPnyt7nVfiwyELHsXA0jAsjm14,25
+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=vZR3du1fGg5-3cmPvYKTO4PFk7Lxyf6-BrIy7CmeG0I,42578
-GameSentenceMiner/owocr/owocr/run.py,sha256=U6VIfCvsNPADG3twhp4SQVX1xhihSAGGrBnQj2x0C2c,54964
+GameSentenceMiner/owocr/owocr/ocr.py,sha256=uEv0Pjvq7n6XJOkV4i_EiR0wxXqzi2EVpWsK2-i3SXs,51932
+GameSentenceMiner/owocr/owocr/run.py,sha256=bNh9nF0tzFa7BuW-ixcipyf6vTrNyaNwtgG6W4a-uIo,55063
 GameSentenceMiner/owocr/owocr/screen_coordinate_picker.py,sha256=Na6XStbQBtpQUSdbN3QhEswtKuU1JjReFk_K8t5ezQE,3395
 GameSentenceMiner/util/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-GameSentenceMiner/util/configuration.py,sha256=Wgr1UAf_JoXBlp9h_f3-d2DAmIWnR1FtCmMX6mCfMNM,27461
+GameSentenceMiner/util/configuration.py,sha256=TAdd-aLMCMvpu7OS1Y5brKQC4svcK29J94nvrEb4Ue4,27535
 GameSentenceMiner/util/electron_config.py,sha256=3VmIrcXhC-wIMMc4uqV85NrNenRl4ZUbnQfSjWEwuig,9852
-GameSentenceMiner/util/ffmpeg.py,sha256=7ZrgnXRa67IH7EYrc93pagkH_2rsO8-QBCDVrMWSg-Y,23398
+GameSentenceMiner/util/ffmpeg.py,sha256=iU0AuVikKrgJ1fvtAHAgm0j31r1GQtzg2h_1nzUbGS8,24802
 GameSentenceMiner/util/gsm_utils.py,sha256=Z_Lu4jSIfUaM2VljIJXQkSJD0UsyJ5hMB46H2NS0gZo,8819
-GameSentenceMiner/util/model.py,sha256=iDtLTfR6D-ZC0gCiDqYno6-gA6Z07PZTM4B5MAA6xZI,5704
+GameSentenceMiner/util/model.py,sha256=ROH-uO55im7H4COonyyPZQ8l9-8EPtyOk7l_DNEonbk,6630
 GameSentenceMiner/util/notification.py,sha256=0OnEYjn3DUEZ6c6OtPjdVZe-DG-QSoMAl9fetjjCvNU,3874
 GameSentenceMiner/util/package.py,sha256=u1ym5z869lw5EHvIviC9h9uH97bzUXSXXA8KIn8rUvk,1157
 GameSentenceMiner/util/ss_selector.py,sha256=oCzmDbpEGvVselF-oDPIrBcQktGIZT0Zt16uDLDAHMQ,4493
@@ -61,9 +61,9 @@ GameSentenceMiner/web/templates/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm
 GameSentenceMiner/web/templates/index.html,sha256=HZKiIjiGJV8PGQ9T2aLDUNSfJn71qOwbYCjbRuSIjpY,213583
 GameSentenceMiner/web/templates/text_replacements.html,sha256=tV5c8mCaWSt_vKuUpbdbLAzXZ3ATZeDvQ9PnnAfqY0M,8598
 GameSentenceMiner/web/templates/utility.html,sha256=3flZinKNqUJ7pvrZk6xu__v67z44rXnaK7UTZ303R-8,16946
-gamesentenceminer-2.9.22.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-gamesentenceminer-2.9.22.dist-info/METADATA,sha256=2Tr66qiH5b9rYmJ-KtuEt7Ib65v6SjMSJwBziXFKRxM,7276
-gamesentenceminer-2.9.22.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-gamesentenceminer-2.9.22.dist-info/entry_points.txt,sha256=2APEP25DbfjSxGeHtwBstMH8mulVhLkqF_b9bqzU6vQ,65
-gamesentenceminer-2.9.22.dist-info/top_level.txt,sha256=V1hUY6xVSyUEohb0uDoN4UIE6rUZ_JYx8yMyPGX4PgQ,18
-gamesentenceminer-2.9.22.dist-info/RECORD,,
+gamesentenceminer-2.9.24.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+gamesentenceminer-2.9.24.dist-info/METADATA,sha256=mmAUr_sxdKxY2_Vdt83NkFBqB4LfCdqY6m8ze8-vrqQ,7276
+gamesentenceminer-2.9.24.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+gamesentenceminer-2.9.24.dist-info/entry_points.txt,sha256=2APEP25DbfjSxGeHtwBstMH8mulVhLkqF_b9bqzU6vQ,65
+gamesentenceminer-2.9.24.dist-info/top_level.txt,sha256=V1hUY6xVSyUEohb0uDoN4UIE6rUZ_JYx8yMyPGX4PgQ,18
+gamesentenceminer-2.9.24.dist-info/RECORD,,