GameSentenceMiner 2.4.12__py3-none-any.whl → 2.5.1__py3-none-any.whl

GameSentenceMiner/anki.py

@@ -12,8 +12,10 @@ from GameSentenceMiner import obs, util, notification, ffmpeg, gametext
 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.obs import get_current_game
-from GameSentenceMiner.util import remove_html_tags
+from GameSentenceMiner.util import remove_html_and_cloze_tags
 
 audio_in_anki = None
 screenshot_in_anki = None
@@ -25,15 +27,13 @@ first_run = True
 card_queue = []
 
 
-def update_anki_card(last_note, note=None, audio_path='', video_path='', tango='', reuse_audio=False,
+def update_anki_card(last_note: AnkiCard, note=None, audio_path='', video_path='', tango='', reuse_audio=False,
                      should_update_audio=True, ss_time=0, game_line=None):
     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['fields'][get_config().anki.sentence_audio_field][
-        'value'] or get_config().anki.overwrite_audio)
+    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['fields'][get_config().anki.picture_field][
-        'value']
+    last_note.get_field(get_config().anki.picture_field)
 
     if not reuse_audio:
         if update_audio:
@@ -52,7 +52,7 @@ def update_anki_card(last_note, note=None, audio_path='', video_path='', tango='
     image_html = f"<img src=\"{screenshot_in_anki}\">"
     prev_screenshot_html = f"<img src=\"{prev_screenshot_in_anki}\">"
 
-    # note = {'id': last_note['noteId'], 'fields': {}}
+    # note = {'id': last_note.noteId, 'fields': {}}
 
     if update_audio:
         note['fields'][get_config().anki.sentence_audio_field] = audio_html
@@ -75,12 +75,12 @@ def update_anki_card(last_note, note=None, audio_path='', video_path='', tango='
         tags.append(get_current_game().replace(" ", ""))
     if tags:
         tag_string = " ".join(tags)
-        invoke("addTags", tags=tag_string, notes=[last_note['noteId']])
-    logger.info(f"UPDATED ANKI CARD FOR {last_note['noteId']}")
+        invoke("addTags", tags=tag_string, notes=[last_note.noteId])
+    logger.info(f"UPDATED ANKI CARD FOR {last_note.noteId}")
     if get_config().features.notify_on_update:
         notification.send_notification(tango)
     if get_config().features.open_anki_edit:
-        notification.open_anki_card(last_note['noteId'])
+        notification.open_anki_card(last_note.noteId)
 
     if get_config().audio.external_tool:
         open_audio_in_external(f"{get_config().audio.anki_media_collection}/{audio_in_anki}")
@@ -94,10 +94,9 @@ def open_audio_in_external(fileabspath, shell=False):
         subprocess.Popen([get_config().audio.external_tool, fileabspath])
 
 
-def add_image_to_card(last_note, image_path):
+def add_image_to_card(last_note: AnkiCard, image_path):
     global screenshot_in_anki
-    update_picture = get_config().anki.overwrite_picture or not last_note['fields'][get_config().anki.picture_field][
-        'value']
+    update_picture = get_config().anki.overwrite_picture or not last_note.get_field(get_config().anki.picture_field)
 
     if update_picture:
         screenshot_in_anki = store_media_file(image_path)
@@ -106,34 +105,37 @@ def add_image_to_card(last_note, image_path):
 
     image_html = f"<img src=\"{screenshot_in_anki}\">"
 
-    note = {'id': last_note['noteId'], 'fields': {}}
+    note = {'id': last_note.noteId, 'fields': {}}
 
     if update_picture:
         note['fields'][get_config().anki.picture_field] = image_html
 
     invoke("updateNoteFields", note=note)
 
-    logger.info(f"UPDATED IMAGE FOR ANKI CARD {last_note['noteId']}")
+    logger.info(f"UPDATED IMAGE FOR ANKI CARD {last_note.noteId}")
 
 
-def get_initial_card_info(last_note, selected_lines):
-    note = {'id': last_note['noteId'], 'fields': {}}
+def get_initial_card_info(last_note: AnkiCard, selected_lines):
+    note = {'id': last_note.noteId, 'fields': {}}
     if not last_note:
         return note
     game_line = get_text_event(last_note)
 
-    if get_config().audio.mining_from_history_grab_all_audio and get_config().anki.multi_overwrites_sentence:
-        lines = gametext.get_line_and_future_lines(last_note)
-        if lines:
-            note['fields'][get_config().anki.sentence_field] = "".join(lines)
-
     if selected_lines and get_config().anki.multi_overwrites_sentence:
-        note['fields'][get_config().anki.sentence_field] = "".join([line.text for line in selected_lines])
+        sentences = "".join([line.text for line in selected_lines])
+        try:
+            sentence_in_anki = last_note.get_field(get_config().anki.sentence_field)
+            logger.info(f"Attempting Preserve HTML for multi-line: {remove_html_and_cloze_tags(sentence_in_anki)}, {sentences}, {remove_html_and_cloze_tags(sentence_in_anki) in sentences}")
+            sentences = sentences.replace(remove_html_and_cloze_tags(sentence_in_anki), sentence_in_anki)
+        except Exception as e:
+            logger.debug(f"Error preserving HTML for multi-line: {e}")
+            pass
+        note['fields'][get_config().anki.sentence_field] = sentences
 
     if get_config().anki.previous_sentence_field and game_line.prev and not \
-            last_note['fields'][get_config().anki.previous_sentence_field]['value']:
+            last_note.get_field(get_config().anki.previous_sentence_field):
         logger.debug(
-            f"Adding Previous Sentence: {get_config().anki.previous_sentence_field and game_line.prev.text and not last_note['fields'][get_config().anki.previous_sentence_field]['value']}")
+            f"Adding Previous Sentence: {get_config().anki.previous_sentence_field and game_line.prev.text and not last_note.get_field(get_config().anki.previous_sentence_field)}")
         note['fields'][get_config().anki.previous_sentence_field] = game_line.prev.text
     return note
 
@@ -168,11 +170,11 @@ def invoke(action, **params):
     return response['result']
 
 
-def get_last_anki_card():
+def get_last_anki_card() -> AnkiCard | dict:
     added_ids = invoke('findNotes', query='added:1')
     if not added_ids:
         return {}
-    last_note = invoke('notesInfo', notes=[added_ids[-1]])[0]
+    last_note = AnkiCard.from_dict(invoke('notesInfo', notes=[added_ids[-1]])[0])
     return last_note
 
 
@@ -213,14 +215,17 @@ def check_for_new_cards():
         return
     new_card_ids = current_note_ids - previous_note_ids
     if new_card_ids and not first_run:
-        update_new_card()
+        try:
+            update_new_card()
+        except Exception as e:
+            logger.error("Error updating new card, Reason:", e)
     first_run = False
     previous_note_ids = current_note_ids  # Update the list of known notes
 
 
 def update_new_card():
     last_card = get_last_anki_card()
-    if not check_tags_for_should_update(last_card):
+    if not last_card or not check_tags_for_should_update(last_card):
         return
     use_prev_audio = sentence_is_same_as_previous(last_card)
     logger.info(f"last mined line: {util.get_last_mined_line()}, current sentence: {get_sentence(last_card)}")
@@ -228,8 +233,9 @@ def update_new_card():
     if get_config().obs.get_game_from_scene:
         obs.update_current_game()
     if use_prev_audio:
+        lines = get_utility_window().get_selected_lines()
         with util.lock:
-            update_anki_card(last_card, note=get_initial_card_info(last_card, []), reuse_audio=True)
+            update_anki_card(last_card, note=get_initial_card_info(last_card, lines), reuse_audio=True)
     else:
         logger.info("New card(s) detected! Added to Processing Queue!")
         card_queue.append(last_card)
@@ -239,20 +245,20 @@ def update_new_card():
 def sentence_is_same_as_previous(last_card):
     if not util.get_last_mined_line():
         return False
-    return remove_html_tags(get_sentence(last_card)) == remove_html_tags(util.get_last_mined_line())
+    return remove_html_and_cloze_tags(get_sentence(last_card)) == remove_html_and_cloze_tags(util.get_last_mined_line())
 
 def get_sentence(card):
-    return card['fields'][get_config().anki.sentence_field]['value']
+    return card.get_field(get_config().anki.sentence_field)
 
 def check_tags_for_should_update(last_card):
     if get_config().anki.tags_to_check:
         found = False
-        for tag in last_card['tags']:
+        for tag in last_card.tags:
             if tag.lower() in get_config().anki.tags_to_check:
                 found = True
                 break
         if not found:
-            logger.info(f"Card not tagged properly! Not updating! Note Tags: {last_card['tags']}, Tags_To_Check {get_config().anki.tags_to_check}")
+            logger.info(f"Card not tagged properly! Not updating! Note Tags: {last_card.tags}, Tags_To_Check {get_config().anki.tags_to_check}")
         return found
     else:
         return True

GameSentenceMiner/config_gui.py

@@ -6,6 +6,7 @@ import ttkbootstrap as ttk
 
 from GameSentenceMiner import obs, configuration
 from GameSentenceMiner.configuration import *
+from GameSentenceMiner.downloader.download_tools import download_ocenaudio_if_needed
 from GameSentenceMiner.electron_messaging import signal_restart_settings_change
 from GameSentenceMiner.package import get_current_version, get_latest_version
 
@@ -85,6 +86,7 @@ class ConfigApp:
         on_save.append(func)
 
     def show(self):
+        logger.info("Showing Configuration Window")
         obs.update_current_game()
         self.reload_settings()
         if self.window is not None:
@@ -106,6 +108,7 @@ class ConfigApp:
                 use_clipboard=self.clipboard_enabled.get(),
                 websocket_uri=self.websocket_uri.get(),
                 open_config_on_startup=self.open_config_on_startup.get(),
+                open_multimine_on_startup=self.open_multimine_on_startup.get(),
                 texthook_replacement_regex=self.texthook_replacement_regex.get()
             ),
             paths=Paths(
@@ -160,7 +163,6 @@ class ConfigApp:
                 ffmpeg_reencode_options=self.ffmpeg_reencode_options.get(),
                 external_tool = self.external_tool.get(),
                 anki_media_collection=self.anki_media_collection.get(),
-                mining_from_history_grab_all_audio=self.mining_from_history_grab_all_audio.get()
             ),
             obs=OBS(
                 enabled=self.obs_enabled.get(),
@@ -184,7 +186,9 @@ class ConfigApp:
                 vosk_url='https://alphacephei.com/vosk/models/vosk-model-ja-0.22.zip' if self.vosk_url.get() == VOSK_BASE else "https://alphacephei.com/vosk/models/vosk-model-small-ja-0.22.zip",
                 selected_vad_model=self.selected_vad_model.get(),
                 backup_vad_model=self.backup_vad_model.get(),
-                trim_beginning=self.vad_trim_beginning.get()
+                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(),
             )
         )
 
@@ -215,6 +219,7 @@ class ConfigApp:
             signal_restart_settings_change()
         settings_saved = True
         configuration.reload_config()
+        self.settings = get_config()
         for func in on_save:
             func()
 
@@ -225,8 +230,9 @@ class ConfigApp:
 
         self.window.title("GameSentenceMiner Configuration - " + current_config.name)
 
-        if current_config.name != self.settings.name:
-            logger.info("Profile changed, reloading settings.")
+
+        if current_config.name != self.settings.name or self.settings.config_changed(current_config):
+            logger.info("Config changed, reloading settings.")
             self.master_config = new_config
             self.settings = current_config
             for frame in self.notebook.winfo_children():
@@ -296,6 +302,13 @@ class ConfigApp:
         self.add_label_and_increment_row(general_frame, "Whether to open config when the script starts.",
                                          row=self.current_row, column=2)
 
+        ttk.Label(general_frame, text="Open Multimine on Startup:").grid(row=self.current_row, column=0, sticky='W')
+        self.open_multimine_on_startup = tk.BooleanVar(value=self.settings.general.open_multimine_on_startup)
+        ttk.Checkbutton(general_frame, variable=self.open_multimine_on_startup).grid(row=self.current_row, column=1,
+                                                                                  sticky='W')
+        self.add_label_and_increment_row(general_frame, "Whether to open multimining window when the script starts.",
+                                         row=self.current_row, column=2)
+
         ttk.Label(general_frame, text="Current Version:").grid(row=self.current_row, column=0, sticky='W')
         self.current_version = ttk.Label(general_frame, text=get_current_version())
         self.current_version.grid(row=self.current_row, column=1)
@@ -365,6 +378,17 @@ class ConfigApp:
         self.add_label_and_increment_row(vad_frame, "Trim the beginning of the audio based on Voice Detection Results",
                                          row=self.current_row, column=2)
 
+        ttk.Label(vad_frame, text="Beginning Offset After Beginning Trim:").grid(row=self.current_row, column=0, sticky='W')
+        self.vad_beginning_offset = ttk.Entry(vad_frame)
+        self.vad_beginning_offset.insert(0, str(self.settings.vad.beginning_offset))
+        self.vad_beginning_offset.grid(row=self.current_row, column=1)
+        self.add_label_and_increment_row(vad_frame, 'Beginning offset after VAD Trim, Only active if "Trim Beginning" is ON. Negative values = more time at the beginning', row=self.current_row, column=2)
+
+        ttk.Label(vad_frame, text="Add Audio on No Results:").grid(row=self.current_row, column=0, sticky='W')
+        self.add_audio_on_no_results = tk.BooleanVar(value=self.settings.vad.add_audio_on_no_results)
+        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)
+
 
     @new_tab
     def create_paths_tab(self):
@@ -740,12 +764,14 @@ class ConfigApp:
                                          row=self.current_row,
                                          column=2)
 
-        ttk.Label(audio_frame, text="Grab all Future Audio when Mining from History:").grid(row=self.current_row, column=0, sticky='W')
-        self.mining_from_history_grab_all_audio = tk.BooleanVar(
-            value=self.settings.audio.mining_from_history_grab_all_audio)
-        ttk.Checkbutton(audio_frame, variable=self.mining_from_history_grab_all_audio).grid(row=self.current_row, column=1, sticky='W')
-        self.add_label_and_increment_row(audio_frame, "When mining from History, this option will allow the script to get all audio from that line to the current time.", row=self.current_row,
-                                         column=2)
+        ttk.Button(audio_frame, text="Install Ocenaudio", command=self.download_and_install_ocen).grid(
+            row=self.current_row, column=0, pady=5)
+        ttk.Button(audio_frame, text="Get Anki Media Collection",
+                   command=self.set_default_anki_media_collection).grid(row=self.current_row, column=1, pady=5)
+        self.add_label_and_increment_row(audio_frame,
+                                         "These Two buttons both help set up the External Audio Editing Tool. The first one downloads and installs OcenAudio, a free audio editing software. The second one sets the default Anki media collection path.",
+                                         row=self.current_row,
+                                         column=3)
 
     @new_tab
     def create_obs_tab(self):
@@ -898,6 +924,24 @@ class ConfigApp:
     def show_error_box(self, title, message):
         messagebox.showerror(title, message)
 
+    def download_and_install_ocen(self):
+        confirm = messagebox.askyesno("Download OcenAudio?", "Would you like to download and install OcenAudio? It is a free audio editing software that works extremely well with GSM.")
+        if confirm:
+            exe_path = download_ocenaudio_if_needed()
+            messagebox.showinfo("OcenAudio Downloaded", f"OcenAudio has been downloaded and installed. You can find it at {exe_path}.")
+            self.external_tool.delete(0, tk.END)
+            self.external_tool.insert(0, exe_path)
+            self.save_settings()
+
+    def set_default_anki_media_collection(self):
+        confirm = messagebox.askyesno("Set Default Anki Media Collection?", "Would you like to set the default Anki media collection path? This will help the script find the media collection for external trimming.\n\nDefault: %APPDATA%/Anki2/User 1/collection.media")
+        if confirm:
+            default_path = get_default_anki_media_collection_path()
+            if default_path != self.settings.audio.external_tool:
+                self.anki_media_collection.delete(0, tk.END)
+                self.anki_media_collection.insert(0, default_path)
+                self.save_settings()
+
 
 if __name__ == '__main__':
     root = ttk.Window(themename='darkly')

GameSentenceMiner/configuration.py

@@ -42,6 +42,7 @@ class General:
     use_clipboard: bool = True
     websocket_uri: str = 'localhost:6677'
     open_config_on_startup: bool = False
+    open_multimine_on_startup: bool = False
     texthook_replacement_regex: str = ""
 
 
@@ -116,7 +117,6 @@ class Audio:
     ffmpeg_reencode_options: str = ''
     external_tool: str = ""
     anki_media_collection: str = ""
-    mining_from_history_grab_all_audio: bool = False
 
 
 @dataclass_json
@@ -150,6 +150,8 @@ class VAD:
     selected_vad_model: str = SILERO
     backup_vad_model: str = OFF
     trim_beginning: bool = False
+    beginning_offset: float = -0.25
+    add_audio_on_no_results: bool = False
 
 
 @dataclass_json
@@ -244,9 +246,13 @@ class ProfileConfig:
                 previous.obs.host != self.obs.host,
                 previous.obs.port != self.obs.port
                 ]):
+            logger.info("Restart Required for Some Settings that were Changed")
             return True
         return False
 
+    def config_changed(self, new: 'ProfileConfig') -> bool:
+        return self != new
+
 
 @dataclass_json
 @dataclass
@@ -276,6 +282,17 @@ class Config:
         return self.configs[DEFAULT_CONFIG]
 
 
+def get_default_anki_path():
+    if platform == 'win32':  # Windows
+        base_dir = os.getenv('APPDATA')
+    else:  # macOS and Linux
+        base_dir = '~/.local/share/'
+    config_dir = os.path.join(base_dir, 'Anki2')
+    return config_dir
+
+def get_default_anki_media_collection_path():
+    return os.path.join(get_default_anki_path(), 'User 1', 'collection.media')
+
 def get_app_directory():
     if platform == 'win32':  # Windows
         appdata_dir = os.getenv('APPDATA')
@@ -377,11 +394,19 @@ def reload_config():
 def get_master_config():
     return config_instance
 
+def save_full_config(config):
+    with open(get_config_path(), 'w') as file:
+        json.dump(config.to_dict(), file, indent=4)
+
+def save_current_config(config):
+    global config_instance
+    config_instance.set_config_for_profile(config_instance.current_profile, config)
+    save_full_config(config_instance)
+
 def switch_profile_and_save(profile_name):
     global config_instance
     config_instance.current_profile = profile_name
-    with open(get_config_path(), 'w') as file:
-        json.dump(config_instance.to_dict(), file, indent=4)
+    save_full_config(config_instance)
     return config_instance.get_config()
 
 

GameSentenceMiner/downloader/download_tools.py

@@ -149,10 +149,39 @@ def download_ffmpeg_if_needed():
                 with source, target:
                     shutil.copyfileobj(source, target)
     logger.info(f"FFmpeg extracted to {ffmpeg_dir}.")
+
+def download_ocenaudio_if_needed():
+    ocenaudio_dir = os.path.join(get_app_directory(), 'ocenaudio', 'ocenaudio')
+    ocenaudio_exe_path = os.path.join(ocenaudio_dir, 'ocenaudio.exe')
+    if os.path.exists(ocenaudio_dir) and os.path.exists(ocenaudio_exe_path):
+        logger.info(f"Ocenaudio already installed at {ocenaudio_dir}.")
+        return ocenaudio_exe_path
+
+    if os.path.exists(ocenaudio_dir) and not os.path.exists(ocenaudio_exe_path):
+        logger.info("Ocenaudio directory exists but executable is missing. Re-downloading Ocenaudio...")
+        shutil.rmtree(ocenaudio_dir)
+
+    ocenaudio_url = "https://www.ocenaudio.com/downloads/ocenaudio_windows64.zip"
+
+    download_dir = os.path.join(get_app_directory(), "downloads")
+    os.makedirs(download_dir, exist_ok=True)
+    ocenaudio_archive = os.path.join(download_dir, "ocenaudio.zip")
+
+    logger.info(f"Downloading Ocenaudio from {ocenaudio_url}...")
+    urllib.request.urlretrieve(ocenaudio_url, ocenaudio_archive)
+    logger.info(f"Ocenaudio downloaded. Extracting to {ocenaudio_dir}...")
+
+    os.makedirs(ocenaudio_dir, exist_ok=True)
+    with zipfile.ZipFile(ocenaudio_archive, 'r') as zip_ref:
+        zip_ref.extractall(ocenaudio_dir)
+
+    logger.info(f"Ocenaudio extracted to {ocenaudio_dir}.")
+    return ocenaudio_exe_path
+
 def main():
-    # Run dependency checks
     download_obs_if_needed()
     download_ffmpeg_if_needed()
+    download_ocenaudio_if_needed()
 
 if __name__ == "__main__":
     main()

GameSentenceMiner/ffmpeg.py

@@ -200,7 +200,7 @@ def trim_audio_based_on_last_line(untrimmed_audio, video_path, game_line, next_l
     ffmpeg_command = ffmpeg_base_command_list + [
         "-i", untrimmed_audio,
         "-ss", start_trim_time]
-    if next_line and next_line > game_line.time and not get_config().audio.mining_from_history_grab_all_audio:
+    if next_line and next_line > game_line.time:
         end_total_seconds = total_seconds + (next_line - game_line.time).total_seconds() + 1
         hours, remainder = divmod(end_total_seconds, 3600)
         minutes, seconds = divmod(remainder, 60)
@@ -290,12 +290,14 @@ def convert_audio_to_wav(input_audio, output_wav):
 def trim_audio(input_audio, start_time, end_time, output_audio):
     command = ffmpeg_base_command_list.copy()
 
+    command.extend(['-i', input_audio])
+
     if get_config().vad.trim_beginning and start_time > 0:
+        logger.info(f"trimming beginning to {start_time}")
         command.extend(['-ss', f"{start_time:.2f}"])
 
     command.extend([
         '-to', f"{end_time:.2f}",
-        '-i', input_audio,
         '-c', 'copy',
         output_audio
     ])

GameSentenceMiner/gametext.py

@@ -3,17 +3,18 @@ import re
 import threading
 import time
 from datetime import datetime
-from typing import Callable
 
 import pyperclip
 import websockets
 
 from GameSentenceMiner import util
+from GameSentenceMiner.model import AnkiCard
 from GameSentenceMiner.configuration import *
 from GameSentenceMiner.configuration import get_config, logger
-from GameSentenceMiner.util import remove_html_tags
+from GameSentenceMiner.util import remove_html_and_cloze_tags
 from difflib import SequenceMatcher
 
+from GameSentenceMiner.utility_gui import get_utility_window
 
 initial_time = datetime.now()
 current_line = ''
@@ -22,7 +23,6 @@ current_line_time = datetime.now()
 
 reconnecting = False
 websocket_connected = False
-multi_mine_event_bus: Callable[[str, datetime], None] = None
 
 @dataclass
 class GameLine:
@@ -89,14 +89,17 @@ class ClipboardMonitor(threading.Thread):
         # Initial clipboard content
         current_line = pyperclip.paste()
 
+        skip_next_clipboard = False
         while True:
             if websocket_connected:
                 time.sleep(1)
+                skip_next_clipboard = True
                 continue
             current_clipboard = pyperclip.paste()
 
-            if current_clipboard != current_line:
+            if current_clipboard != current_line and not skip_next_clipboard:
                 handle_new_text_event(current_clipboard)
+                skip_next_clipboard = False
 
             time.sleep(0.05)
 
@@ -138,7 +141,7 @@ def handle_new_text_event(current_clipboard):
     logger.info(f"Line Received: {current_line_after_regex}")
     current_line_time = datetime.now()
     line_history.add_line(current_line_after_regex)
-    multi_mine_event_bus(line_history[-1])
+    get_utility_window().add_text(line_history[-1])
 
 
 def reset_line_hotkey_pressed():
@@ -152,9 +155,7 @@ def run_websocket_listener():
     asyncio.run(listen_websocket())
 
 
-def start_text_monitor(send_to_mine_event_bus):
-    global multi_mine_event_bus
-    multi_mine_event_bus = send_to_mine_event_bus
+def start_text_monitor():
     if get_config().general.use_websocket:
         threading.Thread(target=run_websocket_listener, daemon=True).start()
     if get_config().general.use_clipboard:
@@ -169,24 +170,26 @@ def similar(a, b):
 def one_contains_the_other(a, b):
     return a in b or b in a
 
+def lines_match(a, b):
+    similarity = similar(a, b)
+    logger.debug(f"Comparing: {a} with {b} - Similarity: {similarity}, Or One contains the other: {one_contains_the_other(a, b)}")
+    return similar(a, b) >= 0.60 or one_contains_the_other(a, b)
 
 def get_text_event(last_note) -> GameLine:
     lines = line_history.values
 
-    if not last_note:
-        return lines[-1]
-
     if not lines:
         raise Exception("No lines in history. Text is required from either clipboard or websocket for GSM to work. Please check your setup/config.")
 
-    sentence = last_note['fields'][get_config().anki.sentence_field]['value']
+    if not last_note:
+        return lines[-1]
+
+    sentence = last_note.get_field(get_config().anki.sentence_field)
     if not sentence:
         return lines[-1]
 
     for line in reversed(lines):
-        similarity = similar(remove_html_tags(sentence), line.text)
-        logger.debug(f"Comparing: {remove_html_tags(sentence)} with {line.text} - Similarity: {similarity}")
-        if similarity >= 0.60 or one_contains_the_other(line.text, remove_html_tags(sentence)):
+        if lines_match(line.text, remove_html_and_cloze_tags(sentence)):
             return line
 
     logger.debug("Couldn't find a match in history, using last event")
@@ -197,28 +200,25 @@ def get_line_and_future_lines(last_note):
     if not last_note:
         return []
 
-    sentence = last_note['fields'][get_config().anki.sentence_field]['value']
+    sentence = last_note.get_field(get_config().anki.sentence_field)
     found_lines = []
     if sentence:
         found = False
         for line in line_history.values:
-            similarity = similar(remove_html_tags(sentence), line.text)
-            logger.debug(f"Comparing: {remove_html_tags(sentence)} with {line.text} - Similarity: {similarity}")
             if found:
                 found_lines.append(line.text)
-            if similarity >= 0.60 or one_contains_the_other(line.text, remove_html_tags(sentence)):  # 80% similarity threshold
+            if lines_match(line.text, remove_html_and_cloze_tags(sentence)):  # 80% similarity threshold
                 found = True
                 found_lines.append(line.text)
     return found_lines
 
-def get_mined_line(last_note, lines):
+def get_mined_line(last_note: AnkiCard, lines):
     if not last_note:
         return lines[-1]
 
-    sentence = last_note['fields'][get_config().anki.sentence_field]['value']
+    sentence = last_note.get_field(get_config().anki.sentence_field)
     for line in lines:
-        similarity = similar(remove_html_tags(sentence), line.text)
-        if similarity >= 0.60 or one_contains_the_other(line.text, remove_html_tags(sentence)):
+        if lines_match(line.text, remove_html_and_cloze_tags(sentence)):
             return line
     return lines[-1]
 

GameSentenceMiner/gsm.py

@@ -18,13 +18,13 @@ from GameSentenceMiner import gametext
 from GameSentenceMiner import notification
 from GameSentenceMiner import obs
 from GameSentenceMiner import util
-from GameSentenceMiner import utility_gui
 from GameSentenceMiner.configuration import *
 from GameSentenceMiner.downloader.download_tools import download_obs_if_needed, download_ffmpeg_if_needed
 from GameSentenceMiner.electron_messaging import signal_restart_settings_change
 from GameSentenceMiner.ffmpeg import get_audio_and_trim
 from GameSentenceMiner.gametext import get_text_event, get_mined_line
 from GameSentenceMiner.util import *
+from GameSentenceMiner.utility_gui import init_utility_window, get_utility_window
 from GameSentenceMiner.vad import vosk_helper, silero_trim, whisper_helper
 
 if is_windows():
@@ -33,7 +33,6 @@ if is_windows():
 obs_process = None
 procs_to_close = []
 settings_window: config_gui.ConfigApp = None
-utility_window: utility_gui.UtilityApp = None
 obs_paused = False
 icon: Icon
 menu: Menu
@@ -91,7 +90,7 @@ class VideoToAudioHandler(FileSystemEventHandler):
                     if get_config().anki.update_anki:
                         last_note = anki.get_last_anki_card()
                     if get_config().features.backfill_audio:
-                        last_note = anki.get_cards_by_sentence(gametext.current_line)
+                        last_note = anki.get_cards_by_sentence(gametext.current_line_after_regex)
                 line_cutoff = None
                 start_line = None
                 mined_line = get_text_event(last_note)
@@ -100,21 +99,21 @@ class VideoToAudioHandler(FileSystemEventHandler):
                     if mined_line.next:
                         line_cutoff = mined_line.next.time
 
-                if utility_window.lines_selected():
-                    lines = utility_window.get_selected_lines()
+                if get_utility_window().lines_selected():
+                    lines = get_utility_window().get_selected_lines()
                     start_line = lines[0]
                     mined_line = get_mined_line(last_note, lines)
-                    line_cutoff = utility_window.get_next_line_timing()
+                    line_cutoff = get_utility_window().get_next_line_timing()
 
                 ss_timing = 0
                 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)
                 if last_note:
-                    logger.debug(json.dumps(last_note))
+                    logger.debug(last_note.to_json())
 
-                note = anki.get_initial_card_info(last_note, utility_window.get_selected_lines())
+                note = anki.get_initial_card_info(last_note, get_utility_window().get_selected_lines())
 
-                tango = last_note['fields'][get_config().anki.word_field]['value'] if last_note else ''
+                tango = last_note.get_field(get_config().anki.word_field) if last_note else ''
 
                 if get_config().anki.sentence_audio_field:
                     logger.debug("Attempting to get audio from video")
@@ -127,26 +126,23 @@ class VideoToAudioHandler(FileSystemEventHandler):
                     should_update_audio = False
                     vad_trimmed_audio = ""
                     logger.info("No SentenceAudio Field in config, skipping audio processing!")
-                    # Only update sentenceaudio if it's not present. Want to avoid accidentally overwriting sentence audio
-                try:
-                    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,
-                                              should_update_audio=should_update_audio,
-                                              ss_time=ss_timing,
-                                              game_line=start_line)
-                    elif get_config().features.notify_on_update and should_update_audio:
-                        notification.send_audio_generated_notification(vad_trimmed_audio)
-                except Exception as e:
-                    logger.exception(f"Card failed to update! Maybe it was removed? {e}")
+                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,
+                                          should_update_audio=should_update_audio,
+                                          ss_time=ss_timing,
+                                          game_line=start_line)
+                elif get_config().features.notify_on_update and should_update_audio:
+                    notification.send_audio_generated_notification(vad_trimmed_audio)
         except Exception as e:
-            logger.exception(f"Some error was hit catching to allow further work to be done: {e}")
-            # settings_window.show_error_box("Error", f"Some error was hit, check logs for more info: {e}")
+            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
-        utility_window.reset_checkboxes()
+        get_utility_window().reset_checkboxes()
 
     @staticmethod
     def get_audio(game_line, next_line_time, video_path):
@@ -177,6 +173,10 @@ class VideoToAudioHandler(FileSystemEventHandler):
                     case configuration.WHISPER:
                         should_update_audio = whisper_helper.process_audio_with_whisper(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
+                should_update_audio = True
         if get_config().audio.ffmpeg_reencode_options and os.path.exists(vad_trimmed_audio):
             ffmpeg.reencode_file_with_user_config(vad_trimmed_audio, final_audio_output,
                                                   get_config().audio.ffmpeg_reencode_options)
@@ -196,7 +196,7 @@ def initialize(reloading=False):
                 obs_process = obs.start_obs()
             obs.connect_to_obs(start_replay=True)
             anki.start_monitoring_anki()
-        gametext.start_text_monitor(utility_window.add_text)
+        gametext.start_text_monitor()
         os.makedirs(get_config().paths.folder_to_watch, exist_ok=True)
         os.makedirs(get_config().paths.screenshot_destination, exist_ok=True)
         os.makedirs(get_config().paths.audio_destination, exist_ok=True)
@@ -237,9 +237,9 @@ def get_screenshot():
                 last_note = anki.get_cards_by_sentence(gametext.current_line)
             if last_note:
                 anki.add_image_to_card(last_note, encoded_image)
-                notification.send_screenshot_updated(last_note['fields'][get_config().anki.word_field]['value'])
+                notification.send_screenshot_updated(last_note.get_field(get_config().anki.word_field))
                 if get_config().features.open_anki_edit:
-                    notification.open_anki_card(last_note['noteId'])
+                    notification.open_anki_card(last_note.noteId)
             else:
                 notification.send_screenshot_saved(encoded_image)
         else:
@@ -272,7 +272,7 @@ def open_settings():
 
 def open_multimine():
     obs.update_current_game()
-    utility_window.show()
+    get_utility_window().show()
 
 
 def open_log():
@@ -337,11 +337,13 @@ def switch_profile(icon, item):
         logger.error("You cannot switch to the currently active profile!")
         return
     logger.info(f"Switching to profile: {item.text}")
+    prev_config = get_config()
     get_master_config().current_profile = item.text
     switch_profile_and_save(item.text)
     settings_window.reload_settings()
     update_icon()
-    signal_restart_settings_change()
+    if get_config().restart_required(prev_config):
+        signal_restart_settings_change()
 
 
 def run_tray():
@@ -459,12 +461,12 @@ def handle_exit():
 
 
 def main(reloading=False, do_config_input=True):
-    global root, settings_window, utility_window
+    global root, settings_window
     logger.info("Script started.")
     util.run_new_thread(check_for_stdin)
     root = ttk.Window(themename='darkly')
     settings_window = config_gui.ConfigApp(root)
-    utility_window = utility_gui.UtilityApp(root)
+    init_utility_window(root)
     initialize(reloading)
     util.run_new_thread(run_tray)
     initial_checks()
@@ -486,6 +488,8 @@ def main(reloading=False, do_config_input=True):
     try:
         if get_config().general.open_config_on_startup:
             root.after(0, settings_window.show)
+        if get_config().general.open_multimine_on_startup:
+            root.after(0, get_utility_window().show)
         settings_window.add_save_hook(update_icon)
         settings_window.on_exit = exit_program
         root.mainloop()

GameSentenceMiner/model.py

@@ -3,6 +3,8 @@ from typing import Optional, List
 
 from dataclasses_json import dataclass_json
 
+from GameSentenceMiner.configuration import get_config, logger, save_current_config
+
 
 # OBS
 @dataclass_json
@@ -82,3 +84,73 @@ class SceneItemsResponse:
 #     videoActive: bool
 #     videoShowing: bool
 
+@dataclass_json
+@dataclass
+class AnkiCard:
+    noteId: int
+    profile: str
+    tags: list[str]
+    fields: dict[str, dict[str, str]]
+    modelName: str
+    mod: int
+    cards: list[int]
+    alternatives = {
+        "word_field": ["Front", "Word", "TargetWord", "Expression"],
+        "sentence_field": ["Example", "Context", "Back", "Sentence"],
+        "picture_field": ["Image", "Visual", "Media", "Picture", "Screenshot", 'AnswerImage'],
+        "sentence_audio_field": ["SentenceAudio"]
+    }
+
+    def get_field(self, field_name: str) -> str:
+        if self.has_field(field_name):
+            return self.fields[field_name]['value']
+        else:
+            raise ValueError(f"Field '{field_name}' not found in AnkiCard. Please make sure your Anki Field Settings in GSM Match your fields in your Anki Note!")
+
+    def has_field (self, field_name: str) -> bool:
+        return field_name in self.fields
+
+    def __post_init__(self):
+        config = get_config()
+        changes_found = False
+        if not self.has_field(config.anki.word_field):
+            found_alternative_field, field = self.find_field(config.anki.word_field, "word_field")
+            if found_alternative_field:
+                logger.warning(f"{config.anki.word_field} Not found in Anki Card! Saving alternative field '{field}' for word_field to settings.")
+                config.anki.word_field = field
+                changes_found = True
+
+        if not self.has_field(config.anki.sentence_field):
+            found_alternative_field, field = self.find_field(config.anki.sentence_field, "sentence_field")
+            if found_alternative_field:
+                logger.warning(f"{config.anki.sentence_field} Not found in Anki Card! Saving alternative field '{field}' for sentence_field to settings.")
+                config.anki.sentence_field = field
+                changes_found = True
+
+        if not self.has_field(config.anki.picture_field):
+            found_alternative_field, field = self.find_field(config.anki.picture_field, "picture_field")
+            if found_alternative_field:
+                logger.warning(f"{config.anki.picture_field} Not found in Anki Card! Saving alternative field '{field}' for picture_field to settings.")
+                config.anki.picture_field = field
+                changes_found = True
+
+        if not self.has_field(config.anki.sentence_audio_field):
+            found_alternative_field, field = self.find_field(config.anki.sentence_audio_field, "sentence_audio_field")
+            if found_alternative_field:
+                logger.warning(f"{config.anki.sentence_audio_field} Not found in Anki Card! Saving alternative field '{field}' for sentence_audio_field to settings.")
+                config.anki.sentence_audio_field = field
+                changes_found = True
+
+        if changes_found:
+            save_current_config(config)
+
+    def find_field(self, field, field_type):
+        if field in self.fields:
+            return False, field
+
+        for alt_field in self.alternatives[field_type]:
+            for key in self.fields:
+                if alt_field.lower() == key.lower():
+                    return True, key
+
+        return False, None

GameSentenceMiner/notification.py

@@ -69,3 +69,12 @@ def send_check_obs_notification(reason):
         app_name="GameSentenceMiner",
         timeout=5  # Notification disappears after 5 seconds
     )
+
+
+def send_error_no_anki_update():
+    notification.notify(
+        title="Error",
+        message=f"Anki Card not updated, Check Console for Reason!",
+        app_name="GameSentenceMiner",
+        timeout=5  # Notification disappears after 5 seconds
+    )

GameSentenceMiner/util.py

@@ -143,6 +143,6 @@ def is_windows():
 #     else:
 #         return subprocess.run(command, shell=shell, input=input, capture_output=capture_output, timeout=timeout,
 #                               check=check, **kwargs)
-def remove_html_tags(text):
-    clean_text = re.sub(r'<.*?>', '', text)
-    return clean_text
+def remove_html_and_cloze_tags(text):
+    text = re.sub(r'<.*?>', '', re.sub(r'{{c\d+::(.*?)(::.*?)?}}', r'\1', text))
+    return text

GameSentenceMiner/utility_gui.py

@@ -1,13 +1,14 @@
+import json
+import os
 import tkinter as tk
 from tkinter import ttk
 
-from GameSentenceMiner.configuration import logger
+from GameSentenceMiner.configuration import logger, get_app_directory
 
 
 class UtilityApp:
     def __init__(self, root):
         self.root = root
-
         self.items = []
         self.checkboxes = []
         self.multi_mine_window = None  # Store the multi-mine window reference
@@ -15,32 +16,60 @@ class UtilityApp:
 
         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 = {
+                "x": self.multi_mine_window.winfo_x(),
+                "y": self.multi_mine_window.winfo_y(),
+                "width": self.multi_mine_window.winfo_width(),
+                "height": self.multi_mine_window.winfo_height()
+            }
+            print(config)
+            with open(self.config_file, "w") as f:
+                json.dump(config, f)
+
+    def load_window_config(self):
+        if os.path.exists(self.config_file):
+            with open(self.config_file, "r") as f:
+                config = json.load(f)
+                self.window_x = config.get("x", 100)
+                self.window_y = config.get("y", 100)
+                self.window_width = config.get("width", 800)
+                self.window_height = config.get("height", 400)
+        else:
+            self.window_x = 100
+            self.window_y = 100
+            self.window_width = 800
+            self.window_height = 400
 
-    # def show(self):
-    #     if self.multi_mine_window is None or not tk.Toplevel.winfo_exists(self.multi_mine_window):
-    #         self.multi_mine_window = tk.Toplevel(self.root)
-    #         self.multi_mine_window.title("Multi-Mine Window")
-    #         self.update_multi_mine_window()
-    #
     def show(self):
-        """ Open the multi-mine window only if it doesn't exist. """
         if not self.multi_mine_window or not tk.Toplevel.winfo_exists(self.multi_mine_window):
-            logger.info("opening multi-mine_window")
             self.multi_mine_window = tk.Toplevel(self.root)
             self.multi_mine_window.title("Multi Mine Window")
 
-            self.multi_mine_window.minsize(800, 400)  # Set a minimum size to prevent shrinking too
+            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)
 
-            # Add existing items
             for line, var in self.items:
                 self.add_checkbox_to_gui(line, var)
+
+            self.multi_mine_window.protocol("WM_DELETE_WINDOW", self.on_close)
         else:
             self.multi_mine_window.deiconify()
             self.multi_mine_window.lift()
 
+    def on_close(self):
+        self.save_window_config()
+        self.multi_mine_window.withdraw()
+
     def add_text(self, line):
         if line.text:
             var = tk.BooleanVar()
@@ -121,6 +150,16 @@ class UtilityApp:
         #     for checkbox in self.checkboxes:
         #         checkbox.set(False)
 
+def init_utility_window(root):
+    global utility_window
+    utility_window = UtilityApp(root)
+    return utility_window
+
+def get_utility_window():
+    return utility_window
+
+utility_window: UtilityApp = None
+
 
 if __name__ == "__main__":
     root = tk.Tk()

GameSentenceMiner/vad/silero_trim.py

@@ -38,6 +38,6 @@ def process_audio_with_silero(input_audio, output_audio):
     end_time = voice_activity[-1]['end'] if voice_activity else 0
 
     # Trim the audio using FFmpeg
-    ffmpeg.trim_audio(input_audio, start_time, end_time + get_config().audio.end_offset, output_audio)
+    ffmpeg.trim_audio(input_audio, start_time + get_config().vad.beginning_offset, end_time + get_config().audio.end_offset, output_audio)
     logger.info(f"Trimmed audio saved to: {output_audio}")
     return True

GameSentenceMiner/vad/vosk_helper.py

@@ -140,7 +140,7 @@ def process_audio_with_vosk(input_audio, output_audio):
     logger.info(f"Trimmed End of Audio to {end_time} seconds:")
 
     # Trim the audio using FFmpeg
-    ffmpeg.trim_audio(input_audio, start_time, end_time + get_config().audio.end_offset, output_audio)
+    ffmpeg.trim_audio(input_audio, start_time + get_config().vad.beginning_offset, end_time + get_config().audio.end_offset, output_audio)
     logger.info(f"Trimmed audio saved to: {output_audio}")
     return True
 

GameSentenceMiner/vad/whisper_helper.py

@@ -87,7 +87,7 @@ def process_audio_with_whisper(input_audio, output_audio):
     logger.info(f"Trimmed End of Audio to {end_time} seconds:")
 
     # Trim the audio using FFmpeg
-    ffmpeg.trim_audio(input_audio, start_time, end_time + get_config().audio.end_offset, output_audio)
+    ffmpeg.trim_audio(input_audio, start_time + get_config().vad.beginning_offset, end_time + get_config().audio.end_offset, output_audio)
     logger.info(f"Trimmed audio saved to: {output_audio}")
     return True
 

{gamesentenceminer-2.4.12.dist-info → gamesentenceminer-2.5.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: GameSentenceMiner
-Version: 2.4.12
+Version: 2.5.1
 Summary: A tool for mining sentences from games. Update: Multi-Line Mining! Fixed!
 Author-email: Beangate <bpwhelan95@gmail.com>
 License: MIT License
@@ -32,6 +32,7 @@ Requires-Dist: dataclasses_json~=0.6.7
 Requires-Dist: numpy
 Requires-Dist: pystray
 Requires-Dist: pywin32; sys_platform == "win32"
+Dynamic: license-file
 
 # Game Sentence Miner
 

gamesentenceminer-2.5.1.dist-info/RECORD

@@ -0,0 +1,27 @@
+GameSentenceMiner/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+GameSentenceMiner/anki.py,sha256=_jr6q3tOSP-7YGaY9cVz5v3508T_V2JINJjDYbp1YS0,11495
+GameSentenceMiner/config_gui.py,sha256=PzzLX-OwK71U5JSFaxup0ec0oWBWaF6AeCXs0m13HK0,56762
+GameSentenceMiner/configuration.py,sha256=kyvNCkZSZcqXbGjak8lb_GyhhjN8tIfb7eEfusz_M8A,16038
+GameSentenceMiner/electron_messaging.py,sha256=fBk9Ipo0jg2OZwYaKe1Qsm05P2ftrdTRGgFYob7ZA-k,139
+GameSentenceMiner/ffmpeg.py,sha256=2dwKbKxw_9sUXud67pPAx_6dGd1j-D99CdqLFVtbhSk,11479
+GameSentenceMiner/gametext.py,sha256=LORVdE2WEo1CDI8gonc7qxrhbS4KFKXFQVKjhlkpLbc,7368
+GameSentenceMiner/gsm.py,sha256=cWHJwWHyKsdzo0TXTXREG549MUtlQLyect9S37UK56g,20309
+GameSentenceMiner/model.py,sha256=WYLjIS9IEPxaLPwG5c-edfcfBKYzBFpdR3V3Da8MuLg,5277
+GameSentenceMiner/notification.py,sha256=WeFodBsshhbOagcEfjAJ3kxjUGvBuUAQKEJ8Zf0YO04,2267
+GameSentenceMiner/obs.py,sha256=8ImXAVUWa4JdzwcBOEFShlZRZzh1dCvdpD1aEGhQfbU,6566
+GameSentenceMiner/package.py,sha256=YlS6QRMuVlm6mdXx0rlXv9_3erTGS21jaP3PNNWfAH0,1250
+GameSentenceMiner/util.py,sha256=nmp2cmuBN0Azoc91f3zN_dZSh4nK9z21VTfpIbn8Tk4,4761
+GameSentenceMiner/utility_gui.py,sha256=VYuY8Br47AFak_zOVx9R1oUCBvoRjonDyE0oE6FVwJ0,5742
+GameSentenceMiner/downloader/Untitled_json.py,sha256=RUUl2bbbCpUDUUS0fP0tdvf5FngZ7ILdA_J5TFYAXUQ,15272
+GameSentenceMiner/downloader/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+GameSentenceMiner/downloader/download_tools.py,sha256=mI1u_FGBmBqDIpCH3jOv8DOoZ3obgP5pIf9o9SVfX2Q,8131
+GameSentenceMiner/vad/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+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.1.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+gamesentenceminer-2.5.1.dist-info/METADATA,sha256=OjwqqaJ_DG7FR6OLc3z1XlUX6WH6SqsOc4EDXUjbzbQ,5409
+gamesentenceminer-2.5.1.dist-info/WHEEL,sha256=tTnHoFhvKQHCh4jz3yCn0WPTYIy7wXx3CJtJ7SJGV7c,91
+gamesentenceminer-2.5.1.dist-info/entry_points.txt,sha256=2APEP25DbfjSxGeHtwBstMH8mulVhLkqF_b9bqzU6vQ,65
+gamesentenceminer-2.5.1.dist-info/top_level.txt,sha256=V1hUY6xVSyUEohb0uDoN4UIE6rUZ_JYx8yMyPGX4PgQ,18
+gamesentenceminer-2.5.1.dist-info/RECORD,,

{gamesentenceminer-2.4.12.dist-info → gamesentenceminer-2.5.1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (76.0.0)
+Generator: setuptools (77.0.1)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

gamesentenceminer-2.4.12.dist-info/RECORD

@@ -1,27 +0,0 @@
-GameSentenceMiner/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-GameSentenceMiner/anki.py,sha256=YSz5gUTsKOdbogwHKtgFM7v7pREjdAwl7A0Wa_CXnKg,10918
-GameSentenceMiner/config_gui.py,sha256=s0U0Sj_WvrJ8GecSyj33tWMh-OyOcZ5yY1ddEc1cgwg,53456
-GameSentenceMiner/configuration.py,sha256=_VxzRHCJPW2iJTW6gheD1d6-oaUbUQQnLsIiHjgjNcY,15186
-GameSentenceMiner/electron_messaging.py,sha256=fBk9Ipo0jg2OZwYaKe1Qsm05P2ftrdTRGgFYob7ZA-k,139
-GameSentenceMiner/ffmpeg.py,sha256=vkRvhsuXCL8-tGynobdLBnw4qNHUhTC33ITCCnjfZLM,11468
-GameSentenceMiner/gametext.py,sha256=YXjaZF130lkzU-I2dpZ5HoNrj3GSCG-7X9B04IFnetI,7551
-GameSentenceMiner/gsm.py,sha256=E9Hpbyzrv8FEFGBs-4Hf60m3sk0ps3OQdvB1n42AhRU,20164
-GameSentenceMiner/model.py,sha256=oh8VVT8T1UKekbmP6MGNgQ8jIuQ_7Rg4GPzDCn2kJo8,1999
-GameSentenceMiner/notification.py,sha256=WBaQWoPNhW4XqdPBUmxPBgjk0ngzH_4v9zMQ-XQAKC8,2010
-GameSentenceMiner/obs.py,sha256=8ImXAVUWa4JdzwcBOEFShlZRZzh1dCvdpD1aEGhQfbU,6566
-GameSentenceMiner/package.py,sha256=YlS6QRMuVlm6mdXx0rlXv9_3erTGS21jaP3PNNWfAH0,1250
-GameSentenceMiner/util.py,sha256=MITweiFYaefWQF5nR8tZ9yE6vd_b-fLuP0MP1Y1U4K0,4720
-GameSentenceMiner/utility_gui.py,sha256=EtQUnCgTTdzKJE0iCJiHjjc_c6tc7JtI09LRg4_iy8Y,4555
-GameSentenceMiner/downloader/Untitled_json.py,sha256=RUUl2bbbCpUDUUS0fP0tdvf5FngZ7ILdA_J5TFYAXUQ,15272
-GameSentenceMiner/downloader/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-GameSentenceMiner/downloader/download_tools.py,sha256=1x57nzktdlsUruTJxCPNpmHDDlhZ589NwRyAMP0Pq7E,6818
-GameSentenceMiner/vad/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-GameSentenceMiner/vad/silero_trim.py,sha256=syDJX_KbFmdyFFtnQqYTD0tICsUCJizYhs-atPgXtxA,1549
-GameSentenceMiner/vad/vosk_helper.py,sha256=HifeXKbEMrs81ZuuGxS67yAghu8TMXUP6Oan9i9dTxw,5938
-GameSentenceMiner/vad/whisper_helper.py,sha256=bpR1HVnJRn9H5u8XaHBqBJ6JwIjzqn-Fajps8QmQ4zc,3411
-gamesentenceminer-2.4.12.dist-info/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-gamesentenceminer-2.4.12.dist-info/METADATA,sha256=fqK1YCT402ptWC4idyZaIqjbCQ38jGDAZGJCuVJ1TAE,5388
-gamesentenceminer-2.4.12.dist-info/WHEEL,sha256=52BFRY2Up02UkjOa29eZOS2VxUrpPORXg1pkohGGUS8,91
-gamesentenceminer-2.4.12.dist-info/entry_points.txt,sha256=2APEP25DbfjSxGeHtwBstMH8mulVhLkqF_b9bqzU6vQ,65
-gamesentenceminer-2.4.12.dist-info/top_level.txt,sha256=V1hUY6xVSyUEohb0uDoN4UIE6rUZ_JYx8yMyPGX4PgQ,18
-gamesentenceminer-2.4.12.dist-info/RECORD,,