GameSentenceMiner 2.13.7__tar.gz → 2.13.8__tar.gz

{gamesentenceminer-2.13.7 → gamesentenceminer-2.13.8}/GameSentenceMiner/anki.py

@@ -1,4 +1,5 @@
 import copy
+from pathlib import Path
 import queue
 import time
 
@@ -10,7 +11,7 @@ from requests import post
 
 from GameSentenceMiner import obs
 from GameSentenceMiner.ai.ai_prompting import get_ai_prompt_result
-from GameSentenceMiner.util.gsm_utils import wait_for_stable_file, remove_html_and_cloze_tags, combine_dialogue, \
+from GameSentenceMiner.util.gsm_utils import make_unique, sanitize_filename, wait_for_stable_file, remove_html_and_cloze_tags, combine_dialogue, \
     run_new_thread, open_audio_in_external
 from GameSentenceMiner.util import ffmpeg, notification
 from GameSentenceMiner.util.configuration import *
@@ -20,6 +21,8 @@ from GameSentenceMiner.util.text_log import get_all_lines, get_text_event, get_m
 from GameSentenceMiner.obs import get_current_game
 from GameSentenceMiner.web import texthooking_page
 import re
+import platform
+import sys
 
 # Global variables to track state
 previous_note_ids = set()
@@ -28,7 +31,7 @@ card_queue = []
 
 
 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, selected_lines=None, prev_ss_timing=0):
+                     should_update_audio=True, ss_time=0, game_line=None, selected_lines=None, prev_ss_timing=0, start_time=None, end_time=None):
     update_audio = should_update_audio and (get_config().anki.sentence_audio_field and not
     last_note.get_field(get_config().anki.sentence_audio_field) or get_config().anki.overwrite_audio)
     update_picture = (get_config().anki.picture_field and get_config().screenshot.enabled
@@ -37,6 +40,8 @@ def update_anki_card(last_note: AnkiCard, note=None, audio_path='', video_path='
     audio_in_anki = ''
     screenshot_in_anki = ''
     prev_screenshot_in_anki = ''
+    screenshot = ''
+    prev_screenshot = ''
     if reuse_audio:
         logger.info("Reusing Audio from last note")
         anki_result = anki_results[game_line.id]
@@ -53,8 +58,6 @@ def update_anki_card(last_note: AnkiCard, note=None, audio_path='', video_path='
             screenshot = ffmpeg.get_screenshot(video_path, ss_time, try_selector=get_config().screenshot.use_screenshot_selector)
             wait_for_stable_file(screenshot)
             screenshot_in_anki = store_media_file(screenshot)
-            if get_config().paths.remove_screenshot:
-                os.remove(screenshot)
         if get_config().anki.previous_image_field and game_line.prev:
             prev_screenshot = ffmpeg.get_screenshot_for_line(video_path, selected_lines[0].prev if selected_lines else game_line.prev, try_selector=get_config().screenshot.use_screenshot_selector)
             wait_for_stable_file(prev_screenshot)
@@ -64,6 +67,46 @@ def update_anki_card(last_note: AnkiCard, note=None, audio_path='', video_path='
     audio_html = f"[sound:{audio_in_anki}]"
     image_html = f"<img src=\"{screenshot_in_anki}\">"
     prev_screenshot_html = f"<img src=\"{prev_screenshot_in_anki}\">"
+    
+    
+    # Move files to output folder if configured
+    if get_config().paths.output_folder and get_config().paths.copy_temp_files_to_output_folder:
+        word_path = os.path.join(get_config().paths.output_folder, sanitize_filename(tango))
+        os.makedirs(word_path, exist_ok=True)
+        if audio_path:
+            audio_filename = Path(audio_path).name
+            new_audio_path = os.path.join(word_path, audio_filename)
+            if os.path.exists(audio_path):
+                shutil.copy(audio_path, new_audio_path)
+        if screenshot:
+            screenshot_filename = Path(screenshot).name
+            new_screenshot_path = os.path.join(word_path, screenshot_filename)
+            if os.path.exists(screenshot):
+                shutil.copy(screenshot, new_screenshot_path)
+        if prev_screenshot:
+            prev_screenshot_filename = Path(prev_screenshot).name
+            new_prev_screenshot_path = os.path.join(word_path, "prev_" + prev_screenshot_filename)
+            if os.path.exists(prev_screenshot):
+                shutil.copy(prev_screenshot, new_prev_screenshot_path)
+                
+        if video_path and get_config().paths.copy_trimmed_replay_to_output_folder:
+            trimmed_video = ffmpeg.trim_replay_for_gameline(video_path, start_time, end_time, accurate=True)
+            new_video_path = os.path.join(word_path, Path(trimmed_video).name)
+            if os.path.exists(trimmed_video):
+                shutil.copy(trimmed_video, new_video_path)
+
+        # Open to word_path if configured
+        if get_config().paths.open_output_folder_on_card_creation:
+            try:
+                if platform.system() == "Windows":
+                    subprocess.Popen(f'explorer "{word_path}"')
+                elif platform.system() == "Darwin":
+                    subprocess.Popen(["open", word_path])
+                else:
+                    subprocess.Popen(["xdg-open", word_path])
+            except Exception as e:
+                logger.error(f"Error opening output folder: {e}")
+
 
     # note = {'id': last_note.noteId, 'fields': {}}
 
@@ -413,9 +456,7 @@ def get_note_ids():
 
 
 def start_monitoring_anki():
-    # Start monitoring anki
-    if get_config().obs.enabled and get_config().features.full_auto:
-        obs_thread = threading.Thread(target=monitor_anki)
-        obs_thread.daemon = True  # Ensures the thread will exit when the main program exits
-        obs_thread.start()
+    obs_thread = threading.Thread(target=monitor_anki)
+    obs_thread.daemon = True
+    obs_thread.start()
 

{gamesentenceminer-2.13.7 → gamesentenceminer-2.13.8}/GameSentenceMiner/config_gui.py

@@ -143,7 +143,7 @@ class ConfigApp:
         self.current_row = 0
 
         self.master_config: Config = configuration.load_config()
-        self.i18n = load_localization(self.master_config.locale)
+        self.i18n = load_localization(self.master_config.get_locale())
         
         self.window.title(self.i18n.get('app', {}).get('title', 'GameSentenceMiner Configuration'))
 
@@ -212,7 +212,7 @@ class ConfigApp:
     
     def change_locale(self):
         """Change the locale of the application."""
-        if self.locale_value.get() == self.master_config.locale.name:
+        if self.locale_value.get() == self.master_config.get_locale().name:
             return
         self.i18n = load_localization(Locale[self.locale_value.get()])
         self.save_settings()
@@ -245,7 +245,6 @@ class ConfigApp:
         self.native_language_value = tk.StringVar(value=CommonLanguages.from_code(self.settings.general.native_language).name.replace('_', ' ').title())
 
         # OBS Settings
-        self.obs_enabled_value = tk.BooleanVar(value=self.settings.obs.enabled)
         self.obs_websocket_port_value = tk.StringVar(value=str(self.settings.obs.port))
         self.obs_host_value = tk.StringVar(value=self.settings.obs.host)
         self.obs_port_value = tk.StringVar(value=str(self.settings.obs.port))
@@ -257,8 +256,10 @@ class ConfigApp:
         
         # Paths Settings
         self.folder_to_watch_value = tk.StringVar(value=self.settings.paths.folder_to_watch)
-        self.audio_destination_value = tk.StringVar(value=self.settings.paths.audio_destination)
-        self.screenshot_destination_value = tk.StringVar(value=self.settings.paths.screenshot_destination)
+        self.output_folder_value = tk.StringVar(value=self.settings.paths.output_folder)
+        self.copy_temp_files_to_output_folder_value = tk.BooleanVar(value=self.settings.paths.copy_temp_files_to_output_folder)
+        self.open_output_folder_on_card_creation_value = tk.BooleanVar(value=self.settings.paths.open_output_folder_on_card_creation)
+        self.copy_trimmed_replay_to_output_folder_value = tk.BooleanVar(value=self.settings.paths.copy_trimmed_replay_to_output_folder)
         self.remove_video_value = tk.BooleanVar(value=self.settings.paths.remove_video)
         self.remove_audio_value = tk.BooleanVar(value=self.settings.paths.remove_audio)
         self.remove_screenshot_value = tk.BooleanVar(value=self.settings.paths.remove_screenshot)
@@ -357,7 +358,7 @@ class ConfigApp:
         
         # Master Config Settings
         self.switch_to_default_if_not_found_value = tk.BooleanVar(value=self.master_config.switch_to_default_if_not_found)
-        self.locale_value = tk.StringVar(value=self.master_config.locale.name)
+        self.locale_value = tk.StringVar(value=self.master_config.get_locale().name)
         
 
     def create_tabs(self):
@@ -469,11 +470,11 @@ class ConfigApp:
             ),
             paths=Paths(
                 folder_to_watch=self.folder_to_watch_value.get(),
-                audio_destination=self.audio_destination_value.get(),
-                screenshot_destination=self.screenshot_destination_value.get(),
+                output_folder=self.output_folder_value.get(),
+                open_output_folder_on_card_creation=self.open_output_folder_on_card_creation_value.get(),
                 remove_video=self.remove_video_value.get(),
-                remove_audio=self.remove_audio_value.get(),
-                remove_screenshot=self.remove_screenshot_value.get()
+                copy_temp_files_to_output_folder=self.copy_temp_files_to_output_folder_value.get(),
+                copy_trimmed_replay_to_output_folder=self.copy_trimmed_replay_to_output_folder_value.get()
             ),
             anki=Anki(
                 update_anki=self.update_anki_value.get(),
@@ -525,7 +526,6 @@ class ConfigApp:
                 pre_vad_end_offset=float(self.pre_vad_audio_offset_value.get()),
             ),
             obs=OBS(
-                enabled=self.obs_enabled_value.get(),
                 open_obs=self.obs_open_obs_value.get(),
                 close_obs=self.obs_close_obs_value.get(),
                 host=self.obs_host_value.get(),
@@ -593,15 +593,6 @@ class ConfigApp:
         dialog_i18n = self.i18n.get('dialogs', {}).get('config_error', {})
         error_title = dialog_i18n.get('title', 'Configuration Error')
 
-        if config.features.backfill_audio and config.features.full_auto:
-            messagebox.showerror(error_title,
-                                 dialog_i18n.get('full_auto_and_backfill', 'Cannot have Full Auto and Backfill...'))
-            return
-
-        if not config.general.use_websocket and not config.general.use_clipboard:
-            messagebox.showerror(error_title, dialog_i18n.get('no_input_method', 'Cannot have both...'))
-            return
-
         current_profile = self.profile_combobox.get()
         prev_config = self.master_config.get_config()
         self.master_config.switch_to_default_if_not_found = self.switch_to_default_if_not_found_value.get()
@@ -625,8 +616,7 @@ class ConfigApp:
         if sync_changes:
             self.master_config.sync_changed_fields(prev_config)
 
-        with open(get_config_path(), 'w') as file:
-            file.write(self.master_config.to_json(indent=4))
+        self.master_config.save()
 
         logger.info("Settings saved successfully!")
 
@@ -934,13 +924,6 @@ class ConfigApp:
             row=self.current_row, column=3, sticky='W', pady=2)
         self.current_row += 1
         
-        # obs_enabled_i18n = simple_i18n.get('obs_enabled', {})
-        # HoverInfoLabelWidget(feature_frame, text=obs_enabled_i18n.get('label', '...'),
-        #                      tooltip=obs_enabled_i18n.get('tooltip', '...'), row=self.current_row, column=0)
-        # ttk.Checkbutton(feature_frame, variable=self.obs_enabled_value, bootstyle="round-toggle").grid(
-        #     row=self.current_row, column=1, sticky='W', pady=2)
-        # self.current_row += 1
-        
         # screenshot_i18n = simple_i18n.get('screenshot_enabled', {})
         # HoverInfoLabelWidget(feature_frame, text=screenshot_i18n.get('label', '...'),
         #                      tooltip=screenshot_i18n.get('tooltip', '...'), row=self.current_row, column=0)
@@ -1094,46 +1077,61 @@ class ConfigApp:
         ttk.Button(paths_frame, text=browse_text, command=lambda: self.browse_folder(folder_watch_entry),
                    bootstyle="outline").grid(row=self.current_row, column=2, padx=5, pady=2)
         self.current_row += 1
-
-        audio_dest_i18n = paths_i18n.get('audio_destination', {})
-        HoverInfoLabelWidget(paths_frame, text=audio_dest_i18n.get('label', '...'), tooltip=audio_dest_i18n.get('tooltip', '...'),
-                             foreground="dark orange", font=("Helvetica", 10, "bold"), row=self.current_row, column=0)
-        audio_dest_entry = ttk.Entry(paths_frame, width=50, textvariable=self.audio_destination_value)
-        audio_dest_entry.grid(row=self.current_row, column=1, sticky='W', pady=2)
-        ttk.Button(paths_frame, text=browse_text, command=lambda: self.browse_folder(audio_dest_entry),
-                   bootstyle="outline").grid(row=self.current_row, column=2, padx=5, pady=2)
+        
+        # Combine "Copy temp files to output folder" and "Output folder" on one row
+        copy_to_output_i18n = paths_i18n.get('copy_temp_files_to_output_folder', {})
+        combined_i18n = paths_i18n.get('output_folder', {})
+        
+        # Output folder and "Copy temp files to output folder" on one row
+        HoverInfoLabelWidget(paths_frame, text=combined_i18n.get('label', '...'),
+                     tooltip=combined_i18n.get('tooltip', '...'), foreground="dark orange",
+                     font=("Helvetica", 10, "bold"), row=self.current_row, column=0)
+        output_folder_entry = ttk.Entry(paths_frame, width=30, textvariable=self.output_folder_value)
+        output_folder_entry.grid(row=self.current_row, column=1, sticky='EW', pady=2)
+        ttk.Button(paths_frame, text=browse_text, command=lambda: self.browse_folder(output_folder_entry),
+               bootstyle="outline").grid(row=self.current_row, column=2, padx=5, pady=2)
+
+        HoverInfoLabelWidget(paths_frame, text=copy_to_output_i18n.get('label', '...'),
+                     tooltip=copy_to_output_i18n.get('tooltip', '...'), row=self.current_row, column=3)
+        ttk.Checkbutton(paths_frame, variable=self.copy_temp_files_to_output_folder_value, bootstyle="round-toggle").grid(
+            row=self.current_row, column=4, sticky='W', pady=2)
         self.current_row += 1
-
-        ss_dest_i18n = paths_i18n.get('screenshot_destination', {})
-        HoverInfoLabelWidget(paths_frame, text=ss_dest_i18n.get('label', '...'),
-                             tooltip=ss_dest_i18n.get('tooltip', '...'), foreground="dark orange",
-                             font=("Helvetica", 10, "bold"), row=self.current_row, column=0)
-        ss_dest_entry = ttk.Entry(paths_frame, width=50, textvariable=self.screenshot_destination_value)
-        ss_dest_entry.grid(row=self.current_row, column=1, sticky='W', pady=2)
-        ttk.Button(paths_frame, text=browse_text, command=lambda: self.browse_folder(ss_dest_entry),
-                   bootstyle="outline").grid(row=self.current_row, column=2, padx=5, pady=2)
+        
+        
+        copy_to_output_i18n = paths_i18n.get('copy_trimmed_replay_to_output_folder', {})
+        HoverInfoLabelWidget(paths_frame, text=copy_to_output_i18n.get('label', '...'),
+                             tooltip=copy_to_output_i18n.get('tooltip', '...'), row=self.current_row, column=0)
+        ttk.Checkbutton(paths_frame, variable=self.copy_trimmed_replay_to_output_folder_value, bootstyle="round-toggle").grid(
+            row=self.current_row, column=1, sticky='W', pady=2)
         self.current_row += 1
 
-        rm_vid_i18n = paths_i18n.get('remove_video', {})
-        HoverInfoLabelWidget(paths_frame, text=rm_vid_i18n.get('label', '...'), tooltip=rm_vid_i18n.get('tooltip', '...'),
-                             row=self.current_row, column=0)
-        ttk.Checkbutton(paths_frame, variable=self.remove_video_value, bootstyle="round-toggle").grid(row=self.current_row,
+        open_output_folder_i18n = paths_i18n.get('open_output_folder_on_card_creation', {})
+        HoverInfoLabelWidget(paths_frame, text=open_output_folder_i18n.get('label', '...'),
+                             tooltip=open_output_folder_i18n.get('tooltip', '...'), row=self.current_row, column=0)
+        ttk.Checkbutton(paths_frame, variable=self.open_output_folder_on_card_creation_value, bootstyle="round-toggle").grid(row=self.current_row,
                                                                                                 column=1, sticky='W', pady=2)
         self.current_row += 1
-
-        rm_audio_i18n = paths_i18n.get('remove_audio', {})
-        HoverInfoLabelWidget(paths_frame, text=rm_audio_i18n.get('label', '...'), tooltip=rm_audio_i18n.get('tooltip', '...'),
+        
+        rm_video_i18n = paths_i18n.get('remove_video', {})
+        HoverInfoLabelWidget(paths_frame, text=rm_video_i18n.get('label', '...'), tooltip=rm_video_i18n.get('tooltip', '...'),
                              row=self.current_row, column=0)
-        ttk.Checkbutton(paths_frame, variable=self.remove_audio_value, bootstyle="round-toggle").grid(row=self.current_row,
-                                                                                                column=1, sticky='W', pady=2)
+        ttk.Checkbutton(paths_frame, variable=self.remove_video_value, bootstyle="round-toggle").grid(row=self.current_row,
+                                                                                         column=1, sticky='W', pady=2)
         self.current_row += 1
 
-        rm_ss_i18n = paths_i18n.get('remove_screenshot', {})
-        HoverInfoLabelWidget(paths_frame, text=rm_ss_i18n.get('label', '...'), tooltip=rm_ss_i18n.get('tooltip', '...'),
-                             row=self.current_row, column=0)
-        ttk.Checkbutton(paths_frame, variable=self.remove_screenshot_value, bootstyle="round-toggle").grid(
-            row=self.current_row, column=1, sticky='W', pady=2)
-        self.current_row += 1
+        # rm_audio_i18n = paths_i18n.get('remove_audio', {})
+        # HoverInfoLabelWidget(paths_frame, text=rm_audio_i18n.get('label', '...'), tooltip=rm_audio_i18n.get('tooltip', '...'),
+        #                      row=self.current_row, column=0)
+        # ttk.Checkbutton(paths_frame, variable=self.remove_audio_value, bootstyle="round-toggle").grid(row=self.current_row,
+        #                                                                                         column=1, sticky='W', pady=2)
+        # self.current_row += 1
+
+        # rm_ss_i18n = paths_i18n.get('remove_screenshot', {})
+        # HoverInfoLabelWidget(paths_frame, text=rm_ss_i18n.get('label', '...'), tooltip=rm_ss_i18n.get('tooltip', '...'),
+        #                      row=self.current_row, column=0)
+        # ttk.Checkbutton(paths_frame, variable=self.remove_screenshot_value, bootstyle="round-toggle").grid(
+        #     row=self.current_row, column=1, sticky='W', pady=2)
+        # self.current_row += 1
 
         self.add_reset_button(paths_frame, "paths", self.current_row, 0, self.create_paths_tab)
 
@@ -1335,13 +1333,6 @@ class ConfigApp:
             row=self.current_row, column=1, sticky='W', pady=2)
         self.current_row += 1
 
-        full_auto_i18n = features_i18n.get('full_auto', {})
-        HoverInfoLabelWidget(features_frame, text=full_auto_i18n.get('label', '...'), tooltip=full_auto_i18n.get('tooltip', '...'),
-                             row=self.current_row, column=0)
-        ttk.Checkbutton(features_frame, variable=self.full_auto_value, bootstyle="round-toggle").grid(row=self.current_row,
-                                                                                                column=1, sticky='W', pady=2)
-        self.current_row += 1
-
         self.add_reset_button(features_frame, "features", self.current_row, 0, self.create_features_tab)
 
         for col in range(3): features_frame.grid_columnconfigure(col, weight=0)
@@ -1607,13 +1598,6 @@ class ConfigApp:
         obs_frame = self.obs_tab
         obs_i18n = self.i18n.get('tabs', {}).get('obs', {})
 
-        enabled_i18n = obs_i18n.get('enabled', {})
-        HoverInfoLabelWidget(obs_frame, text=enabled_i18n.get('label', '...'), tooltip=enabled_i18n.get('tooltip', '...'),
-                             row=self.current_row, column=0)
-        ttk.Checkbutton(obs_frame, variable=self.obs_enabled_value, bootstyle="round-toggle").grid(row=self.current_row,
-                                                                                             column=1, sticky='W', pady=2)
-        self.current_row += 1
-
         open_i18n = obs_i18n.get('open_obs', {})
         HoverInfoLabelWidget(obs_frame, text=open_i18n.get('label', '...'), tooltip=open_i18n.get('tooltip', '...'), row=self.current_row,
                              column=0)

{gamesentenceminer-2.13.7 → gamesentenceminer-2.13.8}/GameSentenceMiner/gametext.py

@@ -149,10 +149,9 @@ async def handle_new_text_event(current_clipboard, line_time=None):
     global current_line, current_line_time, current_line_after_regex, timer, current_sequence_start_time, last_raw_clipboard
     obs.update_current_game()
     current_line = current_clipboard
-    logger.info(f"Current Line: {current_line} last raw clipboard: {last_raw_clipboard}")
     # Only apply this logic if merging is enabled
     if get_config().general.merge_matching_sequential_text:
-        logger.info(f"Handling new text event: {current_line}")
+        logger.info(f"Current Line: {current_line} last raw clipboard: {last_raw_clipboard}")
         # If no timer is active, this is the start of a new sequence
         if not timer:
             logger.info("Starting a new sequence of text lines.")

{gamesentenceminer-2.13.7 → gamesentenceminer-2.13.8}/GameSentenceMiner/gsm.py

@@ -9,6 +9,18 @@ import warnings
 os.environ.pop('TCL_LIBRARY', None)
 
 
+def handle_error_in_initialization(e):
+    """Handle errors that occur during initialization."""
+    logger.exception(e, exc_info=True)
+    logger.info(
+        "An error occurred during initialization, Maybe try updating GSM from the menu or if running manually, try installing `pip install --update GameSentenceMiner`")
+    try:
+        while True:
+            time.sleep(1)
+    except KeyboardInterrupt:
+        logger.info("Exiting due to initialization error.")
+        sys.exit(1)
+
 try:
     import os.path
     import signal
@@ -45,11 +57,7 @@ try:
     from GameSentenceMiner.web.texthooking_page import run_text_hooker_page
 except Exception as e:
     from GameSentenceMiner.util.configuration import logger, is_linux, is_windows
-    logger.info(
-        "Something bad happened during import/initialization, closing in 5 seconds")
-    logger.exception(e)
-    time.sleep(5)
-    sys.exit(1)
+    handle_error_in_initialization(e)
 
 if is_windows():
     import win32api
@@ -143,7 +151,7 @@ class VideoToAudioHandler(FileSystemEventHandler):
 
             if get_config().anki.sentence_audio_field and get_config().audio.enabled:
                 logger.debug("Attempting to get audio from video")
-                final_audio_output, vad_result, vad_trimmed_audio = VideoToAudioHandler.get_audio(
+                final_audio_output, vad_result, vad_trimmed_audio, start_time, end_time = VideoToAudioHandler.get_audio(
                     start_line,
                     line_cutoff,
                     video_path,
@@ -178,7 +186,9 @@ class VideoToAudioHandler(FileSystemEventHandler):
                     should_update_audio=vad_result.output_audio,
                     ss_time=ss_timing,
                     game_line=mined_line,
-                    selected_lines=selected_lines
+                    selected_lines=selected_lines,
+                    start_time=start_time,
+                    end_time=end_time
                 )
             elif get_config().features.notify_on_update and vad_result.success:
                 notification.send_audio_generated_notification(
@@ -192,23 +202,25 @@ class VideoToAudioHandler(FileSystemEventHandler):
                 f"Some error was hit catching to allow further work to be done: {e}", exc_info=True)
             notification.send_error_no_anki_update()
         finally:
-            if not skip_delete:
-                if video_path and get_config().paths.remove_video and os.path.exists(video_path):
-                    os.remove(video_path)
-                if vad_trimmed_audio and get_config().paths.remove_audio and os.path.exists(vad_trimmed_audio):
-                    os.remove(vad_trimmed_audio)
-                if final_audio_output and get_config().paths.remove_audio and os.path.exists(final_audio_output):
-                    os.remove(final_audio_output)
+            if get_config().paths.remove_video and video_path and not skip_delete:
+                try:
+                    if os.path.exists(video_path):
+                        logger.debug(f"Removing video: {video_path}")
+                        os.remove(video_path)
+                except Exception as e:
+                    logger.error(
+                        f"Error removing video file {video_path}: {e}", exc_info=True)
+            pass
 
     @staticmethod
     def get_audio(game_line, next_line_time, video_path, anki_card_creation_time=None, temporary=False, timing_only=False, mined_line=None):
-        trimmed_audio = get_audio_and_trim(
+        trimmed_audio, start_time, end_time = get_audio_and_trim(
             video_path, game_line, next_line_time, anki_card_creation_time)
         if temporary:
             return ffmpeg.convert_audio_to_wav_lossless(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,
+        final_audio_output = make_unique_file_name(os.path.join(get_temporary_directory(),
                                                                 f"{obs.get_current_game(sanitize=True)}.{get_config().audio.extension}"))
 
         vad_result = vad_processor.trim_audio_with_vad(
@@ -222,7 +234,7 @@ class VideoToAudioHandler(FileSystemEventHandler):
                                                   get_config().audio.ffmpeg_reencode_options_to_use)
         elif os.path.exists(vad_trimmed_audio):
             shutil.move(vad_trimmed_audio, final_audio_output)
-        return final_audio_output, vad_result, vad_trimmed_audio
+        return final_audio_output, vad_result, vad_trimmed_audio, start_time, end_time
 
 
 def initial_checks():
@@ -451,41 +463,52 @@ def restart_obs():
 
 
 def cleanup():
-    logger.info("Performing cleanup...")
-    gsm_state.keep_running = False
+    try:
+        logger.info("Performing cleanup...")
+        gsm_state.keep_running = False
 
-    if get_config().obs.enabled:
+        if obs.obs_connection_manager and obs.obs_connection_manager.is_alive():
+            obs.obs_connection_manager.stop()
         obs.stop_replay_buffer()
         obs.disconnect_from_obs()
-    if get_config().obs.close_obs:
-        close_obs()
-
-    proc: Popen
-    for proc in procs_to_close:
-        try:
-            logger.info(f"Terminating process {proc.args[0]}")
-            proc.terminate()
-            proc.wait()  # Wait for OBS to fully close
-            logger.info(f"Process {proc.args[0]} terminated.")
-        except psutil.NoSuchProcess:
-            logger.info("PID already closed.")
-        except Exception as e:
-            proc.kill()
-            logger.error(f"Error terminating process {proc}: {e}")
-
-    if icon:
-        icon.stop()
-
-    for video in gsm_state.videos_to_remove:
-        try:
-            if os.path.exists(video):
-                os.remove(video)
-        except Exception as e:
-            logger.error(f"Error removing temporary video file {video}: {e}")
-
-    settings_window.window.destroy()
-    time.sleep(5)
-    logger.info("Cleanup complete.")
+        if get_config().obs.close_obs:
+            close_obs()
+            
+        if texthooking_page.websocket_server_threads:
+            for thread in texthooking_page.websocket_server_threads:
+                if thread and isinstance(thread, threading.Thread) and thread.is_alive():
+                    thread.stop_server()
+                    thread.join()
+        
+        proc: Popen
+        for proc in procs_to_close:
+            try:
+                logger.info(f"Terminating process {proc.args[0]}")
+                proc.terminate()
+                proc.wait()
+                logger.info(f"Process {proc.args[0]} terminated.")
+            except psutil.NoSuchProcess:
+                logger.info("PID already closed.")
+            except Exception as e:
+                proc.kill()
+                logger.error(f"Error terminating process {proc}: {e}")
+
+        if icon:
+            icon.stop()
+
+        for video in gsm_state.videos_to_remove:
+            try:
+                if os.path.exists(video):
+                    os.remove(video)
+            except Exception as e:
+                logger.error(f"Error removing temporary video file {video}: {e}")
+
+        settings_window.window.destroy()
+        # time.sleep(5)
+        logger.info("Cleanup complete.")
+    except Exception as e:
+        logger.error(f"Error during cleanup: {e}", exc_info=True)
+        sys.exit(1)
 
 
 def handle_exit():
@@ -508,15 +531,13 @@ def initialize(reloading=False):
             if shutil.which("ffmpeg") is None:
                 os.environ["PATH"] += os.pathsep + \
                     os.path.dirname(get_ffmpeg_path())
-        if get_config().obs.enabled:
-            if get_config().obs.open_obs:
-                obs_process = obs.start_obs()
+        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)
+        os.makedirs(get_config().paths.output_folder, exist_ok=True)
     initial_checks()
     register_websocket_message_handler(handle_websocket_message)
     # if get_config().vad.do_vad_postprocessing:
@@ -568,9 +589,8 @@ def post_init2():
 def async_loop():
     async def loop():
         await obs.connect_to_obs()
-        if get_config().obs.enabled:
-            await register_scene_switcher_callback()
-            await check_obs_folder_is_correct()
+        await register_scene_switcher_callback()
+        await check_obs_folder_is_correct()
         logger.info("Post-Initialization started.")
         vad_processor.init()
         # if is_beangate:
@@ -688,11 +708,7 @@ async def async_main(reloading=False):
         except Exception as e:
             logger.error(f"Error stopping observer: {e}")
     except Exception as e:
-        logger.error(f"An error occurred during initialization: {e}", exc_info=True)
-        notification.send_error_notification(
-            "An error occurred during initialization. Check the log for details.")
-        asyncio.sleep(5)
-        raise e
+        handle_error_in_initialization(e)
 
 
 def main():
@@ -701,10 +717,8 @@ def main():
     try:
         asyncio.run(async_main())
     except Exception as e:
-        logger.exception(e, exc_info=True)
-        logger.info(
-            "An error occurred during initialization, closing in 5 seconds")
-        time.sleep(5)
+        handle_error_in_initialization(e)
+
 
 
 if __name__ == "__main__":
@@ -712,7 +726,4 @@ if __name__ == "__main__":
     try:
         asyncio.run(async_main())
     except Exception as e:
-        logger.exception(e, exc_info=True)
-        logger.info(
-            "An error occurred during initialization, closing in 5 seconds")
-        time.sleep(5)
+        handle_error_in_initialization(e)