GameSentenceMiner 2.3.7__py3-none-any.whl → 2.4.0__py3-none-any.whl

GameSentenceMiner/gsm.py

@@ -1,18 +1,15 @@
 import signal
-import subprocess
-import sys
 import time
-import ttkbootstrap as ttk
 from subprocess import Popen
 
 import keyboard
 import psutil
+import ttkbootstrap as ttk
 from PIL import Image, ImageDraw
 from pystray import Icon, Menu, MenuItem
 from watchdog.events import FileSystemEventHandler
 from watchdog.observers import Observer
 
-from GameSentenceMiner import utility_gui
 from GameSentenceMiner import anki
 from GameSentenceMiner import config_gui
 from GameSentenceMiner import configuration
@@ -21,12 +18,13 @@ from GameSentenceMiner import gametext
 from GameSentenceMiner import notification
 from GameSentenceMiner import obs
 from GameSentenceMiner import util
-from GameSentenceMiner.downloader.download_tools import download_obs_if_needed, download_ffmpeg_if_needed
-from GameSentenceMiner.vad import vosk_helper, silero_trim, whisper_helper
+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.ffmpeg import get_audio_and_trim
-from GameSentenceMiner.gametext import get_line_timing
+from GameSentenceMiner.gametext import get_text_event, get_mined_line
 from GameSentenceMiner.util import *
+from GameSentenceMiner.vad import vosk_helper, silero_trim, whisper_helper
 
 if is_windows():
     import win32api
@@ -57,6 +55,7 @@ class VideoToAudioHandler(FileSystemEventHandler):
             if anki.card_queue and len(anki.card_queue) > 0:
                 last_note = anki.card_queue.pop(0)
             with util.lock:
+                util.set_last_mined_line(anki.get_sentence(last_note))
                 if os.path.exists(video_path) and os.access(video_path, os.R_OK):
                     logger.debug(f"Video found and is readable: {video_path}")
 
@@ -73,12 +72,23 @@ class VideoToAudioHandler(FileSystemEventHandler):
                         last_note = anki.get_last_anki_card()
                     if get_config().features.backfill_audio:
                         last_note = anki.get_cards_by_sentence(gametext.current_line)
-                line_time, next_line_time = get_line_timing(last_note)
+                line_cutoff = None
+                start_line = None
+                mined_line = get_text_event(last_note)
+                if mined_line:
+                    start_line = mined_line
+                    if mined_line.next:
+                        line_cutoff = mined_line.next.time
+
                 if utility_window.lines_selected():
-                    line_time, next_line_time = utility_window.get_selected_times()
+                    lines = 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()
+
                 ss_timing = 0
-                if line_time and next_line_time or line_time and get_config().screenshot.use_beginning_of_line_as_screenshot:
-                    ss_timing = ffmpeg.get_screenshot_time(video_path, line_time)
+                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))
 
@@ -89,8 +99,8 @@ class VideoToAudioHandler(FileSystemEventHandler):
                 if get_config().anki.sentence_audio_field:
                     logger.debug("Attempting to get audio from video")
                     final_audio_output, should_update_audio, vad_trimmed_audio = VideoToAudioHandler.get_audio(
-                        line_time,
-                        next_line_time,
+                        start_line,
+                        line_cutoff,
                         video_path)
                 else:
                     final_audio_output = ""
@@ -103,7 +113,8 @@ class VideoToAudioHandler(FileSystemEventHandler):
                         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)
+                                              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:
@@ -118,11 +129,12 @@ class VideoToAudioHandler(FileSystemEventHandler):
         utility_window.reset_checkboxes()
 
     @staticmethod
-    def get_audio(line_time, next_line_time, video_path):
-        trimmed_audio = get_audio_and_trim(video_path, line_time, next_line_time)
+    def get_audio(game_line, next_line_time, video_path):
+        trimmed_audio = get_audio_and_trim(video_path, game_line, next_line_time)
         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, f"{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,
+                                                                f"{obs.get_current_game(sanitize=True)}.{get_config().audio.extension}"))
         should_update_audio = True
         if get_config().vad.do_vad_postprocessing:
             match get_config().vad.selected_vad_model:
@@ -138,13 +150,13 @@ class VideoToAudioHandler(FileSystemEventHandler):
                     case configuration.OFF:
                         pass
                     case configuration.SILERO:
-                        should_update_audio  = silero_trim.process_audio_with_silero(trimmed_audio,
-                                                                                     vad_trimmed_audio)
+                        should_update_audio = silero_trim.process_audio_with_silero(trimmed_audio,
+                                                                                    vad_trimmed_audio)
                     case configuration.VOSK:
-                        should_update_audio  = vosk_helper.process_audio_with_vosk(trimmed_audio, vad_trimmed_audio)
+                        should_update_audio = vosk_helper.process_audio_with_vosk(trimmed_audio, vad_trimmed_audio)
                     case configuration.WHISPER:
-                        should_update_audio  = whisper_helper.process_audio_with_whisper(trimmed_audio,
-                                                                                         vad_trimmed_audio)
+                        should_update_audio = whisper_helper.process_audio_with_whisper(trimmed_audio,
+                                                                                        vad_trimmed_audio)
         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)
@@ -174,6 +186,7 @@ def initialize(reloading=False):
         if WHISPER in (get_config().vad.backup_vad_model, get_config().vad.selected_vad_model):
             whisper_helper.initialize_whisper_model()
 
+
 def initial_checks():
     try:
         subprocess.run(ffmpeg.ffmpeg_base_command_list)
@@ -231,10 +244,12 @@ def create_image():
 
     return image
 
+
 def open_settings():
     obs.update_current_game()
     settings_window.show()
 
+
 def open_multimine():
     obs.update_current_game()
     utility_window.show()
@@ -259,10 +274,12 @@ def open_log():
     logger.info("Log opened.")
 
 
-def exit_program(icon, item):
+def exit_program(passed_icon, item):
     """Exit the application."""
+    if not passed_icon:
+        passed_icon = icon
     logger.info("Exiting...")
-    icon.stop()
+    passed_icon.stop()
     cleanup()
 
 
@@ -276,7 +293,8 @@ def update_icon():
     global menu, icon
     # Recreate the menu with the updated button text
     profile_menu = Menu(
-        *[MenuItem(("Active: " if profile == get_master_config().current_profile else "") + profile, switch_profile) for profile in
+        *[MenuItem(("Active: " if profile == get_master_config().current_profile else "") + profile, switch_profile) for
+          profile in
           get_master_config().get_all_profile_names()]
     )
 
@@ -293,6 +311,7 @@ def update_icon():
     icon.menu = menu
     icon.update_menu()
 
+
 def switch_profile(icon, item):
     if "Active:" in item.text:
         logger.error("You cannot switch to the currently active profile!")
@@ -326,6 +345,7 @@ def run_tray():
     icon = Icon("TrayApp", create_image(), "Game Sentence Miner", menu)
     icon.run()
 
+
 # def close_obs():
 #     if obs_process:
 #         logger.info("Closing OBS")
@@ -354,6 +374,7 @@ def close_obs():
     else:
         print("OBS is not running.")
 
+
 def restart_obs():
     global obs_process
     if obs_process:
@@ -362,6 +383,7 @@ def restart_obs():
         obs_process = obs.start_obs()
         obs.connect_to_obs(start_replay=True)
 
+
 def cleanup():
     logger.info("Performing cleanup...")
     util.keep_running = False
@@ -386,11 +408,23 @@ def cleanup():
             proc.kill()
             logger.error(f"Error terminating process {proc}: {e}")
 
-
     settings_window.window.destroy()
     logger.info("Cleanup complete.")
 
 
+def check_for_stdin():
+    while True:
+        for line in sys.stdin:
+            match line:
+                case "exit":
+                    cleanup()
+                    sys.exit(0)
+                case "restart_obs":
+                    restart_obs()
+                case "update":
+                    update_icon()
+
+
 def handle_exit():
     """Signal handler for graceful termination."""
 
@@ -405,10 +439,12 @@ def handle_exit():
 def main(reloading=False, do_config_input=True):
     global root, settings_window, utility_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)
     initialize(reloading)
+    util.run_new_thread(run_tray)
     initial_checks()
     event_handler = VideoToAudioHandler()
     observer = Observer()
@@ -425,8 +461,6 @@ def main(reloading=False, do_config_input=True):
     if is_windows():
         win32api.SetConsoleCtrlHandler(handle_exit())
 
-    util.run_new_thread(run_tray)
-
     try:
         if get_config().general.check_for_update_on_startup:
             root.after(0, settings_window.check_update)

GameSentenceMiner/utility_gui.py

@@ -35,16 +35,16 @@ class UtilityApp:
             self.checkbox_frame.pack(padx=10, pady=10, fill="both", expand=True)
 
             # Add existing items
-            for text, var, time in self.items:
-                self.add_checkbox_to_gui(text, var, time)
+            for line, var in self.items:
+                self.add_checkbox_to_gui(line, var)
         else:
             self.multi_mine_window.deiconify()
             self.multi_mine_window.lift()
 
-    def add_text(self, text, time):
-        if text:
+    def add_text(self, line):
+        if line.text:
             var = tk.BooleanVar()
-            self.items.append((text, var, time))
+            self.items.append((line, var))
 
             if len(self.items) > 10:
                 if self.checkboxes:
@@ -53,12 +53,12 @@ class UtilityApp:
                 self.items.pop(0)
 
             if self.multi_mine_window and tk.Toplevel.winfo_exists(self.multi_mine_window):
-                self.add_checkbox_to_gui(text, var, time)
+                self.add_checkbox_to_gui(line, var)
 
-    def add_checkbox_to_gui(self, text, var, time):
+    def add_checkbox_to_gui(self, line, var):
         """ Add a single checkbox without repainting everything. """
         if self.checkbox_frame:
-            chk = ttk.Checkbutton(self.checkbox_frame, text=f"{time.strftime('%H:%M:%S')} - {text}", variable=var)
+            chk = ttk.Checkbutton(self.checkbox_frame, text=f"{line.time.strftime('%H:%M:%S')} - {line.text}", variable=var)
             chk.pack(anchor='w')
             self.checkboxes.append(chk)
 
@@ -73,30 +73,31 @@ class UtilityApp:
     #         chk.pack(anchor='w')
 
     def get_selected_lines(self):
-        filtered_items = [text for text, var, _ in self.items if var.get()]
-        return filtered_items if len(filtered_items) >= 2 else []
+        filtered_items = [line for line, var in self.items if var.get()]
+        return filtered_items if len(filtered_items) > 0 else []
 
-    def get_selected_times(self):
-        filtered_times = [time for _, var, time in self.items if var.get()]
 
-        if len(filtered_times) >= 2:
-            logger.info(filtered_times)
-            # Find the index of the last checked checkbox
-            last_checked_index = max(i for i, (_, var, _) in enumerate(self.items) if var.get())
+    def get_next_line_timing(self):
+        selected_lines = [line for line, var in self.items if var.get()]
+
+        if len(selected_lines) >= 2:
+            last_checked_index = max(i for i, (_, var) in enumerate(self.items) if var.get())
 
-            # Get the time AFTER the last checked checkbox, if it exists
             if last_checked_index + 1 < len(self.items):
-                next_time = self.items[last_checked_index + 1][2]
+                next_time = self.items[last_checked_index + 1][0].time
             else:
                 next_time = 0
 
-            return filtered_times[0], next_time
+            return next_time
+        if len(selected_lines) == 1:
+            return selected_lines[0].get_next_time()
 
         return None
 
+
     def lines_selected(self):
-        filter_times = [time for _, var, time in self.items if var.get()]
-        if len(filter_times) >= 2:
+        filter_times = [line.time for line, var in self.items if var.get()]
+        if len(filter_times) > 0:
             return True
         return False
 
@@ -114,7 +115,7 @@ class UtilityApp:
     #             found_unchecked = True
 
     def reset_checkboxes(self):
-        for _, var, _ in self.items:
+        for _, var in self.items:
             var.set(False)
         # if self.multi_mine_window:
         #     for checkbox in self.checkboxes: