GameSentenceMiner 2.5.5__py3-none-any.whl → 2.5.7__py3-none-any.whl

GameSentenceMiner/anki.py

@@ -120,10 +120,9 @@ def get_initial_card_info(last_note: AnkiCard, selected_lines):
     if not last_note:
         return note
     game_line = get_text_event(last_note)
-
-    if selected_lines and get_config().anki.multi_overwrites_sentence:
-        sentences = []
-        sentences_text = ''
+    sentences = []
+    sentences_text = ''
+    if selected_lines:
         try:
             sentence_in_anki = last_note.get_field(get_config().anki.sentence_field)
             logger.info(f"Attempting Preserve HTML for multi-line")
@@ -134,11 +133,11 @@ def get_initial_card_info(last_note: AnkiCard, selected_lines):
                 else:
                     sentences.append(line.text)
 
-            logger.info(f"Attempting to Fix Character Dialogue Format")
-            logger.info([f"{line.text}" for line in sentences])
+            logger.debug(f"Attempting to Fix Character Dialogue Format")
+            logger.debug([f"{line}" for line in sentences])
             try:
                 combined_lines = combine_dialogue(sentences)
-
+                logger.debug(combined_lines)
                 if combined_lines:
                     sentences_text = "".join(combined_lines)
             except Exception as e:
@@ -147,7 +146,13 @@ def get_initial_card_info(last_note: AnkiCard, selected_lines):
         except Exception as e:
             logger.debug(f"Error preserving HTML for multi-line: {e}")
             pass
-        note['fields'][get_config().anki.sentence_field] = sentences_text if sentences_text else "<br>".join(sentences)
+        multi_line_sentence = sentences_text if sentences_text else get_config().advanced.multi_line_line_break.join(sentences)
+        if get_config().anki.multi_overwrites_sentence:
+            note['fields'][get_config().anki.sentence_field] = multi_line_sentence
+        else:
+            logger.info(f"Configured to not overwrite sentence field, Multi-line Sentence If you want it, Note you need to do ctrl+shift+x in anki to paste properly:\n\n" + (sentences_text if sentences_text else get_config().advanced.multi_line_line_break.join(sentences)) + "\n")
+        if get_config().advanced.multi_line_sentence_storage_field:
+            note['fields'][get_config().advanced.multi_line_sentence_storage_field] = multi_line_sentence
 
     if get_config().anki.previous_sentence_field and game_line.prev and not \
             last_note.get_field(get_config().anki.previous_sentence_field):
@@ -259,6 +264,7 @@ def update_new_card():
         lines = get_utility_window().get_selected_lines()
         with util.lock:
             update_anki_card(last_card, note=get_initial_card_info(last_card, lines), reuse_audio=True)
+        get_utility_window().reset_checkboxes()
     else:
         logger.info("New card(s) detected! Added to Processing Queue!")
         card_queue.append(last_card)

GameSentenceMiner/communication/__init__.py

@@ -0,0 +1,22 @@
+import os.path
+from dataclasses import dataclass, field
+from typing import Dict, Optional, Any
+
+from dataclasses_json import dataclass_json, Undefined
+from websocket import WebSocket
+
+from GameSentenceMiner.configuration import get_app_directory
+
+CONFIG_FILE = os.path.join(get_app_directory(), "shared_config.json")
+websocket: WebSocket = None
+
+@dataclass_json(undefined=Undefined.RAISE)
+@dataclass
+class Message:
+    """
+    Represents a message for inter-process communication.
+    Mimics the structure of IPC or HTTP calls.
+    """
+    function: str
+    data: Dict[str, Any] = field(default_factory=dict)
+    id: Optional[str] = None

GameSentenceMiner/communication/send.py

@@ -0,0 +1,7 @@
+import json
+
+from GameSentenceMiner.communication.websocket import websocket, Message
+
+def send_restart_signal():
+    if websocket and websocket.connected:
+        websocket.send(json.dumps(Message(function="restart").to_json()))

GameSentenceMiner/communication/websocket.py

@@ -0,0 +1,77 @@
+import asyncio
+import os.path
+
+import websockets
+import json
+
+from websocket import WebSocket
+
+from GameSentenceMiner.communication import Message
+from GameSentenceMiner.configuration import get_app_directory, logger
+
+CONFIG_FILE = os.path.join(get_app_directory(), "shared_config.json")
+websocket: WebSocket = None
+handle_websocket_message = None
+
+async def do_websocket_connection(port):
+    """
+    Connects to the WebSocket server running in the Electron app.
+    """
+    global websocket
+
+    uri = f"ws://localhost:{port}"  # Use the port from Electron
+    logger.debug(f"Electron Communication : Connecting to server at {uri}...")
+    try:
+        async with websockets.connect(uri) as websocket:
+            logger.debug(f"Connected to websocket server at {uri}")
+
+            # Send an initial message
+            message = Message(function="on_connect", data={"message": "Hello from Python!"})
+            await websocket.send(message.to_json())
+            logger.debug(f"> Sent: {message}")
+
+            # Receive messages from the server
+            while True:
+                try:
+                    response = await websocket.recv()
+                    if response is None:
+                        break
+                    logger.debug(f"Electron Communication : < Received: {response}")
+                    handle_websocket_message(Message.from_json(response))
+                    await asyncio.sleep(1)  # keep the connection alive
+                except websockets.ConnectionClosedOK:
+                    logger.debug("Electron Communication : Connection closed by server")
+                    break
+                except websockets.ConnectionClosedError as e:
+                    logger.debug(f"Electron Communication : Connection closed with error: {e}")
+                    break
+    except ConnectionRefusedError:
+        logger.debug(f"Electron Communication : Error: Could not connect to server at {uri}.  Electron App not running..")
+    except Exception as e:
+        logger.debug(f"Electron Communication : An error occurred: {e}")
+
+def connect_websocket():
+    """
+    Main function to run the WebSocket client.
+    """
+    # Load the port from the same config.json the Electron app uses
+    try:
+        with open(CONFIG_FILE, "r") as f:
+            config = json.load(f)
+            port = config["port"]
+    except FileNotFoundError:
+        print("Error: shared_config.json not found.  Using default port 8766.  Ensure Electron app creates this file.")
+        port = 8766  # Default port, same as in Electron
+    except json.JSONDecodeError:
+        print("Error: shared_config.json was not valid JSON.  Using default port 8765.")
+        port = 8766
+
+    asyncio.run(do_websocket_connection(port))
+
+def register_websocket_message_handler(handler):
+    global handle_websocket_message
+    handle_websocket_message = handler
+
+
+if __name__ == "__main__":
+    connect_websocket()

GameSentenceMiner/config_gui.py

@@ -1,13 +1,12 @@
 import tkinter as tk
 from tkinter import filedialog, messagebox, simpledialog
 
-import pyperclip
 import ttkbootstrap as ttk
 
 from GameSentenceMiner import obs, configuration
+from GameSentenceMiner.communication.send import send_restart_signal
 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
 
 settings_saved = False
@@ -77,6 +76,7 @@ class ConfigApp:
         self.create_obs_tab()
         self.create_hotkeys_tab()
         self.create_profiles_tab()
+        self.create_advanced_tab()
 
         ttk.Button(self.window, text="Save Settings", command=self.save_settings).pack(pady=20)
 
@@ -178,7 +178,8 @@ class ConfigApp:
             hotkeys=Hotkeys(
                 reset_line=self.reset_line_hotkey.get(),
                 take_screenshot=self.take_screenshot_hotkey.get(),
-                open_utility=self.open_utility_hotkey.get()
+                open_utility=self.open_utility_hotkey.get(),
+                play_latest_audio=self.play_latest_audio_hotkey.get()
             ),
             vad=VAD(
                 whisper_model=self.whisper_model.get(),
@@ -189,6 +190,13 @@ class ConfigApp:
                 trim_beginning=self.vad_trim_beginning.get(),
                 beginning_offset=float(self.vad_beginning_offset.get()),
                 add_audio_on_no_results=self.add_audio_on_no_results.get(),
+            ),
+            advanced=Advanced(
+                audio_player_path=self.audio_player_path.get(),
+                video_player_path=self.video_player_path.get(),
+                show_screenshot_buttons=self.show_screenshot_button.get(),
+                multi_line_line_break=self.multi_line_line_break.get(),
+                multi_line_sentence_storage_field=self.multi_line_sentence_storage_field.get(),
             )
         )
 
@@ -216,7 +224,7 @@ class ConfigApp:
 
         if self.master_config.get_config().restart_required(prev_config):
             logger.info("Restart Required for some settings to take affect!")
-            signal_restart_settings_change()
+            send_restart_signal()
         settings_saved = True
         configuration.reload_config()
         self.settings = get_config()
@@ -248,6 +256,7 @@ class ConfigApp:
             self.create_obs_tab()
             self.create_hotkeys_tab()
             self.create_profiles_tab()
+            self.create_advanced_tab()
 
 
     def increment_row(self):
@@ -442,6 +451,12 @@ class ConfigApp:
 
         return paths_frame
 
+    def browse_file(self, entry_widget):
+        file_selected = filedialog.askopenfilename()
+        if file_selected:
+            entry_widget.delete(0, tk.END)
+            entry_widget.insert(0, file_selected)
+
     def browse_folder(self, entry_widget):
         folder_selected = filedialog.askdirectory()
         if folder_selected:
@@ -880,6 +895,51 @@ class ConfigApp:
         if self.master_config.current_profile != DEFAULT_CONFIG:
             ttk.Button(profiles_frame, text="Delete Config", command=self.delete_profile).grid(row=self.current_row, column=2, pady=5)
 
+    @new_tab
+    def create_advanced_tab(self):
+        advanced_frame = ttk.Frame(self.notebook)
+        self.notebook.add(advanced_frame, text='Advanced')
+
+        ttk.Label(advanced_frame, text="Note: Only one of these will take effect, prioritizing audio.", foreground="red").grid(row=self.current_row, column=0, columnspan=3, sticky='W')
+        self.current_row += 1
+
+        ttk.Label(advanced_frame, text="Audio Player Path:").grid(row=self.current_row, column=0, sticky='W')
+        self.audio_player_path = ttk.Entry(advanced_frame, width=50)
+        self.audio_player_path.insert(0, self.settings.advanced.audio_player_path)
+        self.audio_player_path.grid(row=self.current_row, column=1)
+        ttk.Button(advanced_frame, text="Browse", command=lambda: self.browse_file(self.audio_player_path)).grid(row=self.current_row, column=2)
+        self.add_label_and_increment_row(advanced_frame, "Path to the audio player executable. Will open the trimmed Audio", row=self.current_row, column=3)
+
+        ttk.Label(advanced_frame, text="Video Player Path:").grid(row=self.current_row, column=0, sticky='W')
+        self.video_player_path = ttk.Entry(advanced_frame, width=50)
+        self.video_player_path.insert(0, self.settings.advanced.video_player_path)
+        self.video_player_path.grid(row=self.current_row, column=1)
+        ttk.Button(advanced_frame, text="Browse", command=lambda: self.browse_file(self.video_player_path)).grid(row=self.current_row, column=2)
+        self.add_label_and_increment_row(advanced_frame, "Path to the video player executable. Will seek to the location of the line in the replay", row=self.current_row, column=3)
+
+
+        ttk.Label(advanced_frame, text="Play Latest Video/Audio Hotkey:").grid(row=self.current_row, column=0, sticky='W')
+        self.play_latest_audio_hotkey = ttk.Entry(advanced_frame)
+        self.play_latest_audio_hotkey.insert(0, self.settings.hotkeys.play_latest_audio)
+        self.play_latest_audio_hotkey.grid(row=self.current_row, column=1)
+        self.add_label_and_increment_row(advanced_frame, "Hotkey to trim and play the latest audio.", row=self.current_row, column=2)
+
+        ttk.Label(advanced_frame, text="Show Screenshot Button:").grid(row=self.current_row, column=0, sticky='W')
+        self.show_screenshot_button = tk.BooleanVar(value=self.settings.advanced.show_screenshot_buttons)
+        ttk.Checkbutton(advanced_frame, variable=self.show_screenshot_button).grid(row=self.current_row, column=1, sticky='W')
+        self.add_label_and_increment_row(advanced_frame, "Show the screenshot button in the utility gui.", row=self.current_row, column=2)
+
+        ttk.Label(advanced_frame, text="Multi-line Line-Break:").grid(row=self.current_row, column=0, sticky='W')
+        self.multi_line_line_break = ttk.Entry(advanced_frame)
+        self.multi_line_line_break.insert(0, self.settings.advanced.multi_line_line_break)
+        self.multi_line_line_break.grid(row=self.current_row, column=1)
+        self.add_label_and_increment_row(advanced_frame, "Line break for multi-line mining. This goes between each sentence", row=self.current_row, column=2)
+
+        ttk.Label(advanced_frame, text="Multi-Line Sentence Storage Field:").grid(row=self.current_row, column=0, sticky='W')
+        self.multi_line_sentence_storage_field = ttk.Entry(advanced_frame)
+        self.multi_line_sentence_storage_field.insert(0, self.settings.advanced.multi_line_sentence_storage_field)
+        self.multi_line_sentence_storage_field.grid(row=self.current_row, column=1)
+        self.add_label_and_increment_row(advanced_frame, "Field in Anki for storing the multi-line sentence temporarily.", row=self.current_row, column=2)
 
     def on_profile_change(self, event):
         print("profile Changed!")

GameSentenceMiner/configuration.py

@@ -139,6 +139,7 @@ class Hotkeys:
     reset_line: str = 'f5'
     take_screenshot: str = 'f6'
     open_utility: str = 'ctrl+m'
+    play_latest_audio: str = 'f7'
 
 
 @dataclass_json
@@ -153,6 +154,26 @@ class VAD:
     beginning_offset: float = -0.25
     add_audio_on_no_results: bool = False
 
+    def is_silero(self):
+        return self.selected_vad_model == SILERO or self.backup_vad_model == SILERO
+
+    def is_whisper(self):
+        return self.selected_vad_model == WHISPER or self.backup_vad_model == WHISPER
+
+    def is_vosk(self):
+        return self.selected_vad_model == VOSK or self.backup_vad_model == VOSK
+
+
+@dataclass_json
+@dataclass
+class Advanced:
+    audio_player_path: str = ''
+    video_player_path: str = ''
+    show_screenshot_buttons: bool = False
+    multi_line_line_break: str = '<br>'
+    multi_line_sentence_storage_field: str = ''
+
+
 
 @dataclass_json
 @dataclass
@@ -167,6 +188,7 @@ class ProfileConfig:
     obs: OBS = field(default_factory=OBS)
     hotkeys: Hotkeys = field(default_factory=Hotkeys)
     vad: VAD = field(default_factory=VAD)
+    advanced: Advanced = field(default_factory=Advanced)
 
 
     # This is just for legacy support
@@ -421,7 +443,7 @@ console_handler = logging.StreamHandler(sys.stdout)
 console_handler.setLevel(logging.INFO)
 
 # Create rotating file handler with level DEBUG
-file_handler = RotatingFileHandler(get_log_path(), maxBytes=10 * 1024 * 1024, backupCount=0, encoding='utf-8')
+file_handler = RotatingFileHandler(get_log_path(), maxBytes=1024 * 1024, backupCount=5, encoding='utf-8')
 file_handler.setLevel(logging.DEBUG)
 
 # Create a formatter

GameSentenceMiner/ffmpeg.py

@@ -48,6 +48,10 @@ def get_screenshot(video_file, time_from_end):
 
     return output_image
 
+def get_screenshot_for_line(video_file, game_line):
+    return get_screenshot(video_file, get_screenshot_time(video_file, game_line))
+
+
 
 def get_screenshot_time(video_path, game_line, default_beginning=False):
     if game_line:
@@ -183,19 +187,7 @@ def get_video_duration(file_path):
 def trim_audio_based_on_last_line(untrimmed_audio, video_path, game_line, next_line):
     trimmed_audio = tempfile.NamedTemporaryFile(dir=configuration.get_temporary_directory(),
                                                 suffix=f".{get_config().audio.extension}").name
-    file_mod_time = get_file_modification_time(video_path)
-    file_length = get_video_duration(video_path)
-    time_delta = file_mod_time - game_line.time
-    # Convert time_delta to FFmpeg-friendly format (HH:MM:SS.milliseconds)
-    total_seconds = file_length - time_delta.total_seconds()
-    total_seconds_after_offset = total_seconds + get_config().audio.beginning_offset
-    if total_seconds < 0 or total_seconds >= file_length:
-        logger.info(f"0 seconds trimmed off of beginning")
-        return untrimmed_audio
-
-    hours, remainder = divmod(total_seconds_after_offset, 3600)
-    minutes, seconds = divmod(remainder, 60)
-    start_trim_time = "{:02}:{:02}:{:06.3f}".format(int(hours), int(minutes), seconds)
+    start_trim_time, total_seconds, total_seconds_after_offset = get_video_timings(video_path, game_line)
 
     ffmpeg_command = ffmpeg_base_command_list + [
         "-i", untrimmed_audio,
@@ -222,6 +214,22 @@ def trim_audio_based_on_last_line(untrimmed_audio, video_path, game_line, next_l
     logger.info(f"Audio trimmed and saved to {trimmed_audio}")
     return trimmed_audio
 
+def get_video_timings(video_path, game_line):
+    file_mod_time = get_file_modification_time(video_path)
+    file_length = get_video_duration(video_path)
+    time_delta = file_mod_time - game_line.time
+    # Convert time_delta to FFmpeg-friendly format (HH:MM:SS.milliseconds)
+    total_seconds = file_length - time_delta.total_seconds()
+    total_seconds_after_offset = total_seconds + get_config().audio.beginning_offset
+    if total_seconds < 0 or total_seconds >= file_length:
+        logger.info(f"0 seconds trimmed off of beginning")
+        return 0, 0, 0
+
+    hours, remainder = divmod(total_seconds_after_offset, 3600)
+    minutes, seconds = divmod(remainder, 60)
+    start_trim_time = "{:02}:{:02}:{:06.3f}".format(int(hours), int(minutes), seconds)
+    return start_trim_time, total_seconds, total_seconds_after_offset
+
 
 def reencode_file_with_user_config(input_file, final_output_audio, user_ffmpeg_options):
     logger.info(f"Re-encode running with settings:  {user_ffmpeg_options}")
@@ -251,7 +259,7 @@ def create_temp_file_with_same_name(input_file: str):
 def replace_file_with_retry(temp_file, input_file, retries=5, delay=1):
     for attempt in range(retries):
         try:
-            os.replace(temp_file, input_file)
+            shutil.move(temp_file, input_file)
             logger.info(f'Re-encode Finished!')
             return
         except OSError as e:

GameSentenceMiner/gsm.py

@@ -18,19 +18,20 @@ from GameSentenceMiner import gametext
 from GameSentenceMiner import notification
 from GameSentenceMiner import obs
 from GameSentenceMiner import util
+from GameSentenceMiner.communication import Message
+from GameSentenceMiner.communication.send import send_restart_signal
+from GameSentenceMiner.communication.websocket import connect_websocket, register_websocket_message_handler
 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.ffmpeg import get_audio_and_trim, get_video_timings
+from GameSentenceMiner.gametext import get_text_event, get_mined_line, GameLine
 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
+from GameSentenceMiner.vad import silero_trim, whisper_helper, vosk_helper
 
 if is_windows():
     import win32api
 
-obs_process = None
 procs_to_close = []
 settings_window: config_gui.ConfigApp = None
 obs_paused = False
@@ -69,6 +70,23 @@ class VideoToAudioHandler(FileSystemEventHandler):
 
     @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)
+                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)
+            return
         try:
             last_note = None
             if anki.card_queue and len(anki.card_queue) > 0:
@@ -112,8 +130,8 @@ class VideoToAudioHandler(FileSystemEventHandler):
                     logger.debug(last_note.to_json())
 
                 note = anki.get_initial_card_info(last_note, get_utility_window().get_selected_lines())
-
                 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:
                     logger.debug("Attempting to get audio from video")
@@ -142,11 +160,13 @@ class VideoToAudioHandler(FileSystemEventHandler):
             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
-        get_utility_window().reset_checkboxes()
+
 
     @staticmethod
-    def get_audio(game_line, next_line_time, video_path):
+    def get_audio(game_line, next_line_time, video_path, temporary=False):
         trimmed_audio = get_audio_and_trim(video_path, game_line, next_line_time)
+        if temporary:
+            return trimmed_audio
         vad_trimmed_audio = make_unique_file_name(
             f"{os.path.abspath(configuration.get_temporary_directory())}/{obs.get_current_game(sanitize=True)}.{get_config().audio.extension}")
         final_audio_output = make_unique_file_name(os.path.join(get_config().paths.audio_destination,
@@ -181,31 +201,54 @@ class VideoToAudioHandler(FileSystemEventHandler):
             ffmpeg.reencode_file_with_user_config(vad_trimmed_audio, final_audio_output,
                                                   get_config().audio.ffmpeg_reencode_options)
         elif os.path.exists(vad_trimmed_audio):
-            os.replace(vad_trimmed_audio, final_audio_output)
+            shutil.move(vad_trimmed_audio, final_audio_output)
         return final_audio_output, should_update_audio, vad_trimmed_audio
 
+def play_audio_in_external(filepath):
+    exe = get_config().advanced.audio_player_path
 
-def initialize(reloading=False):
-    global obs_process
-    if not reloading:
-        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()
-            obs.connect_to_obs(start_replay=True)
-            anki.start_monitoring_anki()
-        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)
-    if get_config().vad.do_vad_postprocessing:
-        if VOSK in (get_config().vad.backup_vad_model, get_config().vad.selected_vad_model):
-            vosk_helper.get_vosk_model()
-        if WHISPER in (get_config().vad.backup_vad_model, get_config().vad.selected_vad_model):
-            whisper_helper.initialize_whisper_model()
+    filepath = os.path.normpath(filepath)
+
+    command = [exe, filepath]
+
+    try:
+        subprocess.Popen(command)
+        print(f"Opened {filepath} in {exe}.")
+    except Exception as e:
+        print(f"An error occurred: {e}")
+
+def play_video_in_external(line, filepath):
+    def remove_video_when_closed(p, fp):
+        p.wait()
+        os.remove(fp)
+
+    command = [get_config().advanced.video_player_path, os.path.normpath(filepath)]
+
+    start, _, _ = get_video_timings(filepath, line)
+
+    print(start)
+
+    if start:
+        command.extend(["--start-time", convert_to_vlc_seconds(start)])
+
+    try:
+        proc = subprocess.Popen(command)
+        print(f"Opened {filepath} in VLC.")
+        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.")
+    except Exception as e:
+        print(f"An error occurred: {e}")
 
+def convert_to_vlc_seconds(time_str):
+    """Converts HH:MM:SS.milliseconds to VLC-compatible seconds."""
+    try:
+        hours, minutes, seconds_ms = time_str.split(":")
+        seconds, milliseconds = seconds_ms.split(".")
+        total_seconds = (int(hours) * 3600) + (int(minutes) * 60) + int(seconds) + (int(milliseconds) / 1000.0)
+        return str(total_seconds)
+    except ValueError:
+        return "Invalid time format"
 
 def initial_checks():
     try:
@@ -220,6 +263,7 @@ def register_hotkeys():
     keyboard.add_hotkey(get_config().hotkeys.reset_line, gametext.reset_line_hotkey_pressed)
     keyboard.add_hotkey(get_config().hotkeys.take_screenshot, get_screenshot)
     keyboard.add_hotkey(get_config().hotkeys.open_utility, open_multimine)
+    keyboard.add_hotkey(get_config().hotkeys.play_latest_audio, play_most_recent_audio)
 
 
 def get_screenshot():
@@ -274,6 +318,13 @@ def open_multimine():
     obs.update_current_game()
     get_utility_window().show()
 
+def play_most_recent_audio():
+    if get_config().advanced.audio_player_path or get_config().advanced.video_player_path and len(gametext.line_history) > 0:
+        get_utility_window().line_for_audio = gametext.line_history.values[-1]
+        obs.save_replay_buffer()
+    else:
+        logger.error("Feature Disabled. No audio or video player path set in config!")
+
 
 def open_log():
     """Function to handle opening log."""
@@ -343,7 +394,7 @@ def switch_profile(icon, item):
     settings_window.reload_settings()
     update_icon()
     if get_config().restart_required(prev_config):
-        signal_restart_settings_change()
+        send_restart_signal()
 
 
 def run_tray():
@@ -388,10 +439,10 @@ def run_tray():
 #                 proc.wait()
 
 def close_obs():
-    if obs_process:
+    if obs.obs_process:
         try:
-            subprocess.run(["taskkill", "/PID", str(obs_process), "/F"], check=True, capture_output=True, text=True)
-            print(f"OBS (PID {obs_process}) has been terminated.")
+            subprocess.run(["taskkill", "/PID", str(obs.obs_process.pid), "/F"], check=True, capture_output=True, text=True)
+            print(f"OBS (PID {obs.obs_process.pid}) has been terminated.")
         except subprocess.CalledProcessError as e:
             print(f"Error terminating OBS: {e.stderr}")
     else:
@@ -399,12 +450,11 @@ def close_obs():
 
 
 def restart_obs():
-    global obs_process
-    if obs_process:
+    if obs.obs_process:
         close_obs()
         time.sleep(2)
-        obs_process = obs.start_obs()
-        obs.connect_to_obs(start_replay=True)
+        obs.start_obs()
+        obs.connect_to_obs()
 
 
 def cleanup():
@@ -438,20 +488,6 @@ def cleanup():
     logger.info("Cleanup complete.")
 
 
-def check_for_stdin():
-    while True:
-        for line in sys.stdin:
-            logger.info(f"Got stdin: {line}")
-            if "exit" in line:
-                cleanup()
-                sys.exit(0)
-            elif "restart_obs" in line:
-                restart_obs()
-            elif "update" in line:
-                update_icon()
-            sys.stdin.flush()
-
-
 def handle_exit():
     """Signal handler for graceful termination."""
 
@@ -462,23 +498,74 @@ def handle_exit():
 
     return _handle_exit
 
+def initialize(reloading=False):
+    global obs_process
+    if not reloading:
+        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()
+            # obs.connect_to_obs(start_replay=True)
+            # anki.start_monitoring_anki()
+        # 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)
+    initial_checks()
+    register_websocket_message_handler(handle_websocket_message)
+    # if get_config().vad.do_vad_postprocessing:
+    #     if VOSK in (get_config().vad.backup_vad_model, get_config().vad.selected_vad_model):
+    #         vosk_helper.get_vosk_model()
+    #     if WHISPER in (get_config().vad.backup_vad_model, get_config().vad.selected_vad_model):
+    #         whisper_helper.initialize_whisper_model()
+
+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)
+        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)
+    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 handle_websocket_message(message: Message):
+    match message.function:
+        case "quit":
+            cleanup()
+            sys.exit(0)
+        case _:
+            logger.debug(f"unknown message from electron websocket: {message.to_json()}")
 
-def main(reloading=False, do_config_input=True):
+
+def main(reloading=False):
     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)
     init_utility_window(root)
     initialize(reloading)
-    util.run_new_thread(run_tray)
-    initial_checks()
-    event_handler = VideoToAudioHandler()
+    initialize_async()
     observer = Observer()
-    observer.schedule(event_handler, get_config().paths.folder_to_watch, recursive=False)
+    observer.schedule(VideoToAudioHandler(), get_config().paths.folder_to_watch, recursive=False)
     observer.start()
-
-    logger.info("Script Initialized. Happy Mining!")
     if not is_linux():
         register_hotkeys()
 

GameSentenceMiner/notification.py

@@ -40,7 +40,7 @@ def open_anki_card(note_id):
 
 def send_notification(title, message, timeout):
     if windows:
-        notifier.show_toast(title, message, duration=timeout)
+        notifier.show_toast(title, message, duration=timeout, threaded=True)
     else:
         notification.notify(
             title=title,

GameSentenceMiner/obs.py

@@ -1,3 +1,4 @@
+import logging
 import subprocess
 import time
 
@@ -9,6 +10,8 @@ from GameSentenceMiner.configuration import *
 from GameSentenceMiner.model import *
 
 client: obsws = None
+obs_process = None
+logging.getLogger('obswebsocket').setLevel(logging.CRITICAL)
 
 # REFERENCE: https://github.com/obsproject/obs-websocket/blob/master/docs/generated/protocol.md
 
@@ -17,6 +20,7 @@ def get_obs_path():
     return os.path.join(configuration.get_app_directory(), 'obs-studio/bin/64bit/obs64.exe')
 
 def start_obs():
+    global obs_process
     obs_path = get_obs_path()
     if not os.path.exists(obs_path):
         logger.error(f"OBS not found at {obs_path}. Please install OBS.")
@@ -26,9 +30,9 @@ def start_obs():
         obs_pid = is_obs_running(obs_path)
         if obs_pid:
             return obs_pid
-        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'], cwd=os.path.dirname(obs_path))
         logger.info("OBS launched")
-        return process.pid
+        return obs_process.pid
     except Exception as e:
         logger.error(f"Error launching OBS: {e}")
         return None
@@ -87,7 +91,7 @@ def on_disconnect(obs):
     logger.error("OBS Connection Lost!")
 
 
-def connect_to_obs(start_replay=False):
+def connect_to_obs():
     global client
     if get_config().obs.enabled:
         if util.is_windows():
@@ -97,8 +101,7 @@ def connect_to_obs(start_replay=False):
                        on_disconnect=on_disconnect)
         client.connect()
 
-        time.sleep(1)
-        if start_replay and get_config().obs.start_buffer:
+        if get_config().obs.start_buffer:
             start_replay_buffer()
         update_current_game()
 
@@ -111,22 +114,45 @@ def disconnect_from_obs():
         client = None
         logger.info("Disconnected from OBS WebSocket.")
 
+def do_obs_call(request, from_dict = None, retry=5):
+    try:
+        response = client.call(request)
+        if not response.status and retry > 0:
+            time.sleep(1)
+            return do_obs_call(request, from_dict, retry - 1)
+        if from_dict:
+            return from_dict(response.datain)
+        return None
+    except Exception as e:
+        if "socket is already closed" in str(e) or "object has no attribute" in str(e):
+            if retry > 0:
+                time.sleep(1)
+                return do_obs_call(request, from_dict, retry - 1)
+            else:
+                logger.error(f"Error doing obs call: {e}")
+                raise e
+        return None
 
 def toggle_replay_buffer():
     try:
-        client.call(requests.ToggleReplayBuffer())
+        do_obs_call(requests.ToggleReplayBuffer())
         logger.info("Replay buffer Toggled.")
     except Exception as e:
         logger.error(f"Error toggling buffer: {e}")
 
 
 # Start replay buffer
-def start_replay_buffer():
+def start_replay_buffer(retry=5):
     try:
         client.call(requests.GetVersion())
         client.call(requests.StartReplayBuffer())
     except Exception as e:
-        logger.error(f"Error starting replay buffer: {e}")
+        if "socket is already closed" in str(e):
+            if retry > 0:
+                time.sleep(1)
+                start_replay_buffer(retry - 1)
+            else:
+                logger.error(f"Error starting replay buffer: {e}")
 
 
 # Stop replay buffer
@@ -153,9 +179,7 @@ def save_replay_buffer():
 
 def get_current_scene():
     try:
-        response = client.call(requests.GetCurrentProgramScene())
-        scene_info = SceneInfo.from_dict(response.datain)
-        return scene_info.sceneName
+        return do_obs_call(requests.GetCurrentProgramScene(), SceneInfo.from_dict).sceneName
     except Exception as e:
         logger.error(f"Couldn't get scene: {e}")
     return ''
@@ -163,9 +187,7 @@ def get_current_scene():
 
 def get_source_from_scene(scene_name):
     try:
-        response = client.call(requests.GetSceneItemList(sceneName=scene_name))
-        scene_list = SceneItemsResponse.from_dict(response.datain)
-        return scene_list.sceneItems[0]
+        return do_obs_call(requests.GetSceneItemList(sceneName=scene_name), SceneItemsResponse.from_dict).sceneItems[0]
     except Exception as e:
         logger.error(f"Error getting source from scene: {e}")
         return ''

GameSentenceMiner/util.py

@@ -1,15 +1,17 @@
+import importlib
 import os
 import random
 import re
 import string
 import subprocess
+import sys
 import threading
 from datetime import datetime
 from sys import platform
 
 from rapidfuzz import process
 
-from GameSentenceMiner.configuration import logger
+from GameSentenceMiner.configuration import logger, get_config
 
 SCRIPTS_DIR = r"E:\Japanese Stuff\agent-v0.1.4-win32-x64\data\scripts"
 
@@ -156,25 +158,58 @@ def combine_dialogue(dialogue_lines, new_lines=None):
         new_lines = []
 
     if len(dialogue_lines) == 1 and '「' not in dialogue_lines[0]:
-        new_lines.append(dialogue_lines[0] + "<br>")
+        new_lines.append(dialogue_lines[0])
         return new_lines
 
     character_name = dialogue_lines[0].split("「")[0]
     text = character_name + "「"
-    next_character = ''
 
     for i, line in enumerate(dialogue_lines):
         if not line.startswith(character_name + "「"):
-            text = text + "」<br>"
-            next_character = line.split("「")[0]
+            text = text + "」" + get_config().advanced.multi_line_line_break
             new_lines.append(text)
             new_lines.extend(combine_dialogue(dialogue_lines[i:]))
             break
         else:
-            text +=  ("<br>" if i > 0 else "") + line.split("「")[1].rstrip("」") + ""
+            text +=  (get_config().advanced.multi_line_line_break if i > 0 else "") + line.split("「")[1].rstrip("」") + ""
     else:
         text = text + "」"
         new_lines.append(text)
 
     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

GameSentenceMiner/utility_gui.py

@@ -3,16 +3,22 @@ import os
 import tkinter as tk
 from tkinter import ttk
 
-from GameSentenceMiner.configuration import logger, get_app_directory
+from GameSentenceMiner import obs
+from GameSentenceMiner.configuration import logger, get_app_directory, get_config
 
 
 class UtilityApp:
     def __init__(self, root):
         self.root = root
         self.items = []
+        self.play_audio_buttons = []
+        self.get_screenshot_buttons = []
         self.checkboxes = []
         self.multi_mine_window = None  # Store the multi-mine window reference
         self.checkbox_frame = None
+        self.line_for_audio = None
+        self.line_for_screenshot = None
+        self.line_counter = 0
 
         style = ttk.Style()
         style.configure("TCheckbutton", font=("Arial", 20))  # Change the font and size
@@ -80,17 +86,49 @@ class UtilityApp:
                     self.checkboxes[0].destroy()
                     self.checkboxes.pop(0)
                 self.items.pop(0)
+                if self.play_audio_buttons:
+                    self.play_audio_buttons[0].destroy()
+                    self.play_audio_buttons.pop(0)
+                if self.get_screenshot_buttons:
+                    self.get_screenshot_buttons[0].destroy()
+                    self.get_screenshot_buttons.pop(0)
 
             if self.multi_mine_window and tk.Toplevel.winfo_exists(self.multi_mine_window):
                 self.add_checkbox_to_gui(line, var)
+        self.line_for_audio = None
+        self.line_for_screenshot = None
 
     def add_checkbox_to_gui(self, line, var):
         """ Add a single checkbox without repainting everything. """
         if self.checkbox_frame:
+            column = 0
+            if get_config().advanced.show_screenshot_buttons:
+                get_screenshot_button = ttk.Button(self.checkbox_frame, text="📸", command=lambda: self.take_screenshot(line))
+                get_screenshot_button.grid(row=self.line_counter, column=column, sticky='w', padx=5)
+                self.get_screenshot_buttons.append(get_screenshot_button)
+                column += 1
+
+            if get_config().advanced.video_player_path or get_config().advanced.audio_player_path:
+                play_audio_button = ttk.Button(self.checkbox_frame, text="🔊", command=lambda: self.play_audio(line))
+                play_audio_button.grid(row=self.line_counter, column=column, sticky='w', padx=5)
+                self.play_audio_buttons.append(play_audio_button)
+                column += 1
+
             chk = ttk.Checkbutton(self.checkbox_frame, text=f"{line.time.strftime('%H:%M:%S')} - {line.text}", variable=var)
-            chk.pack(anchor='w')
+            chk.grid(row=self.line_counter, column=column, sticky='w', padx=5)
             self.checkboxes.append(chk)
 
+            self.line_counter += 1
+
+
+    def play_audio(self, line):
+        self.line_for_audio = line
+        obs.save_replay_buffer()
+
+    def take_screenshot(self, line):
+        self.line_for_screenshot = line
+        obs.save_replay_buffer()
+
 
     # def update_multi_mine_window(self):
     #     for widget in self.multi_mine_window.winfo_children():

{gamesentenceminer-2.5.5.dist-info → gamesentenceminer-2.5.7.dist-info}/METADATA

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

gamesentenceminer-2.5.7.dist-info/RECORD

@@ -0,0 +1,29 @@
+GameSentenceMiner/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+GameSentenceMiner/anki.py,sha256=YcdNDpUskjdxi8upZ5SLGTyRbO8NlOPcqsV_8akTwuM,12877
+GameSentenceMiner/config_gui.py,sha256=cLKVliB0X61WNduNisOmaEtqSr1mvTO6ZAiv-t2jW-8,61194
+GameSentenceMiner/configuration.py,sha256=-b1wW6EkkOFwF1No1uZLD2nPUV5gfBIzG5a8_ykqyUI,16691
+GameSentenceMiner/ffmpeg.py,sha256=Bvkk0TMHtoQkpEYQls48CbC4TB0-FzrnqQhRNg36hVk,11831
+GameSentenceMiner/gametext.py,sha256=LORVdE2WEo1CDI8gonc7qxrhbS4KFKXFQVKjhlkpLbc,7368
+GameSentenceMiner/gsm.py,sha256=UeGSoFWV1lq3YS0lcDL4zXmvOEEMvSjeS1KKQpnG3co,24169
+GameSentenceMiner/model.py,sha256=bZm-2vkIw4gQCGLB02eDoTtO1Ymb_dnHk0VDJDFO3y8,5228
+GameSentenceMiner/notification.py,sha256=2d8_8DUxImeC1zY-V4c_PZw1zbvvGZ6KiAnPaSmH9G0,2592
+GameSentenceMiner/obs.py,sha256=N7XoPSzLk9rHi4sgsG_LS2dN06MrqwN2mpSHfjONTjE,7368
+GameSentenceMiner/package.py,sha256=YlS6QRMuVlm6mdXx0rlXv9_3erTGS21jaP3PNNWfAH0,1250
+GameSentenceMiner/util.py,sha256=tkaoU1bj8iPMTNwUCWUzFLAnT44Ot92D1tYwQMEnARw,7336
+GameSentenceMiner/utility_gui.py,sha256=aVdI9zVXADS53g7QtTgmkVK1LumBsXF4Lou3qJzgHN8,7487
+GameSentenceMiner/communication/__init__.py,sha256=_jGn9PJxtOAOPtJ2rI-Qu9hEHVZVpIvWlxKvqk91_zI,638
+GameSentenceMiner/communication/send.py,sha256=oOJdCS6-LNX90amkRn5FL2xqx6THGm56zHR2ntVIFTE,229
+GameSentenceMiner/communication/websocket.py,sha256=vrZ9KwRUyZOepjayJkxZZTsNIbHGcDLgDRO9dNDwizM,2914
+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.7.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+gamesentenceminer-2.5.7.dist-info/METADATA,sha256=TVU0qDawh6UwnB9CD2y_zKATbvuVSVhTDKGjgPCRBLI,5435
+gamesentenceminer-2.5.7.dist-info/WHEEL,sha256=DK49LOLCYiurdXXOXwGJm6U4DkHkg4lcxjhqwRa0CP4,91
+gamesentenceminer-2.5.7.dist-info/entry_points.txt,sha256=2APEP25DbfjSxGeHtwBstMH8mulVhLkqF_b9bqzU6vQ,65
+gamesentenceminer-2.5.7.dist-info/top_level.txt,sha256=V1hUY6xVSyUEohb0uDoN4UIE6rUZ_JYx8yMyPGX4PgQ,18
+gamesentenceminer-2.5.7.dist-info/RECORD,,

{gamesentenceminer-2.5.5.dist-info → gamesentenceminer-2.5.7.dist-info}/WHEEL

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

GameSentenceMiner/electron_messaging.py

@@ -1,6 +0,0 @@
-from GameSentenceMiner.configuration import logger
-
-
-def signal_restart_settings_change():
-    logger.info("restart_for_settings_change")
-

gamesentenceminer-2.5.5.dist-info/RECORD

@@ -1,27 +0,0 @@
-GameSentenceMiner/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-GameSentenceMiner/anki.py,sha256=zjZ3oE0iTMk1BQFuEhLWk8qgqJMYihO6-jTkKaC3eUk,12229
-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=MkRaty1ATLLJKZs9rv9Rdlitx3C9fwz66iD2AJS5LQQ,20343
-GameSentenceMiner/model.py,sha256=bZm-2vkIw4gQCGLB02eDoTtO1Ymb_dnHk0VDJDFO3y8,5228
-GameSentenceMiner/notification.py,sha256=p24TPw1iF8vDVL56NRgRi3oZ-5oQa9DkqqVjr1gZRJk,2577
-GameSentenceMiner/obs.py,sha256=8ImXAVUWa4JdzwcBOEFShlZRZzh1dCvdpD1aEGhQfbU,6566
-GameSentenceMiner/package.py,sha256=YlS6QRMuVlm6mdXx0rlXv9_3erTGS21jaP3PNNWfAH0,1250
-GameSentenceMiner/util.py,sha256=lAFwAQNeHpVZs_Aeb2K2ShVdcmfrQzEwxUnbf7e6fOc,5699
-GameSentenceMiner/utility_gui.py,sha256=Ox63XZnj08MezcEG8X5EYJlbHmw-bZitN3CsWgP8lLo,5743
-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.5.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-gamesentenceminer-2.5.5.dist-info/METADATA,sha256=sHUHiKel1xt8b3oAys3w0In5FNvH0KGxlxsyxEMJWgs,5435
-gamesentenceminer-2.5.5.dist-info/WHEEL,sha256=1tXe9gY0PYatrMPMDd6jXqjfpz_B-Wqm32CPfRC58XU,91
-gamesentenceminer-2.5.5.dist-info/entry_points.txt,sha256=2APEP25DbfjSxGeHtwBstMH8mulVhLkqF_b9bqzU6vQ,65
-gamesentenceminer-2.5.5.dist-info/top_level.txt,sha256=V1hUY6xVSyUEohb0uDoN4UIE6rUZ_JYx8yMyPGX4PgQ,18
-gamesentenceminer-2.5.5.dist-info/RECORD,,