GameSentenceMiner 2.5.10__py3-none-any.whl → 2.5.12__py3-none-any.whl

GameSentenceMiner/anki.py

@@ -1,22 +1,22 @@
+import time
+
 import base64
 import subprocess
 import threading
-import time
 import urllib.request
 from datetime import datetime, timedelta
+from requests import post
 
-import requests as req
-
-from GameSentenceMiner import obs, util, notification, ffmpeg, gametext
-
+from GameSentenceMiner import obs, util, notification, ffmpeg
 from GameSentenceMiner.configuration import *
 from GameSentenceMiner.configuration import get_config
 from GameSentenceMiner.gametext import get_text_event
 from GameSentenceMiner.model import AnkiCard
-from GameSentenceMiner.utility_gui import utility_window, get_utility_window
+from GameSentenceMiner.utility_gui import get_utility_window
 from GameSentenceMiner.obs import get_current_game
 from GameSentenceMiner.util import remove_html_and_cloze_tags, combine_dialogue
 
+
 audio_in_anki = None
 screenshot_in_anki = None
 prev_screenshot_in_anki = None
@@ -309,7 +309,7 @@ def monitor_anki():
 
 # Fetch recent note IDs from Anki
 def get_note_ids():
-    response = req.post(get_config().anki.url, json={
+    response = post(get_config().anki.url, json={
         "action": "findNotes",
         "version": 6,
         "params": {"query": "added:1"}

GameSentenceMiner/config_gui.py

@@ -835,12 +835,6 @@ class ConfigApp:
         self.add_label_and_increment_row(obs_frame, "Password for the OBS WebSocket server.", row=self.current_row,
                                          column=2)
 
-        ttk.Label(obs_frame, text="Start/Stop Buffer:").grid(row=self.current_row, column=0, sticky='W')
-        self.obs_start_buffer = tk.BooleanVar(value=self.settings.obs.start_buffer)
-        ttk.Checkbutton(obs_frame, variable=self.obs_start_buffer).grid(row=self.current_row, column=1, sticky='W')
-        self.add_label_and_increment_row(obs_frame, "Start and Stop the Buffer when Script runs.", row=self.current_row,
-                                         column=2)
-
         ttk.Label(obs_frame, text="Get Game From Scene Name:").grid(row=self.current_row, column=0, sticky='W')
         self.get_game_from_scene_name = tk.BooleanVar(value=self.settings.obs.get_game_from_scene)
         ttk.Checkbutton(obs_frame, variable=self.get_game_from_scene_name).grid(row=self.current_row, column=1,

GameSentenceMiner/configuration.py

@@ -128,7 +128,6 @@ class OBS:
     host: str = "localhost"
     port: int = 4455
     password: str = "your_password"
-    start_buffer: bool = True
     get_game_from_scene: bool = True
     minimum_replay_size: int = 0
 

GameSentenceMiner/gsm.py

@@ -1,5 +1,6 @@
+
+import os.path
 import signal
-import time
 from subprocess import Popen
 
 import keyboard
@@ -10,6 +11,8 @@ from pystray import Icon, Menu, MenuItem
 from watchdog.events import FileSystemEventHandler
 from watchdog.observers import Observer
 
+import time
+
 from GameSentenceMiner import anki
 from GameSentenceMiner import config_gui
 from GameSentenceMiner import configuration
@@ -28,11 +31,11 @@ from GameSentenceMiner.gametext import get_text_event, get_mined_line, GameLine
 from GameSentenceMiner.obs import check_obs_folder_is_correct
 from GameSentenceMiner.util import *
 from GameSentenceMiner.utility_gui import init_utility_window, get_utility_window
-from GameSentenceMiner.vad import silero_trim, whisper_helper, vosk_helper
 
 if is_windows():
     import win32api
 
+silero_trim, whisper_helper, vosk_helper = None, None, None
 procs_to_close = []
 settings_window: config_gui.ConfigApp = None
 obs_paused = False
@@ -41,51 +44,39 @@ menu: Menu
 root = None
 
 
+
 class VideoToAudioHandler(FileSystemEventHandler):
     def on_created(self, event):
         if event.is_directory or ("Replay" not in event.src_path and "GSM" not in event.src_path):
             return
         if event.src_path.endswith(".mkv") or event.src_path.endswith(".mp4"):  # Adjust based on your OBS output format
             logger.info(f"MKV {event.src_path} FOUND, RUNNING LOGIC")
-            self.wait_for_stable_file(event.src_path)
+            wait_for_stable_file(event.src_path)
             self.convert_to_audio(event.src_path)
 
-    @staticmethod
-    def wait_for_stable_file(file_path, timeout=10, check_interval=0.5):
-        elapsed_time = 0
-        last_size = -1
-
-        while elapsed_time < timeout:
-            try:
-                current_size = os.path.getsize(file_path)
-                if current_size == last_size:
-                    return True
-                last_size = current_size
-                time.sleep(check_interval)
-                elapsed_time += check_interval
-            except Exception as e:
-                logger.warning(f"Error checking file size, will still try updating Anki Card!: {e}")
-                return False
-        logger.warning("File size did not stabilize within the timeout period. Continuing...")
-        return False
-
     @staticmethod
     def convert_to_audio(video_path):
-        if get_utility_window().line_for_audio:
-            line: GameLine = get_utility_window().line_for_audio
-            get_utility_window().line_for_audio = None
-            if get_config().advanced.audio_player_path:
-                audio = VideoToAudioHandler.get_audio(line, line.next.time if line.next else None, video_path, temporary=True)
-                play_audio_in_external(audio)
+        try:
+            if get_utility_window().line_for_audio:
+                line: GameLine = get_utility_window().line_for_audio
+                get_utility_window().line_for_audio = None
+                if get_config().advanced.audio_player_path:
+                    audio = VideoToAudioHandler.get_audio(line, line.next.time if line.next else None, video_path, temporary=True)
+                    play_audio_in_external(audio)
+                    os.remove(video_path)
+                elif get_config().advanced.video_player_path:
+                    play_video_in_external(line, video_path)
+                return
+            if get_utility_window().line_for_screenshot:
+                line: GameLine = get_utility_window().line_for_screenshot
+                get_utility_window().line_for_screenshot = None
+                screenshot = ffmpeg.get_screenshot_for_line(video_path, line)
+                os.startfile(screenshot)
                 os.remove(video_path)
-            elif get_config().advanced.video_player_path:
-                play_video_in_external(line, video_path)
-            return
-        if get_utility_window().line_for_screenshot:
-            line: GameLine = get_utility_window().line_for_screenshot
-            get_utility_window().line_for_screenshot = None
-            screenshot = ffmpeg.get_screenshot_for_line(video_path, line)
-            os.startfile(screenshot)
+                return
+        except Exception as e:
+            logger.error(f"Error Playing Audio/Video: {e}")
+            logger.debug(f"Error Playing Audio/Video: {e}", exc_info=True)
             os.remove(video_path)
             return
         try:
@@ -158,10 +149,11 @@ class VideoToAudioHandler(FileSystemEventHandler):
             logger.error(f"Failed Processing and/or adding to Anki: Reason {e}")
             logger.debug(f"Some error was hit catching to allow further work to be done: {e}", exc_info=True)
             notification.send_error_no_anki_update()
-        if get_config().paths.remove_video and os.path.exists(video_path):
-            os.remove(video_path)  # Optionally remove the video after conversion
-        if get_config().paths.remove_audio and os.path.exists(vad_trimmed_audio):
-            os.remove(vad_trimmed_audio)  # Optionally remove the screenshot after conversion
+        finally:
+            if get_config().paths.remove_video and os.path.exists(video_path):
+                os.remove(video_path)  # Optionally remove the video after conversion
+            if get_config().paths.remove_audio and os.path.exists(vad_trimmed_audio):
+                os.remove(vad_trimmed_audio)  # Optionally remove the screenshot after conversion
 
 
     @staticmethod
@@ -175,26 +167,10 @@ class VideoToAudioHandler(FileSystemEventHandler):
                                                                 f"{obs.get_current_game(sanitize=True)}.{get_config().audio.extension}"))
         should_update_audio = True
         if get_config().vad.do_vad_postprocessing:
-            match get_config().vad.selected_vad_model:
-                case configuration.SILERO:
-                    should_update_audio = silero_trim.process_audio_with_silero(trimmed_audio, vad_trimmed_audio)
-                case configuration.VOSK:
-                    should_update_audio = vosk_helper.process_audio_with_vosk(trimmed_audio, vad_trimmed_audio)
-                case configuration.WHISPER:
-                    should_update_audio = whisper_helper.process_audio_with_whisper(trimmed_audio,
-                                                                                    vad_trimmed_audio)
+            should_update_audio = do_vad_processing(get_config().vad.selected_vad_model, trimmed_audio, vad_trimmed_audio)
             if not should_update_audio:
-                match get_config().vad.backup_vad_model:
-                    case configuration.OFF:
-                        pass
-                    case configuration.SILERO:
-                        should_update_audio = silero_trim.process_audio_with_silero(trimmed_audio,
-                                                                                    vad_trimmed_audio)
-                    case configuration.VOSK:
-                        should_update_audio = vosk_helper.process_audio_with_vosk(trimmed_audio, vad_trimmed_audio)
-                    case configuration.WHISPER:
-                        should_update_audio = whisper_helper.process_audio_with_whisper(trimmed_audio,
-                                                                                        vad_trimmed_audio)
+                should_update_audio = do_vad_processing(get_config().vad.selected_vad_model, trimmed_audio,
+                                                        vad_trimmed_audio)
             if not should_update_audio and get_config().vad.add_audio_on_no_results:
                 logger.info("No voice activity detected, using full audio.")
                 vad_trimmed_audio = trimmed_audio
@@ -206,6 +182,22 @@ class VideoToAudioHandler(FileSystemEventHandler):
             shutil.move(vad_trimmed_audio, final_audio_output)
         return final_audio_output, should_update_audio, vad_trimmed_audio
 
+
+def do_vad_processing(model, trimmed_audio, vad_trimmed_audio, second_pass=False):
+    match model:
+        case configuration.OFF:
+            pass
+        case configuration.SILERO:
+            from GameSentenceMiner.vad import silero_trim
+            return silero_trim.process_audio_with_silero(trimmed_audio, vad_trimmed_audio)
+        case configuration.VOSK:
+            from GameSentenceMiner.vad import vosk_helper
+            return vosk_helper.process_audio_with_vosk(trimmed_audio, vad_trimmed_audio)
+        case configuration.WHISPER:
+            from GameSentenceMiner.vad import whisper_helper
+            return whisper_helper.process_audio_with_whisper(trimmed_audio, vad_trimmed_audio)
+
+
 def play_audio_in_external(filepath):
     exe = get_config().advanced.audio_player_path
 
@@ -228,18 +220,19 @@ def play_video_in_external(line, filepath):
 
     start, _, _ = get_video_timings(filepath, line)
 
-    print(start)
-
-    if "vlc" in get_config().advanced.video_player_path:
-        command.append("--start-time")
-    else:
-        command.append("--start")
+    if start:
+        if "vlc" in get_config().advanced.video_player_path:
+            command.append("--start-time")
+        else:
+            command.append("--start")
+        command.append(convert_to_vlc_seconds(start))
+    command.append(os.path.normpath(filepath))
 
-    command.extend([convert_to_vlc_seconds(start), os.path.normpath(filepath)])
+    logger.info(" ".join(command))
 
     try:
         proc = subprocess.Popen(command)
-        print(f"Opened {filepath} in VLC.")
+        print(f"Opened {filepath} in {get_config().advanced.video_player_path}.")
         threading.Thread(target=remove_video_when_closed, args=(proc, filepath)).start()
     except FileNotFoundError:
         print("VLC not found. Make sure it's installed and in your PATH.")
@@ -279,7 +272,7 @@ def register_hotkeys():
 def get_screenshot():
     try:
         image = obs.get_screenshot()
-        time.sleep(2)  # Wait for ss to save
+        wait_for_stable_file(image, timeout=3)
         if not image:
             raise Exception("Failed to get Screenshot from OBS")
         encoded_image = ffmpeg.process_image(image)
@@ -472,9 +465,8 @@ def cleanup():
     util.keep_running = False
 
     if get_config().obs.enabled:
-        if get_config().obs.start_buffer:
-            obs.stop_replay_buffer()
-    obs.disconnect_from_obs()
+        obs.stop_replay_buffer()
+        obs.disconnect_from_obs()
     if get_config().obs.close_obs:
         close_obs()
 
@@ -514,9 +506,9 @@ def initialize(reloading=False):
         if is_windows():
             download_obs_if_needed()
             download_ffmpeg_if_needed()
-        # if get_config().obs.enabled:
-            # if get_config().obs.open_obs:
-                # obs_process = obs.start_obs()
+        if get_config().obs.enabled:
+            if get_config().obs.open_obs:
+                obs_process = obs.start_obs()
             # obs.connect_to_obs(start_replay=True)
             # anki.start_monitoring_anki()
         # gametext.start_text_monitor()
@@ -534,27 +526,29 @@ def initialize(reloading=False):
 def initialize_async():
     tasks = [gametext.start_text_monitor, connect_websocket, run_tray]
     threads = []
-    if get_config().obs.enabled:
-        if get_config().obs.open_obs:
-            tasks.append(obs.start_obs)
-        else:
-            tasks.append(obs.connect_to_obs)
-        tasks.append(anki.start_monitoring_anki)
-    if get_config().vad.do_vad_postprocessing:
-        if VOSK in (get_config().vad.backup_vad_model, get_config().vad.selected_vad_model):
-            tasks.append(vosk_helper.get_vosk_model)
-    if WHISPER in (get_config().vad.backup_vad_model, get_config().vad.selected_vad_model):
-            tasks.append(whisper_helper.initialize_whisper_model)
+    tasks.append(anki.start_monitoring_anki)
     for task in tasks:
         threads.append(util.run_new_thread(task))
     return threads
 
-def check_async_init_done(threads):
-    while True:
-        if all(not thread.is_alive() for thread in threads):
-            break
-        time.sleep(0.5)
-    logger.info("Script Fully Initialized. Happy Mining!")
+
+def post_init():
+    def do_post_init():
+        global silero_trim, whisper_helper, vosk_helper
+        logger.info("Post-Initialization started.")
+        if get_config().obs.enabled:
+            obs.connect_to_obs()
+            check_obs_folder_is_correct()
+            from GameSentenceMiner.vad import vosk_helper
+            from GameSentenceMiner.vad import whisper_helper
+            if get_config().vad.is_vosk():
+                vosk_helper.get_vosk_model()
+            if get_config().vad.is_whisper():
+                whisper_helper.initialize_whisper_model()
+            if get_config().vad.is_silero():
+                from GameSentenceMiner.vad import silero_trim
+
+    util.run_new_thread(do_post_init)
 
 
 def handle_websocket_message(message: Message):
@@ -574,7 +568,6 @@ def main(reloading=False):
     init_utility_window(root)
     initialize(reloading)
     initialize_async()
-    check_obs_folder_is_correct()
     observer = Observer()
     observer.schedule(VideoToAudioHandler(), get_config().paths.folder_to_watch, recursive=False)
     observer.start()
@@ -592,6 +585,7 @@ def main(reloading=False):
             root.after(0, settings_window.show)
         if get_config().general.open_multimine_on_startup:
             root.after(0, get_utility_window().show)
+        root.after(0, post_init)
         settings_window.add_save_hook(update_icon)
         settings_window.on_exit = exit_program
         root.mainloop()
@@ -606,4 +600,5 @@ def main(reloading=False):
 
 
 if __name__ == "__main__":
+    logger.info("Starting GSM")
     main()

GameSentenceMiner/obs.py

@@ -28,12 +28,9 @@ def start_obs():
         return None
 
     try:
-        obs_pid = is_obs_running(obs_path)
-        if obs_pid:
-            return obs_pid
-        obs_process = subprocess.Popen([obs_path, '--disable-shutdown-check', '--portable'], cwd=os.path.dirname(obs_path))
+        obs_process = subprocess.Popen([obs_path, '--disable-shutdown-check', '--portable', '--startreplaybuffer'], cwd=os.path.dirname(obs_path))
+
         logger.info("OBS launched")
-        connect_to_obs()
         return obs_process.pid
     except Exception as e:
         logger.error(f"Error launching OBS: {e}")
@@ -48,15 +45,6 @@ def check_obs_folder_is_correct():
         get_master_config().sync_shared_fields()
         save_full_config(get_master_config())
 
-def is_obs_running(obs_path):
-    obs_path = os.path.abspath(obs_path)  # Normalize path
-    for process in psutil.process_iter(['exe']):
-        try:
-            if process.info['exe'] and os.path.abspath(process.info['exe']) == obs_path:
-                return process.pid
-        except (psutil.NoSuchProcess, psutil.AccessDenied, psutil.ZombieProcess):
-            continue
-    return False
 
 def get_obs_websocket_config_values():
     config_path = os.path.join(get_app_directory(), 'obs-studio', 'config', 'obs-studio', 'plugin_config', 'obs-websocket', 'config.json')
@@ -92,10 +80,8 @@ def get_obs_websocket_config_values():
 
 
 def on_connect(obs):
-    logger.info("Connected to OBS WebSocket.")
-    time.sleep(2)
-    if get_config().obs.start_buffer:
-        start_replay_buffer()
+    logger.info("Reconnected to OBS WebSocket.")
+    start_replay_buffer()
 
 
 def on_disconnect(obs):
@@ -111,9 +97,6 @@ def connect_to_obs():
                        password=get_config().obs.password, authreconnect=1, on_connect=on_connect,
                        on_disconnect=on_disconnect)
         client.connect()
-
-        if get_config().obs.start_buffer:
-            start_replay_buffer()
         update_current_game()
 
 
@@ -135,6 +118,7 @@ def do_obs_call(request, from_dict = None, retry=10):
             return from_dict(response.datain)
         return None
     except Exception as e:
+        logger.error(e)
         if "socket is already closed" in str(e) or "object has no attribute" in str(e):
             if retry > 0:
                 time.sleep(1)

GameSentenceMiner/util.py

@@ -6,6 +6,7 @@ import string
 import subprocess
 import sys
 import threading
+import time
 from datetime import datetime
 from sys import platform
 
@@ -178,38 +179,31 @@ def combine_dialogue(dialogue_lines, new_lines=None):
 
     return new_lines
 
-# def import_vad_models():
-#     silero_trim, whisper_helper, vosk_helper = None, None, None
-#
-#     def check_and_install(package_name):
-#         try:
-#             importlib.import_module(package_name)
-#             return True
-#         except ImportError:
-#             logger.warning(f"{package_name} is not installed. Attempting to install...")
-#             try:
-#                 python_executable = sys.executable
-#                 subprocess.check_call([python_executable, "-m", "pip", "install", package_name])
-#                 logger.info(f"{package_name} installed successfully.")
-#                 return True
-#             except subprocess.CalledProcessError as e:
-#                 logger.error(f"Failed to install {package_name}: {e}")
-#                 return False
-#
-#     if get_config().vad.is_silero():
-#         if check_and_install("silero_vad"):
-#             from GameSentenceMiner.vad import silero_trim
-#         else:
-#             logger.error("Silero VAD is enabled and silero_vad package could not be installed.")
-#     if get_config().vad.is_whisper():
-#         if check_and_install("stable-ts"):
-#             from GameSentenceMiner.vad import whisper_helper
-#         else:
-#             logger.error("Whisper is enabled and whisper package could not be installed.")
-#     if get_config().vad.is_vosk():
-#         if check_and_install("vosk"):
-#             from GameSentenceMiner.vad import vosk_helper
-#         else:
-#             logger.error("Vosk is enabled and vosk package could not be installed.")
-#
-#     return silero_trim, whisper_helper, vosk_helper
+def wait_for_stable_file(file_path, timeout=10, check_interval=0.1):
+    elapsed_time = 0
+    last_size = -1
+
+    while elapsed_time < timeout:
+        try:
+            current_size = os.path.getsize(file_path)
+            if current_size == last_size:
+                return True
+            last_size = current_size
+            time.sleep(check_interval)
+            elapsed_time += check_interval
+        except Exception as e:
+            logger.warning(f"Error checking file size, will still try updating Anki Card!: {e}")
+            return False
+    logger.warning("File size did not stabilize within the timeout period. Continuing...")
+    return False
+
+
+def import_vad_models():
+    silero_trim, whisper_helper, vosk_helper = None, None, None
+    if get_config().vad.is_silero():
+        from GameSentenceMiner.vad import silero_trim
+    if get_config().vad.is_whisper():
+        from GameSentenceMiner.vad import whisper_helper
+    if get_config().vad.is_vosk():
+        from GameSentenceMiner.vad import vosk_helper
+    return silero_trim, whisper_helper, vosk_helper

{gamesentenceminer-2.5.10.dist-info → gamesentenceminer-2.5.12.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: GameSentenceMiner
-Version: 2.5.10
+Version: 2.5.12
 Summary: A tool for mining sentences from games. Update: Multi-Line Mining! Fixed!
 Author-email: Beangate <bpwhelan95@gmail.com>
 License: MIT License
@@ -97,7 +97,7 @@ steps before making an issue:
 
 - Try Restarting OBS
 - Make sure your hook is the best you can find. (Preferably it gives you the text RIGHT when the voice line starts)
-- Try Adjusting Offset Configuration in `config.toml` to better match your situation. (i.e. if the hook is late, add a
+- Try Adjusting Offset Configuration in the config to better match your situation. (i.e. if the hook is late, add a
   negative beginning offset)
 - Try using "Trim beginning" in `VAD` settings.
 

{gamesentenceminer-2.5.10.dist-info → gamesentenceminer-2.5.12.dist-info}/RECORD

@@ -1,15 +1,15 @@
 GameSentenceMiner/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-GameSentenceMiner/anki.py,sha256=xeWU1jX1ZK6tZVnDPqhBzetkCxdbPUWG1LkUy0sfHVg,13089
-GameSentenceMiner/config_gui.py,sha256=v4XRxGqRddqCrdv1UHu4Gnp7aMjL-CCCHBFlTy1Y2v0,61265
-GameSentenceMiner/configuration.py,sha256=DXlwEV4A7X3yzVV6UomY2jmmYAZx_jjMRxZeweoCtRE,20149
+GameSentenceMiner/anki.py,sha256=kMl-VvBkT_VtEjfTjliIHLGZwrJhHzTT1lRQ6qCdtYw,13062
+GameSentenceMiner/config_gui.py,sha256=9w7qXuGwt2lMTo4xXwuZKZyaLCoXBvzIDxSMrJzsUi8,60787
+GameSentenceMiner/configuration.py,sha256=u6Jm-Ox7PSZ1Cf5_AkV6hvQInayq7jXjLduf1eMK7Rc,20119
 GameSentenceMiner/ffmpeg.py,sha256=fzOxrn-a4KqFdUY2oove164CTDOSsdPQtzqRW5f1P7c,12002
 GameSentenceMiner/gametext.py,sha256=LORVdE2WEo1CDI8gonc7qxrhbS4KFKXFQVKjhlkpLbc,7368
-GameSentenceMiner/gsm.py,sha256=KKlI-wrk39XWfPEa9yqAlBwiusm6b-V5aITPFZCRWUs,24707
+GameSentenceMiner/gsm.py,sha256=H6kG2HerHhY37jXWGoQCLWjtzOoxAU_tAJ4RY9pAWbc,23970
 GameSentenceMiner/model.py,sha256=JdnkT4VoPOXmOpRgFdvERZ09c9wLN6tUJxdrKlGZcqo,5305
 GameSentenceMiner/notification.py,sha256=FY39ChSRK0Y8TQ6lBGsLnpZUFPtFpSy2tweeXVoV7kc,2809
-GameSentenceMiner/obs.py,sha256=EcgQ0VdeYXGeXCyvk8mBiHBL-HHai037BoCXomH9ge4,8239
+GameSentenceMiner/obs.py,sha256=MlxRToq5wALPI1XrD8rxEU-N8mWII91cNJWY7rUa5uI,7642
 GameSentenceMiner/package.py,sha256=YlS6QRMuVlm6mdXx0rlXv9_3erTGS21jaP3PNNWfAH0,1250
-GameSentenceMiner/util.py,sha256=tkaoU1bj8iPMTNwUCWUzFLAnT44Ot92D1tYwQMEnARw,7336
+GameSentenceMiner/util.py,sha256=Awhy57vX4NgQzygqKaGQn2EJ75T0uiXlhmINFOWlQkU,6825
 GameSentenceMiner/utility_gui.py,sha256=H4aOddlsrVR768RwbMzYScCziuOz1JeySUigNrPlaac,7692
 GameSentenceMiner/communication/__init__.py,sha256=_jGn9PJxtOAOPtJ2rI-Qu9hEHVZVpIvWlxKvqk91_zI,638
 GameSentenceMiner/communication/send.py,sha256=oOJdCS6-LNX90amkRn5FL2xqx6THGm56zHR2ntVIFTE,229
@@ -21,9 +21,9 @@ GameSentenceMiner/vad/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3h
 GameSentenceMiner/vad/silero_trim.py,sha256=-thDIZLuTLra3YBj7WR16Z6JeDgSpge2YuahprBvD8I,1585
 GameSentenceMiner/vad/vosk_helper.py,sha256=BI_mg_qyrjNbuEJjXSUDoV0FWEtQtEOAPmrrNixnZ_8,5974
 GameSentenceMiner/vad/whisper_helper.py,sha256=OF4J8TPPoKPJR1uFwrWAZ2Q7v0HJkVvNGmF8l1tACX0,3447
-gamesentenceminer-2.5.10.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-gamesentenceminer-2.5.10.dist-info/METADATA,sha256=foslJf1hVD8xY5LLltn7GUYapOOXXszAJyxfXS1bqIM,5436
-gamesentenceminer-2.5.10.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-gamesentenceminer-2.5.10.dist-info/entry_points.txt,sha256=2APEP25DbfjSxGeHtwBstMH8mulVhLkqF_b9bqzU6vQ,65
-gamesentenceminer-2.5.10.dist-info/top_level.txt,sha256=V1hUY6xVSyUEohb0uDoN4UIE6rUZ_JYx8yMyPGX4PgQ,18
-gamesentenceminer-2.5.10.dist-info/RECORD,,
+gamesentenceminer-2.5.12.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+gamesentenceminer-2.5.12.dist-info/METADATA,sha256=iibLRrqHFjwy-4U4_j1JhHB3USB-W8CR0AMpW_JneF0,5433
+gamesentenceminer-2.5.12.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+gamesentenceminer-2.5.12.dist-info/entry_points.txt,sha256=2APEP25DbfjSxGeHtwBstMH8mulVhLkqF_b9bqzU6vQ,65
+gamesentenceminer-2.5.12.dist-info/top_level.txt,sha256=V1hUY6xVSyUEohb0uDoN4UIE6rUZ_JYx8yMyPGX4PgQ,18
+gamesentenceminer-2.5.12.dist-info/RECORD,,