GameSentenceMiner 2.5.11__py3-none-any.whl → 2.5.13__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
@@ -32,8 +32,9 @@ def update_anki_card(last_note: AnkiCard, note=None, audio_path='', video_path='
     global audio_in_anki, screenshot_in_anki, prev_screenshot_in_anki
     update_audio = should_update_audio and (get_config().anki.sentence_audio_field and not
     last_note.get_field(get_config().anki.sentence_audio_field) or get_config().anki.overwrite_audio)
-    update_picture = (get_config().anki.picture_field and get_config().anki.overwrite_picture) or not \
-    last_note.get_field(get_config().anki.picture_field)
+    update_picture = (get_config().anki.picture_field and get_config().screenshot.enabled
+                      and (get_config().anki.overwrite_picture or not last_note.get_field(get_config().anki.picture_field)))
+
 
     if not reuse_audio:
         if update_audio:
@@ -54,11 +55,13 @@ def update_anki_card(last_note: AnkiCard, note=None, audio_path='', video_path='
 
     # note = {'id': last_note.noteId, 'fields': {}}
 
-    if update_audio:
+    if update_audio and audio_in_anki:
         note['fields'][get_config().anki.sentence_audio_field] = audio_html
 
-    if update_picture:
+    if update_picture and screenshot_in_anki:
         note['fields'][get_config().anki.picture_field] = image_html
+    if not get_config().screenshot.enabled:
+        logger.info("Skipping Adding Screenshot to Anki, Screenshot is disabled in settings")
 
     if prev_screenshot_in_anki:
         note['fields'][get_config().anki.previous_image_field] = prev_screenshot_html
@@ -82,7 +85,7 @@ def update_anki_card(last_note: AnkiCard, note=None, audio_path='', video_path='
     if get_config().features.open_anki_edit:
         notification.open_anki_card(last_note.noteId)
 
-    if get_config().audio.external_tool:
+    if get_config().audio.external_tool and get_config().audio.external_tool_enabled and update_audio:
         open_audio_in_external(f"{get_config().audio.anki_media_collection}/{audio_in_anki}")
 
 
@@ -309,7 +312,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

@@ -147,6 +147,7 @@ class ConfigApp:
                 backfill_audio=self.backfill_audio.get()
             ),
             screenshot=Screenshot(
+                enabled=self.screenshot_enabled.get(),
                 width=self.screenshot_width.get(),
                 height=self.screenshot_height.get(),
                 quality=self.screenshot_quality.get(),
@@ -157,12 +158,14 @@ class ConfigApp:
                 use_beginning_of_line_as_screenshot=self.use_beginning_of_line_as_screenshot.get()
             ),
             audio=Audio(
+                enabled=self.audio_enabled.get(),
                 extension=self.audio_extension.get(),
                 beginning_offset=float(self.beginning_offset.get()),
                 end_offset=float(self.end_offset.get()),
                 ffmpeg_reencode_options=self.ffmpeg_reencode_options.get(),
                 external_tool = self.external_tool.get(),
                 anki_media_collection=self.anki_media_collection.get(),
+                external_tool_enabled=self.external_tool_enabled.get(),
             ),
             obs=OBS(
                 enabled=self.obs_enabled.get(),
@@ -171,7 +174,6 @@ class ConfigApp:
                 host=self.obs_host.get(),
                 port=int(self.obs_port.get()),
                 password=self.obs_password.get(),
-                start_buffer=self.obs_start_buffer.get(),
                 get_game_from_scene=self.get_game_from_scene_name.get(),
                 minimum_replay_size=int(self.minimum_replay_size.get())
             ),
@@ -679,6 +681,11 @@ class ConfigApp:
         screenshot_frame = ttk.Frame(self.notebook)
         self.notebook.add(screenshot_frame, text='Screenshot')
 
+        ttk.Label(screenshot_frame, text="Enabled:").grid(row=self.current_row, column=0, sticky='W')
+        self.screenshot_enabled = tk.BooleanVar(value=self.settings.screenshot.enabled)
+        ttk.Checkbutton(screenshot_frame, variable=self.screenshot_enabled).grid(row=self.current_row, column=1, sticky='W')
+        self.add_label_and_increment_row(screenshot_frame, "Enable or disable screenshot processing.", row=self.current_row, column=2)
+
         ttk.Label(screenshot_frame, text="Width:").grid(row=self.current_row, column=0, sticky='W')
         self.screenshot_width = ttk.Entry(screenshot_frame)
         self.screenshot_width.insert(0, str(self.settings.screenshot.width))
@@ -737,6 +744,11 @@ class ConfigApp:
         audio_frame = ttk.Frame(self.notebook)
         self.notebook.add(audio_frame, text='Audio')
 
+        ttk.Label(audio_frame, text="Enabled:").grid(row=self.current_row, column=0, sticky='W')
+        self.audio_enabled = tk.BooleanVar(value=self.settings.audio.enabled)
+        ttk.Checkbutton(audio_frame, variable=self.audio_enabled).grid(row=self.current_row, column=1, sticky='W')
+        self.add_label_and_increment_row(audio_frame, "Enable or disable audio processing.", row=self.current_row, column=2)
+
         ttk.Label(audio_frame, text="Audio Extension:").grid(row=self.current_row, column=0, sticky='W')
         self.audio_extension = ttk.Combobox(audio_frame, values=['opus', 'mp3', 'ogg', 'aac', 'm4a'])
         self.audio_extension.insert(0, self.settings.audio.extension)
@@ -777,10 +789,13 @@ class ConfigApp:
         self.external_tool = ttk.Entry(audio_frame)
         self.external_tool.insert(0, self.settings.audio.external_tool)
         self.external_tool.grid(row=self.current_row, column=1)
+        ttk.Label(audio_frame, text="Enabled:").grid(row=self.current_row, column=2, sticky='W')
+        self.external_tool_enabled = tk.BooleanVar(value=self.settings.audio.external_tool_enabled)
+        ttk.Checkbutton(audio_frame, variable=self.external_tool_enabled).grid(row=self.current_row, column=3, sticky='W')
         self.add_label_and_increment_row(audio_frame,
                                          "Path to External tool that opens the audio up for manual trimming. I recommend OcenAudio for in-place Editing.",
                                          row=self.current_row,
-                                         column=2)
+                                         column=4)
 
         ttk.Button(audio_frame, text="Install Ocenaudio", command=self.download_and_install_ocen).grid(
             row=self.current_row, column=0, pady=5)
@@ -835,12 +850,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

@@ -98,6 +98,7 @@ class Features:
 @dataclass_json
 @dataclass
 class Screenshot:
+    enabled: bool = True
     width: str = 0
     height: str = 0
     quality: str = 85
@@ -111,12 +112,14 @@ class Screenshot:
 @dataclass_json
 @dataclass
 class Audio:
+    enabled: bool = True
     extension: str = 'opus'
     beginning_offset: float = 0.0
     end_offset: float = 0.5
     ffmpeg_reencode_options: str = ''
     external_tool: str = ""
     anki_media_collection: str = ""
+    external_tool_enabled: bool = True
 
 
 @dataclass_json
@@ -128,7 +131,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,6 +1,6 @@
+
 import os.path
 import signal
-import time
 from subprocess import Popen
 
 import keyboard
@@ -11,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
@@ -29,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
@@ -42,34 +44,16 @@ 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):
         try:
@@ -141,7 +125,7 @@ class VideoToAudioHandler(FileSystemEventHandler):
                 tango = last_note.get_field(get_config().anki.word_field) if last_note else ''
                 get_utility_window().reset_checkboxes()
 
-                if get_config().anki.sentence_audio_field:
+                if get_config().anki.sentence_audio_field and get_config().audio.enabled:
                     logger.debug("Attempting to get audio from video")
                     final_audio_output, should_update_audio, vad_trimmed_audio = VideoToAudioHandler.get_audio(
                         start_line,
@@ -151,7 +135,10 @@ class VideoToAudioHandler(FileSystemEventHandler):
                     final_audio_output = ""
                     should_update_audio = False
                     vad_trimmed_audio = ""
-                    logger.info("No SentenceAudio Field in config, skipping audio processing!")
+                    if not get_config().audio.enabled:
+                        logger.info("Audio is disabled in config, skipping audio processing!")
+                    elif not get_config().anki.sentence_audio_field:
+                        logger.info("No SentenceAudio Field in config, skipping audio processing!")
                 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,
                                           tango=tango,
@@ -183,26 +170,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
@@ -214,6 +185,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
 
@@ -244,6 +231,8 @@ def play_video_in_external(line, filepath):
         command.append(convert_to_vlc_seconds(start))
     command.append(os.path.normpath(filepath))
 
+    logger.info(" ".join(command))
+
     try:
         proc = subprocess.Popen(command)
         print(f"Opened {filepath} in {get_config().advanced.video_player_path}.")
@@ -286,7 +275,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)
@@ -479,9 +468,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()
 
@@ -521,9 +509,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()
@@ -541,27 +529,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):
@@ -581,7 +571,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()
@@ -599,6 +588,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()
@@ -613,4 +603,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.11.dist-info → gamesentenceminer-2.5.13.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: GameSentenceMiner
-Version: 2.5.11
+Version: 2.5.13
 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.11.dist-info → gamesentenceminer-2.5.13.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=FHm76i7WYEs--szhzZjz0B6DW4JuDQopmjR3RjYBogs,13358
+GameSentenceMiner/config_gui.py,sha256=WVSN239lyVm5GwKzE1HXiCSCu2CNpkcDm8TGKlTJpMc,62093
+GameSentenceMiner/configuration.py,sha256=_lxd1x78NX7tktt6RU7nhO4zkKzSoNKFQ-0r1zwNilU,20208
 GameSentenceMiner/ffmpeg.py,sha256=fzOxrn-a4KqFdUY2oove164CTDOSsdPQtzqRW5f1P7c,12002
 GameSentenceMiner/gametext.py,sha256=LORVdE2WEo1CDI8gonc7qxrhbS4KFKXFQVKjhlkpLbc,7368
-GameSentenceMiner/gsm.py,sha256=XZLc_HwA8Zzxas0M0oFYbjRwgXa7OLPhT2QXhoiUVzQ,25125
+GameSentenceMiner/gsm.py,sha256=OHOoO0U-YMjLnMvwG9zg63jDTcXLg-rG90Cw27l5yBo,24224
 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.11.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-gamesentenceminer-2.5.11.dist-info/METADATA,sha256=7yFwFF9yNCL_KdU8_aYpg6BeWpiQKBjWD1sm6Scl9UI,5436
-gamesentenceminer-2.5.11.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-gamesentenceminer-2.5.11.dist-info/entry_points.txt,sha256=2APEP25DbfjSxGeHtwBstMH8mulVhLkqF_b9bqzU6vQ,65
-gamesentenceminer-2.5.11.dist-info/top_level.txt,sha256=V1hUY6xVSyUEohb0uDoN4UIE6rUZ_JYx8yMyPGX4PgQ,18
-gamesentenceminer-2.5.11.dist-info/RECORD,,
+gamesentenceminer-2.5.13.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+gamesentenceminer-2.5.13.dist-info/METADATA,sha256=WpCjip7e_2FhZIkC9bEgZhknsc9qjoAhZDw5Q8Tq0Uw,5433
+gamesentenceminer-2.5.13.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+gamesentenceminer-2.5.13.dist-info/entry_points.txt,sha256=2APEP25DbfjSxGeHtwBstMH8mulVhLkqF_b9bqzU6vQ,65
+gamesentenceminer-2.5.13.dist-info/top_level.txt,sha256=V1hUY6xVSyUEohb0uDoN4UIE6rUZ_JYx8yMyPGX4PgQ,18
+gamesentenceminer-2.5.13.dist-info/RECORD,,