GameSentenceMiner 2.7.9__py3-none-any.whl → 2.7.10__py3-none-any.whl

GameSentenceMiner/ffmpeg.py

@@ -52,7 +52,7 @@ def get_screenshot_for_line(video_file, game_line):
     return get_screenshot(video_file, get_screenshot_time(video_file, game_line))
 
 
-def get_screenshot_time(video_path, game_line, default_beginning=False, vad_beginning=None, vad_end=None):
+def get_screenshot_time(video_path, game_line, default_beginning=False, vad_beginning=None, vad_end=None, doing_multi_line=False):
     if game_line:
         line_time = game_line.time
     else:
@@ -68,7 +68,7 @@ def get_screenshot_time(video_path, game_line, default_beginning=False, vad_begi
     screenshot_offset = get_config().screenshot.seconds_after_line
 
     # Calculate screenshot time from the beginning by adding the offset
-    if vad_beginning and vad_end:
+    if vad_beginning and vad_end and not doing_multi_line:
         logger.debug("Using VAD to determine screenshot time")
         screenshot_time_from_beginning = line_timestamp_in_video + vad_end - screenshot_offset
     elif get_config().screenshot.use_new_screenshot_logic:

GameSentenceMiner/gsm.py

@@ -141,7 +141,7 @@ class VideoToAudioHandler(FileSystemEventHandler):
 
                 ss_timing = 1
                 if mined_line and line_cutoff or mined_line and get_config().screenshot.use_beginning_of_line_as_screenshot:
-                    ss_timing = ffmpeg.get_screenshot_time(video_path, mined_line, vad_beginning, vad_end)
+                    ss_timing = ffmpeg.get_screenshot_time(video_path, mined_line, vad_beginning, vad_end, bool(selected_lines))
 
                 if get_config().anki.update_anki and last_note:
                     anki.update_anki_card(last_note, note, audio_path=final_audio_output, video_path=video_path,

GameSentenceMiner/ocr/gsm_ocr_config.py

@@ -23,20 +23,4 @@ class Rectangle:
 class OCRConfig:
     scene: str
     rectangles: List[Rectangle]
-    window: Optional[str] = None
-
-# Example of how you might use from_dict (assuming you have a dictionary called 'data')
-data = {
-    "scene": "CODEVEIN",
-    "window": "CODE VEIN",
-    "rectangles": [
-        {
-            "monitor": {"left": 0, "top": 0, "width": 2560, "height": 1440, "index": 0},
-            "coordinates": [749, 1178, 1100, 147],
-            "is_excluded": False,
-        }
-    ],
-}
-
-config = OCRConfig.from_dict(data)
-print(config)
+    window: Optional[str] = None

GameSentenceMiner/ocr/owocr_area_selector.py

@@ -88,7 +88,7 @@ class ScreenSelector:
                 serializable_rects.append(rect_data)
 
             print(serializable_rects)
-            with open(config_path, 'w') as f:
+            with open(config_path, 'w', encoding="utf-8") as f:
                 json.dump({"scene": sanitize_filename(obs.get_current_scene()), "window": self.window_name, "rectangles": serializable_rects}, f, indent=4)
             print("Rectangles saved.")
             self.result['rectangles'] = self.rectangles.copy()

GameSentenceMiner/ocr/owocr_helper.py

@@ -13,6 +13,7 @@ from tkinter import messagebox
 
 import mss
 import websockets
+from rapidfuzz import fuzz
 from PIL import Image, ImageDraw
 
 from GameSentenceMiner import obs, util
@@ -75,7 +76,7 @@ def get_new_game_cords():
     return coords_list
 
 
-def get_ocr_config():
+def get_ocr_config() -> OCRConfig:
     """Loads and updates screen capture areas from the corresponding JSON file."""
     app_dir = Path.home() / "AppData" / "Roaming" / "GameSentenceMiner"
     ocr_config_dir = app_dir / "ocr_config"
@@ -85,7 +86,7 @@ def get_ocr_config():
     if not config_path.exists():
         raise Exception(f"No config file found at {config_path}.")
     try:
-        with open(config_path, 'r') as f:
+        with open(config_path, 'r', encoding="utf-8") as f:
             config_data = json.load(f)
         if "rectangles" in config_data and isinstance(config_data["rectangles"], list) and all(
                 isinstance(item, list) and len(item) == 4 for item in config_data["rectangles"]):
@@ -120,7 +121,7 @@ def get_ocr_config():
                     })
             new_config_data = {"scene": config_data.get("scene", scene), "window": config_data.get("window", None),
                                "rectangles": new_rectangles}
-            with open(config_path, 'w') as f:
+            with open(config_path, 'w', encoding="utf-8") as f:
                 json.dump(new_config_data, f, indent=4)
             return OCRConfig.from_dict(new_config_data)
         elif "rectangles" in config_data and isinstance(config_data["rectangles"], list) and all(
@@ -206,63 +207,78 @@ class WebsocketServerThread(threading.Thread):
 all_cords = None
 rectangles = None
 
+def do_second_ocr(ocr1_text, rectangle_index, time, img):
+    global twopassocr, ocr2, last_ocr1_results, last_ocr2_results
+    last_result = ([], -1)
+
+    previous_ocr1_text = last_ocr1_results[rectangle_index]
+    if fuzz.ratio(previous_ocr1_text, ocr1_text) >= 80:
+        logger.info("Seems like the same text, not doing 2nd pass")
+    last_ocr1_results[rectangle_index] = ocr1_text
+    try:
+        orig_text, text = run.process_and_write_results(img, None, None, last_result, TextFiltering(),
+                                                        engine=ocr2)
+        previous_ocr2_text = last_ocr2_results[rectangle_index]
+        if fuzz.ratio(previous_ocr2_text, text) >= 80:
+            logger.info("Seems like the same text from previous ocr2 result, not sending")
+            return
+        last_ocr2_results[rectangle_index] = text
+        if get_config().advanced.ocr_sends_to_clipboard:
+            import pyperclip
+            pyperclip.copy(text)
+        websocket_server_thread.send_text(text, time)
+    except json.JSONDecodeError:
+        print("Invalid JSON received.")
+    except Exception as e:
+        logger.exception(e)
+        print(f"Error processing message: {e}")
+
+
+last_oneocr_results_to_check = {}  # Store last OCR result for each rectangle
+last_oneocr_times = {}    # Store last OCR time for each rectangle
+text_stable_start_times = {} # Store the start time when text becomes stable for each rectangle
+TEXT_APPEARENCE_DELAY = get_ocr_scan_rate() * 1000 + 500  # Adjust as needed
 
 def text_callback(text, rectangle_index, time, img=None):
-    global twopassocr, ocr2, last_oneocr_results
+    global twopassocr, ocr2, last_oneocr_results_to_check, last_oneocr_times, text_stable_start_times
+
+    current_time = time if time else datetime.now()
+
+    previous_text = last_oneocr_results_to_check.get(rectangle_index, "")
+
     if not text:
+        if previous_text:
+            if rectangle_index in text_stable_start_times:
+                stable_time = text_stable_start_times[rectangle_index]
+                if twopassocr:
+                    do_second_ocr(previous_text, rectangle_index, time, img)
+                else:
+                    previous_ocr1_text = last_ocr1_results[rectangle_index]
+                    if fuzz.ratio(previous_ocr1_text, text) >= 80:
+                        logger.info("Seems like the same text, not sending")
+                    last_ocr1_results[rectangle_index] = text
+                    websocket_server_thread.send_text(previous_text, stable_time)
+                del text_stable_start_times[rectangle_index]
+            del last_oneocr_results_to_check[rectangle_index]
         return
-    if not twopassocr or not ocr2:
-        websocket_server_thread.send_text(text, time if time else datetime.now())
+
+    if rectangle_index not in last_oneocr_results_to_check:
+        last_oneocr_results_to_check[rectangle_index] = text
+        last_oneocr_times[rectangle_index] = current_time
+        text_stable_start_times[rectangle_index] = current_time
         return
-    with mss.mss() as sct:
-        line_time = time if time else datetime.now()
-        logger.info(f"Received message: {text}, ATTEMPTING LENS OCR")
-        if rectangles:
-            rect_data: Rectangle = rectangles[rectangle_index]
-            cords = rect_data.coordinates
-            i = rectangle_index
-        else:
-            i = 0
-            mon = sct.monitors
-            cords = [mon[1]['left'], mon[1]['top'], mon[1]['width'], mon[1]['height']]
-        similarity = difflib.SequenceMatcher(None, last_oneocr_results[i], text).ratio()
-        if similarity > .8:
-            return
-        logger.debug(f"Similarity for region {i}: {similarity}")
-        last_oneocr_results[i] = text
-        last_result = ([], -1)
-        try:
-            # sct_params = {'left': cords[0], 'top': cords[1], 'width': cords[2], 'height': cords[3]}
-            # sct_img = sct.grab(sct_params)
-            # img = Image.frombytes('RGB', sct_img.size, sct_img.bgra, 'raw', 'BGRX')
-            # img = img.convert("RGBA")
-            # draw = ImageDraw.Draw(img)
-            # excluded_rects = ocr_config.get("excluded_rectangles", [])
-            # if isinstance(excluded_rects, list) and all(
-            #         isinstance(item, list) and len(item) == 4 for item in excluded_rects):
-            #     for exclusion in excluded_rects:
-            #         left, top, right, bottom = exclusion
-            #         draw.rectangle((left, top, right, bottom), fill=(0, 0, 0, 0))
-            # elif isinstance(excluded_rects, list) and all(
-            #         isinstance(item, dict) and "coordinates" in item and isinstance(item["coordinates"], list) and len(
-            #                 item["coordinates"]) == 4 for item in excluded_rects):
-            #     for exclusion in excluded_rects:
-            #         left, top, right, bottom = exclusion["coordinates"]
-            #         draw.rectangle((left, top, right, bottom), fill=(0, 0, 0, 0))
-            orig_text, text = run.process_and_write_results(img, None, None, last_result, TextFiltering(),
-                                                            engine=ocr2)
-            if ":gsm_prefix:" in text:
-                text = text.split(":gsm_prefix:")[1]
-            if get_config().advanced.ocr_sends_to_clipboard:
-                import pyperclip
-                pyperclip.copy(text)
-            websocket_server_thread.send_text(text, line_time)
-        except json.JSONDecodeError:
-            print("Invalid JSON received.")
-        except Exception as e:
-            logger.exception(e)
-            print(f"Error processing message: {e}")
 
+    stable = text_stable_start_times.get(rectangle_index)
+
+    if stable:
+        time_since_stable_ms = int((current_time - stable).total_seconds() * 1000)
+
+        if time_since_stable_ms >= TEXT_APPEARENCE_DELAY:
+            last_oneocr_results_to_check[rectangle_index] = text
+            last_oneocr_times[rectangle_index] = current_time
+    else:
+        last_oneocr_results_to_check[rectangle_index] = text
+        last_oneocr_times[rectangle_index] = current_time
 
 done = False
 
@@ -305,12 +321,15 @@ if __name__ == "__main__":
         twopassocr = False
     else:
         ocr1 = "oneocr"
+        ocr2 = "glens"
+        twopassocr = True
     logger.info(f"Received arguments: ocr1={ocr1}, ocr2={ocr2}, twopassocr={twopassocr}")
     global ocr_config
     ocr_config: OCRConfig = get_ocr_config()
     if ocr_config and ocr_config.rectangles:
         rectangles = ocr_config.rectangles
-        last_oneocr_results = [""] * len(rectangles) if rectangles else [""]
+        last_ocr1_results = [""] * len(rectangles) if rectangles else [""]
+        last_ocr2_results = [""] * len(rectangles) if rectangles else [""]
         oneocr_threads = []
         run.init_config(False)
         if rectangles:

GameSentenceMiner/utility_gui.py

@@ -1,7 +1,7 @@
 import json
 import os
 import tkinter as tk
-from tkinter import ttk
+from tkinter import ttk, Scrollbar
 
 from GameSentenceMiner import obs
 from GameSentenceMiner.configuration import logger, get_app_directory, get_config
@@ -13,19 +13,19 @@ class UtilityApp:
         self.items = []
         self.play_audio_buttons = []
         self.get_screenshot_buttons = []
-        self.checkboxes = []
+        self.checkbox_vars = []
         self.multi_mine_window = None  # Store the multi-mine window reference
         self.checkbox_frame = None
+        self.canvas = None
+        self.scrollbar = None
         self.line_for_audio = None
         self.line_for_screenshot = None
-        self.line_counter = 0
 
         style = ttk.Style()
         style.configure("TCheckbutton", font=("Arial", 20))  # Change the font and size
         self.config_file = os.path.join(get_app_directory(), "multi-mine-window-config.json")
         self.load_window_config()
 
-
     def save_window_config(self):
         if self.multi_mine_window:
             config = {
@@ -58,20 +58,33 @@ class UtilityApp:
             self.multi_mine_window.title("Multi Mine Window")
 
             self.multi_mine_window.geometry(f"{self.window_width}x{self.window_height}+{self.window_x}+{self.window_y}")
-
             self.multi_mine_window.minsize(800, 400)
 
-            self.checkbox_frame = ttk.Frame(self.multi_mine_window)
-            self.checkbox_frame.pack(padx=10, pady=10, fill="both", expand=True)
+            self.canvas = tk.Canvas(self.multi_mine_window)
+            self.scrollbar = Scrollbar(self.multi_mine_window, orient="vertical", command=self.canvas.yview)
+            self.checkbox_frame = ttk.Frame(self.canvas)
+
+            self.canvas.configure(yscrollcommand=self.scrollbar.set)
+
+            self.scrollbar.pack(side="right", fill="y")
+            self.canvas.pack(side="left", fill="both", expand=True)
+            self.canvas.create_window((0, 0), window=self.checkbox_frame, anchor="nw")
+
+            self.checkbox_frame.bind("<Configure>", self.on_frame_configure)
 
             for line, var in self.items:
                 self.add_checkbox_to_gui(line, var)
+            self.scroll_to_bottom()
 
             self.multi_mine_window.protocol("WM_DELETE_WINDOW", self.on_close)
         else:
             self.multi_mine_window.deiconify()
             self.multi_mine_window.lift()
 
+    def on_frame_configure(self, event):
+        """Reset the scroll region to encompass the inner frame"""
+        self.canvas.configure(scrollregion=self.canvas.bbox("all"))
+
     def on_close(self):
         self.save_window_config()
         self.multi_mine_window.withdraw()
@@ -81,48 +94,44 @@ class UtilityApp:
             try:
                 var = tk.BooleanVar()
                 self.items.append((line, var))
+                if self.multi_mine_window and tk.Toplevel.winfo_exists(self.multi_mine_window):
+                    self.add_checkbox_to_gui(line, var)
+                self.scroll_to_bottom()
             except Exception as e:
                 logger.error(f"NOT AN ERROR: Attempted to add text to multi-mine window, before it was initialized: {e}")
                 return
 
-            if len(self.items) > 10:
-                if self.checkboxes:
-                    self.checkboxes[0].destroy()
-                    self.checkboxes.pop(0)
-                self.items.pop(0)
-                if self.play_audio_buttons:
-                    self.play_audio_buttons[0].destroy()
-                    self.play_audio_buttons.pop(0)
-                if self.get_screenshot_buttons:
-                    self.get_screenshot_buttons[0].destroy()
-                    self.get_screenshot_buttons.pop(0)
-
-            if self.multi_mine_window and tk.Toplevel.winfo_exists(self.multi_mine_window):
-                self.add_checkbox_to_gui(line, var)
         self.line_for_audio = None
         self.line_for_screenshot = None
 
     def add_checkbox_to_gui(self, line, var):
         """ Add a single checkbox without repainting everything. """
         if self.checkbox_frame:
+            row = len(self.checkbox_vars)
             column = 0
+
             if get_config().advanced.show_screenshot_buttons:
                 get_screenshot_button = ttk.Button(self.checkbox_frame, text="📸", command=lambda: self.take_screenshot(line))
-                get_screenshot_button.grid(row=self.line_counter, column=column, sticky='w', padx=5)
-                self.get_screenshot_buttons.append(get_screenshot_button)
+                get_screenshot_button.grid(row=row, column=column, sticky='w', padx=5)
                 column += 1
 
             if get_config().advanced.video_player_path or get_config().advanced.audio_player_path:
                 play_audio_button = ttk.Button(self.checkbox_frame, text="🔊", command=lambda: self.play_audio(line))
-                play_audio_button.grid(row=self.line_counter, column=column, sticky='w', padx=5)
-                self.play_audio_buttons.append(play_audio_button)
+                play_audio_button.grid(row=row, column=column, sticky='w', padx=5)
                 column += 1
 
             chk = ttk.Checkbutton(self.checkbox_frame, text=f"{line.time.strftime('%H:%M:%S')} - {line.text}", variable=var)
-            chk.grid(row=self.line_counter, column=column, sticky='w', padx=5)
-            self.checkboxes.append(chk)
+            chk.grid(row=row, column=column, sticky='w', padx=5)
+            self.checkbox_vars.append(var)
+
+            # Update scroll region after adding a new item
+            self.checkbox_frame.update_idletasks()
+            self.canvas.config(scrollregion=self.canvas.bbox("all"))
 
-            self.line_counter += 1
+
+    def scroll_to_bottom(self):
+        """Scroll the canvas to the bottom"""
+        self.canvas.yview_moveto(1.0)
 
 
     def play_audio(self, line):
@@ -134,25 +143,16 @@ class UtilityApp:
         obs.save_replay_buffer()
 
 
-    # def update_multi_mine_window(self):
-    #     for widget in self.multi_mine_window.winfo_children():
-    #         widget.destroy()
-    #
-    #     for i, (text, var, time) in enumerate(self.items):
-    #         time: datetime
-    #         chk = ttk.Checkbutton(self.checkbox_frame, text=f"{time.strftime('%H:%M:%S')} - {text}", variable=var)
-    #         chk.pack(anchor='w')
-
     def get_selected_lines(self):
-        filtered_items = [line for line, var in self.items if var.get()]
+        filtered_items = [line for (line, _), var in zip(self.items, self.checkbox_vars) if var.get()]
         return filtered_items if len(filtered_items) > 0 else []
 
 
     def get_next_line_timing(self):
-        selected_lines = [line for line, var in self.items if var.get()]
+        selected_lines = [line for (line, _), var in zip(self.items, self.checkbox_vars) if var.get()]
 
         if len(selected_lines) >= 2:
-            last_checked_index = max(i for i, (_, var) in enumerate(self.items) if var.get())
+            last_checked_index = max(i for i, var in enumerate(self.checkbox_vars) if var.get())
 
             if last_checked_index + 1 < len(self.items):
                 next_time = self.items[last_checked_index + 1][0].time
@@ -167,30 +167,14 @@ class UtilityApp:
 
 
     def lines_selected(self):
-        filter_times = [line.time for line, var in self.items if var.get()]
+        filter_times = [line.time for (line, _), var in zip(self.items, self.checkbox_vars) if var.get()]
         if len(filter_times) > 0:
             return True
         return False
 
-    # def validate_checkboxes(self, *args):
-    #     logger.debug("Validating checkboxes")
-    #     found_checked = False
-    #     found_unchecked = False
-    #     for _, var in self.items:
-    #         if var.get():
-    #             if found_unchecked:
-    #                 messagebox.showinfo("Invalid", "Can only select neighboring checkboxes.")
-    #                 break
-    #             found_checked = True
-    #         if found_checked and not var.get():
-    #             found_unchecked = True
-
     def reset_checkboxes(self):
-        for _, var in self.items:
+        for var in self.checkbox_vars:
             var.set(False)
-        # if self.multi_mine_window:
-        #     for checkbox in self.checkboxes:
-        #         checkbox.set(False)
 
 
 def init_utility_window(root):
@@ -207,4 +191,14 @@ utility_window: UtilityApp = None
 if __name__ == "__main__":
     root = tk.Tk()
     app = UtilityApp(root)
-    root.mainloop()
+
+    # Simulate adding a lot of lines
+    import datetime
+    now = datetime.datetime.now()
+    for i in range(100):
+        from GameSentenceMiner.gametext import GameLine
+        line = GameLine(f"This is line {i}", now + datetime.timedelta(seconds=i), prev=None, next=None)
+        app.add_text(line)
+    app.show()
+
+    root.mainloop()

{gamesentenceminer-2.7.9.dist-info → gamesentenceminer-2.7.10.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: GameSentenceMiner
-Version: 2.7.9
+Version: 2.7.10
 Summary: A tool for mining sentences from games. Update: Multi-Line Mining! Fixed!
 Author-email: Beangate <bpwhelan95@gmail.com>
 License: MIT License

{gamesentenceminer-2.7.9.dist-info → gamesentenceminer-2.7.10.dist-info}/RECORD

@@ -3,15 +3,15 @@ GameSentenceMiner/anki.py,sha256=9E9GRR2zylW3Gp4PNlwYS_Nn-mhojZkjFqfYlTazte8,140
 GameSentenceMiner/config_gui.py,sha256=-1PanqdtTKiwItxeyt0piXrWo7lGMWwrC4iSo4NiPz4,67521
 GameSentenceMiner/configuration.py,sha256=TIL8yCr-FOScCA4OJt-BAtjEb50wtqFFrpmN-UlaQh4,20405
 GameSentenceMiner/electron_config.py,sha256=dGcPYCISPehXubYSzsDuI2Gl092MYK0u3bTnkL9Jh1Y,9787
-GameSentenceMiner/ffmpeg.py,sha256=iUj-1uLLJla6jjGDKuc1FbcXjMogYpoDhrQqCbQFcWA,13359
+GameSentenceMiner/ffmpeg.py,sha256=Du31elvSmcbfeNlx_TvqkbkmSfXCHCf4mfklBt5rLaU,13408
 GameSentenceMiner/gametext.py,sha256=AAke4swwmN16da0IpyL5xMhU23nTz_c6z2kMfXPYv-8,9194
-GameSentenceMiner/gsm.py,sha256=fcczDPDcC0vDLAPZtIY64mU3Di3RZjR40tuLIiwB5lE,24827
+GameSentenceMiner/gsm.py,sha256=aTJho7V9WTup7kxwMrpwCEXg1u_rsPn2XaRzClK2qI0,24849
 GameSentenceMiner/model.py,sha256=JdnkT4VoPOXmOpRgFdvERZ09c9wLN6tUJxdrKlGZcqo,5305
 GameSentenceMiner/notification.py,sha256=FY39ChSRK0Y8TQ6lBGsLnpZUFPtFpSy2tweeXVoV7kc,2809
 GameSentenceMiner/obs.py,sha256=3h1hh868zdXQFGXJ7_mQZs5kcudEMa3yBOrbCVckhCs,9139
 GameSentenceMiner/package.py,sha256=YlS6QRMuVlm6mdXx0rlXv9_3erTGS21jaP3PNNWfAH0,1250
 GameSentenceMiner/util.py,sha256=W49gqYlhbzZe-17zHMFcAjNeeteXrv_USHT7aBDKSqM,6825
-GameSentenceMiner/utility_gui.py,sha256=H4aOddlsrVR768RwbMzYScCziuOz1JeySUigNrPlaac,7692
+GameSentenceMiner/utility_gui.py,sha256=JcNjk9Wrz_Au7P4ITslSBqXBU-o6nA2sc2vJvglAk4o,7432
 GameSentenceMiner/ai/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 GameSentenceMiner/ai/gemini.py,sha256=6kTQPuRH16D-1srhrWa5uPGIy-jBqNm9eRdKBSbpiXA,5423
 GameSentenceMiner/communication/__init__.py,sha256=_jGn9PJxtOAOPtJ2rI-Qu9hEHVZVpIvWlxKvqk91_zI,638
@@ -21,10 +21,10 @@ GameSentenceMiner/downloader/Untitled_json.py,sha256=RUUl2bbbCpUDUUS0fP0tdvf5Fng
 GameSentenceMiner/downloader/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 GameSentenceMiner/downloader/download_tools.py,sha256=mI1u_FGBmBqDIpCH3jOv8DOoZ3obgP5pIf9o9SVfX2Q,8131
 GameSentenceMiner/ocr/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-GameSentenceMiner/ocr/gsm_ocr_config.py,sha256=UnkAqn_9EoJlzElHLjKYjNsDBM_MnTlsSshqbRAlXIg,890
+GameSentenceMiner/ocr/gsm_ocr_config.py,sha256=FZ3CCgtpVawJ2mq3EP0KheJjYte5PlyOO1VnGND-__Y,467
 GameSentenceMiner/ocr/ocrconfig.py,sha256=hTROOZ3On2HngXKxwQFZvnr5AxlmlMV0mPxv-F3NbMg,6476
-GameSentenceMiner/ocr/owocr_area_selector.py,sha256=fpPE6FOFSSfgc2feur8Czve91Jl1zBG_nwUSRY6lTbg,11934
-GameSentenceMiner/ocr/owocr_helper.py,sha256=_mcjF9TA9GrselOzJQdtXhImj8nlLGih9TIiuXsaEdo,14089
+GameSentenceMiner/ocr/owocr_area_selector.py,sha256=MggSnJSUQhs7SD6YTKRNnVhEZEliLgaUTOPkBUCjAss,11952
+GameSentenceMiner/ocr/owocr_helper.py,sha256=wU6zXr27XzH8cw2xkAJ6HtFSPRVpWOWGuhpC775NMQQ,14742
 GameSentenceMiner/owocr/owocr/__init__.py,sha256=opjBOyGGyEqZCE6YdZPnyt7nVfiwyELHsXA0jAsjm14,25
 GameSentenceMiner/owocr/owocr/__main__.py,sha256=r8MI6RAmbkTWqOJ59uvXoDS7CSw5jX5war9ULGWELrA,128
 GameSentenceMiner/owocr/owocr/config.py,sha256=738QCJHEWpFhMh966plOcXYWwcshSiRsxjjIwldeTtI,7461
@@ -36,9 +36,9 @@ GameSentenceMiner/vad/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3h
 GameSentenceMiner/vad/silero_trim.py,sha256=ULf3zwS-JMsY82cKF7gZxREHw8L6lgpWF2U1YqgE9Oc,1681
 GameSentenceMiner/vad/vosk_helper.py,sha256=125X8C9NxFPlWWpoNsbOnEqKx8RCjXN109zNx_QXhyg,6070
 GameSentenceMiner/vad/whisper_helper.py,sha256=JJ-iltCh813XdjyEw0Wn5DaErf6PDqfH0Efu1Md8cIY,3543
-gamesentenceminer-2.7.9.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-gamesentenceminer-2.7.9.dist-info/METADATA,sha256=hFDJEaZNflRL93x_WRMZwDxjGSnO3ylogfdij2ZwVhs,5839
-gamesentenceminer-2.7.9.dist-info/WHEEL,sha256=pxyMxgL8-pra_rKaQ4drOZAegBVuX-G_4nRHjjgWbmo,91
-gamesentenceminer-2.7.9.dist-info/entry_points.txt,sha256=2APEP25DbfjSxGeHtwBstMH8mulVhLkqF_b9bqzU6vQ,65
-gamesentenceminer-2.7.9.dist-info/top_level.txt,sha256=V1hUY6xVSyUEohb0uDoN4UIE6rUZ_JYx8yMyPGX4PgQ,18
-gamesentenceminer-2.7.9.dist-info/RECORD,,
+gamesentenceminer-2.7.10.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+gamesentenceminer-2.7.10.dist-info/METADATA,sha256=mfPx9X0zpeSfjd_nLr3ZXx-twqQE-BjS7h6YFMIRMlw,5840
+gamesentenceminer-2.7.10.dist-info/WHEEL,sha256=pxyMxgL8-pra_rKaQ4drOZAegBVuX-G_4nRHjjgWbmo,91
+gamesentenceminer-2.7.10.dist-info/entry_points.txt,sha256=2APEP25DbfjSxGeHtwBstMH8mulVhLkqF_b9bqzU6vQ,65
+gamesentenceminer-2.7.10.dist-info/top_level.txt,sha256=V1hUY6xVSyUEohb0uDoN4UIE6rUZ_JYx8yMyPGX4PgQ,18
+gamesentenceminer-2.7.10.dist-info/RECORD,,