GameSentenceMiner 2.9.14__py3-none-any.whl → 2.9.16__py3-none-any.whl

GameSentenceMiner/anki.py

@@ -1,3 +1,4 @@
+import copy
 import queue
 import time
 
@@ -19,10 +20,6 @@ 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
 
-audio_in_anki = None
-screenshot_in_anki = None
-prev_screenshot_in_anki = None
-
 # Global variables to track state
 previous_note_ids = set()
 first_run = True
@@ -31,14 +28,21 @@ 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):
-    global audio_in_anki, screenshot_in_anki, prev_screenshot_in_anki
     update_audio = should_update_audio and (get_config().anki.sentence_audio_field and not
     last_note.get_field(get_config().anki.sentence_audio_field) or get_config().anki.overwrite_audio)
     update_picture = (get_config().anki.picture_field and get_config().screenshot.enabled
                       and (get_config().anki.overwrite_picture or not last_note.get_field(get_config().anki.picture_field)))
 
-
-    if not reuse_audio:
+    audio_in_anki = ''
+    screenshot_in_anki = ''
+    prev_screenshot_in_anki = ''
+    if reuse_audio:
+        logger.info("Reusing Audio from last note")
+        anki_result = anki_results[game_line.id]
+        audio_in_anki = anki_result.audio_in_anki
+        screenshot_in_anki = anki_result.screenshot_in_anki
+        prev_screenshot_in_anki = anki_result.prev_screenshot_in_anki
+    else:
         if update_audio:
             audio_in_anki = store_media_file(audio_path)
             if get_config().audio.external_tool and get_config().audio.external_tool_enabled:
@@ -96,6 +100,16 @@ def update_anki_card(last_note: AnkiCard, note=None, audio_path='', video_path='
         tag_string = " ".join(tags)
         invoke("addTags", tags=tag_string, notes=[last_note.noteId])
 
+    if not reuse_audio:
+        anki_results[game_line.id] = AnkiUpdateResult(
+            success=True,
+            audio_in_anki=audio_in_anki,
+            screenshot_in_anki=screenshot_in_anki,
+            prev_screenshot_in_anki=prev_screenshot_in_anki,
+            sentence_in_anki=game_line.text if game_line else '',
+            multi_line=bool(selected_lines and len(selected_lines) > 1)
+        )
+
     run_new_thread(lambda: check_and_update_note(last_note, note, tags))
 
 def check_and_update_note(last_note, note, tags=[]):
@@ -111,6 +125,7 @@ def check_and_update_note(last_note, note, tags=[]):
         notification.open_anki_card(last_note.noteId)
     if get_config().features.notify_on_update:
         notification.send_note_updated(last_note.noteId)
+    gsm_status.remove_word_being_processed(last_note.get_field(get_config().anki.word_field))
 
 
 def add_image_to_card(last_note: AnkiCard, image_path):
@@ -262,7 +277,9 @@ def check_for_new_cards():
     current_note_ids = set()
     try:
         current_note_ids = get_note_ids()
+        gsm_status.anki_connected = True
     except Exception as e:
+        gsm_status.anki_connected = False
         if datetime.now() - last_connection_error > timedelta(seconds=10):
             logger.error(f"Error fetching Anki notes, Make sure Anki is running, ankiconnect add-on is installed, and url/port is configured correctly in GSM Settings")
             last_connection_error = datetime.now()
@@ -270,10 +287,7 @@ def check_for_new_cards():
     new_card_ids = current_note_ids - previous_note_ids
     if new_card_ids and not first_run:
         try:
-            if gsm_state.lock.locked():
-                run_new_thread(update_new_card)
-            else:
-                update_new_card()
+            update_new_card()
         except Exception as e:
             logger.error("Error updating new card, Reason:", e)
     first_run = False
@@ -283,6 +297,7 @@ def update_new_card():
     last_card = get_last_anki_card()
     if not last_card or not check_tags_for_should_update(last_card):
         return
+    gsm_status.add_word_being_processed(last_card.get_field(get_config().anki.word_field))
     use_prev_audio = sentence_is_same_as_previous(last_card)
     logger.debug(f"last mined line: {gsm_state.last_mined_line}, current sentence: {get_sentence(last_card)}")
     logger.info(f"New card using previous audio: {use_prev_audio}")
@@ -290,8 +305,7 @@ def update_new_card():
         obs.update_current_game()
     if use_prev_audio:
         lines = texthooking_page.get_selected_lines()
-        with gsm_state.lock:
-            update_anki_card(last_card, note=get_initial_card_info(last_card, lines), game_line=get_mined_line(last_card, lines), reuse_audio=True)
+        run_new_thread(lambda: update_card_from_same_sentence(last_card, lines=lines, game_line=get_mined_line(last_card, lines)))
         texthooking_page.reset_checked_lines()
     else:
         logger.info("New card(s) detected! Added to Processing Queue!")
@@ -303,8 +317,16 @@ def update_new_card():
             logger.error(f"Error saving replay buffer: {e}")
             return
 
-
-
+def update_card_from_same_sentence(last_card, lines, game_line):
+    while game_line.id not in anki_results:
+        time.sleep(0.5)
+    anki_result = anki_results[game_line.id]
+    if anki_result.success:
+        update_anki_card(last_card, note=get_initial_card_info(last_card, lines),
+                         game_line=get_mined_line(last_card, lines), reuse_audio=True)
+    else:
+        logger.error(f"Anki update failed for card {last_card.noteId}")
+        notification.send_error_no_anki_update()
 
 
 def sentence_is_same_as_previous(last_card):

GameSentenceMiner/gametext.py

@@ -25,15 +25,18 @@ async def monitor_clipboard():
     send_message_on_resume = False
     while True:
         if not get_config().general.use_clipboard:
+            gsm_status.clipboard_enabled = False
             await asyncio.sleep(5)
             continue
         if not get_config().general.use_both_clipboard_and_websocket and any(websocket_connected.values()):
+            gsm_status.clipboard_enabled = False
             await asyncio.sleep(1)
             send_message_on_resume = True
             continue
         elif send_message_on_resume:
             logger.info("No Websocket Connections, resuming Clipboard Monitoring.")
             send_message_on_resume = False
+        gsm_status.clipboard_enabled = True
         current_clipboard = pyperclip.paste()
 
         if current_clipboard and current_clipboard != current_line:
@@ -57,6 +60,7 @@ async def listen_websockets():
             try:
                 async with websockets.connect(websocket_url, ping_interval=None) as websocket:
                     logger.info(f"TextHooker Websocket {uri} Connected!")
+                    gsm_status.websockets_connected.append(websocket_url)
                     if reconnecting:
                         logger.info(f"Texthooker WebSocket {uri} connected Successfully!" + " Disabling Clipboard Monitor." if (get_config().general.use_clipboard and not get_config().general.use_both_clipboard_and_websocket) else "")
                         reconnecting = False
@@ -79,6 +83,8 @@ async def listen_websockets():
                         if current_clipboard != current_line:
                             await handle_new_text_event(current_clipboard, line_time if line_time else None)
             except (websockets.ConnectionClosed, ConnectionError, InvalidStatus, ConnectionResetError, Exception) as e:
+                if websocket_url in gsm_status.websockets_connected:
+                    gsm_status.websockets_connected.remove(websocket_url)
                 if isinstance(e, InvalidStatus):
                     e: InvalidStatus
                     if e.response.status_code == 404:
@@ -113,6 +119,7 @@ async def handle_new_text_event(current_clipboard, line_time=None):
     current_line_after_regex = do_text_replacements(current_line, TEXT_REPLACEMENTS_FILE)
     logger.info(f"Line Received: {current_line_after_regex}")
     current_line_time = line_time if line_time else datetime.now()
+    gsm_status.last_line_received = current_line_time.strftime("%Y-%m-%d %H:%M:%S")
     add_line(current_line_after_regex, line_time)
     if len(get_text_log().values) > 0:
         await add_event_to_texthooker(get_text_log()[-1])
@@ -121,7 +128,7 @@ def reset_line_hotkey_pressed():
     global current_line_time
     logger.info("LINE RESET HOTKEY PRESSED")
     current_line_time = datetime.now()
-    gsm_state.last_mined_line = ""
+    gsm_state.last_mined_line = None
 
 
 def run_websocket_listener():

GameSentenceMiner/gsm.py

@@ -76,6 +76,7 @@ class VideoToAudioHandler(FileSystemEventHandler):
 
     def process_replay(self, video_path):
         vad_trimmed_audio = ''
+        skip_delete = False
         if "previous.mkv" in video_path:
             os.remove(video_path)
             video_path = gsm_state.previous_replay
@@ -89,92 +90,95 @@ class VideoToAudioHandler(FileSystemEventHandler):
                 last_note, anki_card_creation_time = anki.card_queue.pop(0)
             else:
                 logger.info("Replay buffer initiated externally. Skipping processing.")
+                skip_delete = True
                 return
-            with gsm_state.lock:
-                mined_line = get_text_event(last_note)
-                gsm_state.last_mined_line = mined_line
-                if os.path.exists(video_path) and os.access(video_path, os.R_OK):
-                    logger.debug(f"Video found and is readable: {video_path}")
-                if get_config().obs.minimum_replay_size and not ffmpeg.is_video_big_enough(video_path,
-                                                                                           get_config().obs.minimum_replay_size):
-                    logger.debug("Checking if video is big enough")
-                    notification.send_check_obs_notification(reason="Video may be empty, check scene in OBS.")
-                    logger.error(
-                        f"Video was unusually small, potentially empty! Check OBS for Correct Scene Settings! Path: {video_path}")
-                    return
-                if not last_note:
-                    logger.debug("Attempting to get last anki card")
-                    if get_config().anki.update_anki:
-                        last_note = anki.get_last_anki_card()
-                    if get_config().features.backfill_audio:
-                        last_note = anki.get_cards_by_sentence(gametext.current_line_after_regex)
-                line_cutoff = None
-                start_line = None
-                if mined_line:
-                    start_line = mined_line
-                    if mined_line.next:
-                        line_cutoff = mined_line.next.time
-
-                selected_lines = []
-                if texthooking_page.are_lines_selected():
-                    selected_lines = texthooking_page.get_selected_lines()
-                    start_line = selected_lines[0]
-                    mined_line = get_mined_line(last_note, selected_lines)
-                    line_cutoff = selected_lines[-1].get_next_time()
-
-                if last_note:
-                    logger.debug(last_note.to_json())
-                note = anki.get_initial_card_info(last_note, selected_lines)
-                tango = last_note.get_field(get_config().anki.word_field) if last_note else ''
-                texthooking_page.reset_checked_lines()
-
-                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(
-                        start_line,
-                        line_cutoff,
-                        video_path,
-                        anki_card_creation_time,
-                        mined_line=mined_line)
-                else:
-                    final_audio_output = ""
-                    vad_result = VADResult(False, 0, 0, '')
-                    vad_trimmed_audio = ""
-                    if not get_config().audio.enabled:
-                        logger.info("Audio is disabled in config, skipping audio processing!")
-                    elif not get_config().anki.sentence_audio_field:
-                        logger.info("No SentenceAudio Field in config, skipping audio processing!")
-
-                ss_timing = ffmpeg.get_screenshot_time(video_path, mined_line, vad_result=vad_result, doing_multi_line=bool(selected_lines))
-                # prev_ss_timing = 0
-                # if get_config().anki.previous_image_field and get_config().vad.do_vad_postprocessing:
-                #     prev_ss_timing = ffmpeg.get_screenshot_time(video_path, mined_line.prev,
-                #                                                 vad_result=VideoToAudioHandler.get_audio(game_line=mined_line.prev,
-                #                                                  next_line_time=mined_line.time,
-                #                                                  video_path=video_path,
-                #                                                  anki_card_creation_time=anki_card_creation_time,
-                #                                                  timing_only=True) ,doing_multi_line=bool(selected_lines), previous_line=True)
-
-                if get_config().anki.update_anki and last_note:
-                    anki.update_anki_card(
-                        last_note, note, audio_path=final_audio_output, video_path=video_path,
-                                          tango=tango,
-                                          should_update_audio=vad_result.success,
-                                          ss_time=ss_timing,
-                                          game_line=start_line,
-                        selected_lines=selected_lines
-                    )
-                elif get_config().features.notify_on_update and vad_result.success:
-                    notification.send_audio_generated_notification(vad_trimmed_audio)
+
+            mined_line = get_text_event(last_note)
+            gsm_state.last_mined_line = mined_line
+            if os.path.exists(video_path) and os.access(video_path, os.R_OK):
+                logger.debug(f"Video found and is readable: {video_path}")
+            if get_config().obs.minimum_replay_size and not ffmpeg.is_video_big_enough(video_path,
+                                                                                       get_config().obs.minimum_replay_size):
+                logger.debug("Checking if video is big enough")
+                notification.send_check_obs_notification(reason="Video may be empty, check scene in OBS.")
+                logger.error(
+                    f"Video was unusually small, potentially empty! Check OBS for Correct Scene Settings! Path: {video_path}")
+                return
+            if not last_note:
+                logger.debug("Attempting to get last anki card")
+                if get_config().anki.update_anki:
+                    last_note = anki.get_last_anki_card()
+                if get_config().features.backfill_audio:
+                    last_note = anki.get_cards_by_sentence(gametext.current_line_after_regex)
+            line_cutoff = None
+            start_line = None
+            if mined_line:
+                start_line = mined_line
+                if mined_line.next:
+                    line_cutoff = mined_line.next.time
+
+            selected_lines = []
+            if texthooking_page.are_lines_selected():
+                selected_lines = texthooking_page.get_selected_lines()
+                start_line = selected_lines[0]
+                mined_line = get_mined_line(last_note, selected_lines)
+                line_cutoff = selected_lines[-1].get_next_time()
+
+            if last_note:
+                logger.debug(last_note.to_json())
+            note = anki.get_initial_card_info(last_note, selected_lines)
+            tango = last_note.get_field(get_config().anki.word_field) if last_note else ''
+            texthooking_page.reset_checked_lines()
+
+            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(
+                    start_line,
+                    line_cutoff,
+                    video_path,
+                    anki_card_creation_time,
+                    mined_line=mined_line)
+            else:
+                final_audio_output = ""
+                vad_result = VADResult(False, 0, 0, '')
+                vad_trimmed_audio = ""
+                if not get_config().audio.enabled:
+                    logger.info("Audio is disabled in config, skipping audio processing!")
+                elif not get_config().anki.sentence_audio_field:
+                    logger.info("No SentenceAudio Field in config, skipping audio processing!")
+
+            ss_timing = ffmpeg.get_screenshot_time(video_path, mined_line, vad_result=vad_result, doing_multi_line=bool(selected_lines), anki_card_creation_time=anki_card_creation_time)
+            # prev_ss_timing = 0
+            # if get_config().anki.previous_image_field and get_config().vad.do_vad_postprocessing:
+            #     prev_ss_timing = ffmpeg.get_screenshot_time(video_path, mined_line.prev,
+            #                                                 vad_result=VideoToAudioHandler.get_audio(game_line=mined_line.prev,
+            #                                                  next_line_time=mined_line.time,
+            #                                                  video_path=video_path,
+            #                                                  anki_card_creation_time=anki_card_creation_time,
+            #                                                  timing_only=True) ,doing_multi_line=bool(selected_lines), previous_line=True)
+
+            if get_config().anki.update_anki and last_note:
+                anki.update_anki_card(
+                    last_note, note, audio_path=final_audio_output, video_path=video_path,
+                                      tango=tango,
+                                      should_update_audio=vad_result.success,
+                                      ss_time=ss_timing,
+                                      game_line=start_line,
+                    selected_lines=selected_lines
+                )
+            elif get_config().features.notify_on_update and vad_result.success:
+                notification.send_audio_generated_notification(vad_trimmed_audio)
         except Exception as e:
+            anki_results[mined_line.id] = AnkiUpdateResult.failure()
             logger.error(f"Failed Processing and/or adding to Anki: Reason {e}")
             logger.debug(f"Some error was hit catching to allow further work to be done: {e}", exc_info=True)
             notification.send_error_no_anki_update()
         finally:
-            if video_path and get_config().paths.remove_video and os.path.exists(video_path):
-                os.remove(video_path)  # Optionally remove the video after conversion
-            if vad_trimmed_audio and get_config().paths.remove_audio and os.path.exists(vad_trimmed_audio):
-                os.remove(vad_trimmed_audio)  # Optionally remove the screenshot after conversion
+            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)
 
     def handle_texthooker_button(self, video_path):
         try:
@@ -643,6 +647,7 @@ def async_loop():
 async def register_scene_switcher_callback():
     def scene_switcher_callback(scene):
         logger.info(f"Scene changed to: {scene}")
+        gsm_state.current_game = obs.get_current_game(sanitize=True)
         all_configured_scenes = [config.scenes for config in get_master_config().configs.values()]
         print(all_configured_scenes)
         matching_configs = [name.strip() for name, config in config_instance.configs.items() if scene.strip() in config.scenes]
@@ -691,7 +696,8 @@ async def async_main(reloading=False):
     if is_windows():
         win32api.SetConsoleCtrlHandler(handle_exit())
 
-
+    gsm_status.ready = True
+    gsm_status.status = "Ready"
     try:
         if get_config().general.open_config_on_startup:
             root.after(50, settings_window.show)

GameSentenceMiner/obs.py

@@ -31,6 +31,7 @@ class OBSConnectionManager(threading.Thread):
             try:
                 if not client or not client.get_version() and not connecting:
                     logger.info("OBS WebSocket not connected. Attempting to reconnect...")
+                    gsm_status.obs_connected = False
                     asyncio.run(connect_to_obs())
             except Exception as e:
                 logger.debug(f"Error checking OBS connection: {e}")
@@ -157,6 +158,7 @@ async def connect_to_obs(retry_count=0):
                 password=get_config().obs.password,
                 timeout=1,
             )
+            gsm_status.obs_connected = True
             logger.info("Connected to OBS WebSocket.")
             if not obs_connection_manager:
                 obs_connection_manager = OBSConnectionManager()
@@ -357,15 +359,15 @@ def get_screenshot_base64():
         return None
 
 def update_current_game():
-    configuration.current_game = get_current_scene()
+    gsm_state.current_game = get_current_scene()
 
 def get_current_game(sanitize=False):
-    if not configuration.current_game:
+    if not gsm_state.current_game:
         update_current_game()
 
     if sanitize:
-        return sanitize_filename(configuration.current_game)
-    return configuration.current_game
+        return sanitize_filename(gsm_state.current_game)
+    return gsm_state.current_game
 
 
 def main():

GameSentenceMiner/util/communication/websocket.py

@@ -27,6 +27,7 @@ class FunctionName(Enum):
     TOGGLE_REPLAY_BUFFER = "toggle_replay_buffer"
     RESTART_OBS = "restart_obs"
     EXIT = "exit"
+    GET_STATUS = "get_status"
 
 
 async def do_websocket_connection(port):

GameSentenceMiner/util/configuration.py

@@ -232,7 +232,7 @@ class Advanced:
     ocr_sends_to_clipboard: bool = True
     ocr_websocket_port: int = 9002
     texthooker_communication_websocket_port: int = 55001
-    use_anki_note_creation_time: bool = False
+    use_anki_note_creation_time: bool = True
 
 @dataclass_json
 @dataclass
@@ -633,8 +633,11 @@ logger.addHandler(console_handler)
 
 # Create rotating file handler with level DEBUG
 file_path = get_log_path()
-if os.path.exists(file_path) and os.path.getsize(file_path) > 10 * 1024 * 1024:
-    shutil.move(os.path.join(file_path, "gamesentenceminer.log"), os.path.join(file_path, "gamesentenceminer_old.log"))
+try:
+    if os.path.exists(file_path) and os.path.getsize(file_path) > 10 * 1024 * 1024 and os.access(file_path, os.W_OK):
+        shutil.move(file_path, os.path.join(os.path.dirname(file_path), "gamesentenceminer_old.log"))
+except Exception as e:
+    logger.debug("Error rotating log, probably because the file is being written to by another process.")
 
 file_handler = logging.FileHandler(file_path, encoding='utf-8')
 file_handler.setLevel(logging.DEBUG)
@@ -656,5 +659,45 @@ class GsmAppState:
         self.lock = threading.Lock()
         self.last_mined_line = None
         self.keep_running = True
+        self.current_game = ''
 
+@dataclass_json
+@dataclass
+class AnkiUpdateResult:
+    success: bool = False
+    audio_in_anki: str = ''
+    screenshot_in_anki: str = ''
+    prev_screenshot_in_anki: str = ''
+    sentence_in_anki: str = ''
+    multi_line: bool = False
+
+    @staticmethod
+    def failure():
+        return AnkiUpdateResult(success=False, audio_in_anki='', screenshot_in_anki='', prev_screenshot_in_anki='', sentence_in_anki='', multi_line=False)
+
+
+@dataclass_json
+@dataclass
+class GsmStatus:
+    ready: bool = False
+    status: bool = "Initializing"
+    cards_created: int = 0
+    websockets_connected: List[str] = field(default_factory=list)
+    obs_connected: bool = False
+    anki_connected: bool = False
+    last_line_received: str = None
+    words_being_processed: List[str] = field(default_factory=list)
+    clipboard_enabled: bool = True
+
+    def add_word_being_processed(self, word: str):
+        if word not in self.words_being_processed:
+            self.words_being_processed.append(word)
+
+    def remove_word_being_processed(self, word: str):
+        if word in self.words_being_processed:
+            self.words_being_processed.remove(word)
+
+
+gsm_status = GsmStatus()
+anki_results = {}
 gsm_state = GsmAppState()

GameSentenceMiner/util/notification.py

@@ -37,7 +37,7 @@ def open_browser_window(note_id, query=None):
                 "action": "guiBrowse",
                 "version": 6,
                 "params": {
-                    "query": "refreshing...",
+                    "query": "nid:1",
                 }
             }
             requests.post(url, json=blank_req_data, headers=headers)

GameSentenceMiner/util/text_log.py

@@ -4,8 +4,9 @@ from datetime import datetime
 from difflib import SequenceMatcher
 from typing import Optional
 
+from GameSentenceMiner.obs import get_current_game
 from GameSentenceMiner.util.gsm_utils import remove_html_and_cloze_tags
-from GameSentenceMiner.util.configuration import logger, get_config
+from GameSentenceMiner.util.configuration import logger, get_config, gsm_state
 from GameSentenceMiner.util.model import AnkiCard
 
 initial_time = datetime.now()
@@ -19,6 +20,7 @@ class GameLine:
     prev: 'GameLine | None'
     next: 'GameLine | None'
     index: int = 0
+    scene: str = ""
 
     def get_previous_time(self):
         if self.prev:
@@ -71,10 +73,11 @@ class GameText:
         new_line = GameLine(
             id=line_id,  # Time-based UUID as an integer
             text=line_text,
-            time=line_time if line_time else datetime.now(),
+            time=line_time or datetime.now(),
             prev=self.values[-1] if self.values else None,
             next=None,
-            index=self.game_line_index
+            index=self.game_line_index,
+            scene=gsm_state.current_game or ""
         )
         self.values_dict[line_id] = new_line
         logger.debug(f"Adding line: {new_line}")

GameSentenceMiner/vad.py

@@ -7,16 +7,6 @@ from GameSentenceMiner.util import configuration, ffmpeg
 from GameSentenceMiner.util.configuration import *
 from GameSentenceMiner.util.ffmpeg import get_ffprobe_path
 
-
-def get_audio_length(path):
-    result = subprocess.run(
-        [get_ffprobe_path(), "-v", "error", "-show_entries", "format=duration", "-of", "default=noprint_wrappers=1:nokey=1", path],
-        stdout=subprocess.PIPE,
-        stderr=subprocess.PIPE,
-        text=True
-    )
-    return float(result.stdout.strip())
-
 class VADResult:
     def __init__(self, success: bool, start: float, end: float, model: str, output_audio: str = None):
         self.success = success
@@ -107,6 +97,17 @@ class VADProcessor(ABC):
     def _detect_voice_activity(self, input_audio):
         pass
 
+    @staticmethod
+    def get_audio_length(path):
+        result = subprocess.run(
+            [get_ffprobe_path(), "-v", "error", "-show_entries", "format=duration", "-of",
+             "default=noprint_wrappers=1:nokey=1", path],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True
+        )
+        return float(result.stdout.strip())
+
     def process_audio(self, input_audio, output_audio, game_line):
         voice_activity = self._detect_voice_activity(input_audio)
 
@@ -119,7 +120,7 @@ class VADProcessor(ABC):
 
         # Attempt to fix the end time if the last segment is too short
         if game_line and game_line.next and len(voice_activity) > 1:
-            audio_length = get_audio_length(input_audio)
+            audio_length = self.get_audio_length(input_audio)
             if 0 > audio_length - voice_activity[-1]['start'] + get_config().audio.beginning_offset:
                 end_time = voice_activity[-2]['end']
 

GameSentenceMiner/web/texthooking_page.py

@@ -15,7 +15,7 @@ from GameSentenceMiner.util.text_log import GameLine, get_line_by_id, initial_ti
 from flask import request, jsonify, send_from_directory
 import webbrowser
 from GameSentenceMiner import obs
-from GameSentenceMiner.util.configuration import logger, get_config, DB_PATH, gsm_state
+from GameSentenceMiner.util.configuration import logger, get_config, DB_PATH, gsm_state, gsm_status
 
 port = get_config().general.texthooker_port
 url = f"http://localhost:{port}"
@@ -294,6 +294,12 @@ def play_audio():
     return jsonify({}), 200
 
 
+@app.route('/get_status', methods=['GET'])
+def get_status():
+    gsm_status.clipboard_enabled
+    return jsonify(gsm_status.to_dict()), 200
+
+
 # async def main():
 #     async with websockets.serve(websocket_handler, "localhost", 8765): # Choose a port for WebSocket
 #         print("WebSocket server started on ws://localhost:8765/ws (adjust as needed)")

{gamesentenceminer-2.9.14.dist-info → gamesentenceminer-2.9.16.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: GameSentenceMiner
-Version: 2.9.14
+Version: 2.9.16
 Summary: A tool for mining sentences from games.
 Author-email: Beangate <bpwhelan95@gmail.com>
 License: MIT License

{gamesentenceminer-2.9.14.dist-info → gamesentenceminer-2.9.16.dist-info}/RECORD

@@ -1,10 +1,10 @@
 GameSentenceMiner/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-GameSentenceMiner/anki.py,sha256=tMX6nTVO2PKgXXHM6uh1XaWBYEvZq-6VPhuTSbBrE-Y,15075
+GameSentenceMiner/anki.py,sha256=hNHBIoJRrsWIhLe0sehOYPXTWzPREeXl4gYCPHUCaiE,16331
 GameSentenceMiner/config_gui.py,sha256=iAOLD47sQW67kzBcZKSQ0Dwctc1ngZK1lwSVIaLpQPI,83559
-GameSentenceMiner/gametext.py,sha256=mM-gw1d7c2EEvMUznaAevTQFLswNZavCuxMXhA9pV4g,6251
-GameSentenceMiner/gsm.py,sha256=hmdgvad7k6mei2M0TywNfdaWt6I_1U6o3MNHJaGTMvQ,29307
-GameSentenceMiner/obs.py,sha256=O9NYOGu7kwp4flq8LLXp8YJQg0JTZ8qBqiQNQ6u4ku4,14724
-GameSentenceMiner/vad.py,sha256=Gk_VthD7mDp3-wM_S6bEv8ykGmqzCDbbcRiaEBzAE_o,14835
+GameSentenceMiner/gametext.py,sha256=iO1o2980XBzBc2nsgBVr_ZaKHRLotebVpDhwGqBCK9k,6696
+GameSentenceMiner/gsm.py,sha256=j6Y4Nd79Qi09r-Pgt2y3THxeP-yBAfZSFbbsISE9Ah8,29251
+GameSentenceMiner/obs.py,sha256=21GQ4DzjccLc-m4rU5Tfm4E3n1R1U4vRwmIWfKqcjmw,14805
+GameSentenceMiner/vad.py,sha256=TbP3NVdjfB1TFJeB0QpOXZysgo_UHHKLdx95pYmM0JI,14902
 GameSentenceMiner/ai/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 GameSentenceMiner/ai/ai_prompting.py,sha256=0jBAnngNwmc3dqJiVWe_QRy4Syr-muV-ML2rq0FiUtU,10215
 GameSentenceMiner/assets/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -28,24 +28,24 @@ GameSentenceMiner/owocr/owocr/ocr.py,sha256=vZR3du1fGg5-3cmPvYKTO4PFk7Lxyf6-BrIy
 GameSentenceMiner/owocr/owocr/run.py,sha256=U6VIfCvsNPADG3twhp4SQVX1xhihSAGGrBnQj2x0C2c,54964
 GameSentenceMiner/owocr/owocr/screen_coordinate_picker.py,sha256=Na6XStbQBtpQUSdbN3QhEswtKuU1JjReFk_K8t5ezQE,3395
 GameSentenceMiner/util/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-GameSentenceMiner/util/configuration.py,sha256=5YJSKelIpBTK7ggpGUERf17xVwH8Hy9GzvJ12eP8kHs,26095
+GameSentenceMiner/util/configuration.py,sha256=Wgr1UAf_JoXBlp9h_f3-d2DAmIWnR1FtCmMX6mCfMNM,27461
 GameSentenceMiner/util/electron_config.py,sha256=3VmIrcXhC-wIMMc4uqV85NrNenRl4ZUbnQfSjWEwuig,9852
 GameSentenceMiner/util/ffmpeg.py,sha256=daItJprEqi5PQe-aFb836rls3tBHNqIQKz61vlJK07M,19276
 GameSentenceMiner/util/gsm_utils.py,sha256=Z_Lu4jSIfUaM2VljIJXQkSJD0UsyJ5hMB46H2NS0gZo,8819
 GameSentenceMiner/util/model.py,sha256=iDtLTfR6D-ZC0gCiDqYno6-gA6Z07PZTM4B5MAA6xZI,5704
-GameSentenceMiner/util/notification.py,sha256=hAUKWWDB4F_9exQhgiajfP5DT8u464RowsJGmBVRN_E,3882
+GameSentenceMiner/util/notification.py,sha256=0OnEYjn3DUEZ6c6OtPjdVZe-DG-QSoMAl9fetjjCvNU,3874
 GameSentenceMiner/util/package.py,sha256=u1ym5z869lw5EHvIviC9h9uH97bzUXSXXA8KIn8rUvk,1157
 GameSentenceMiner/util/ss_selector.py,sha256=oCzmDbpEGvVselF-oDPIrBcQktGIZT0Zt16uDLDAHMQ,4493
-GameSentenceMiner/util/text_log.py,sha256=wdFOapIwHzDntR9G0YzJzDcbhO6b1taFkhdgsTnRGJ4,5356
+GameSentenceMiner/util/text_log.py,sha256=VhdiF2UIlGYW42CFurkaeKa6W8x7Z5klXN9GhY1JLIA,5471
 GameSentenceMiner/util/communication/__init__.py,sha256=xh__yn2MhzXi9eLi89PeZWlJPn-cbBSjskhi1BRraXg,643
 GameSentenceMiner/util/communication/send.py,sha256=Wki9qIY2CgYnuHbmnyKVIYkcKAN_oYS4up93XMikBaI,222
-GameSentenceMiner/util/communication/websocket.py,sha256=gPgxA2R2U6QZJjPqbUgODC87gtacPhmuC8lCprIkSmA,3287
+GameSentenceMiner/util/communication/websocket.py,sha256=TbphRGmxVrgEupS7tNdifsmQfWDfIp0Hio2cSiUKgsk,3317
 GameSentenceMiner/util/downloader/Untitled_json.py,sha256=RUUl2bbbCpUDUUS0fP0tdvf5FngZ7ILdA_J5TFYAXUQ,15272
 GameSentenceMiner/util/downloader/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 GameSentenceMiner/util/downloader/download_tools.py,sha256=mvnOjDHFlV1AbjHaNI7mdnC5_CH5k3N4n1ezqzzbzGA,8139
 GameSentenceMiner/util/downloader/oneocr_dl.py,sha256=o3ANp5IodEQoQ8GPcJdg9Y8JzA_lictwnebFPwwUZVk,10144
 GameSentenceMiner/web/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-GameSentenceMiner/web/texthooking_page.py,sha256=RR70Vgde3wNHarQHbB-LBbEP-z95vRD5rtlW0GgdjmQ,15037
+GameSentenceMiner/web/texthooking_page.py,sha256=kDRNeTz6eIzc9rqrnupAqEmdVF3GuhB1PSgv9azEaAI,15191
 GameSentenceMiner/web/static/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 GameSentenceMiner/web/static/apple-touch-icon.png,sha256=OcMI8af_68DA_tweOsQ5LytTyMwm7-hPW07IfrOVgEs,46132
 GameSentenceMiner/web/static/favicon-96x96.png,sha256=lOePzjiKl1JY2J1kT_PMdyEnrlJmi5GWbmXJunM12B4,16502
@@ -59,9 +59,9 @@ GameSentenceMiner/web/templates/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm
 GameSentenceMiner/web/templates/index.html,sha256=HZKiIjiGJV8PGQ9T2aLDUNSfJn71qOwbYCjbRuSIjpY,213583
 GameSentenceMiner/web/templates/text_replacements.html,sha256=tV5c8mCaWSt_vKuUpbdbLAzXZ3ATZeDvQ9PnnAfqY0M,8598
 GameSentenceMiner/web/templates/utility.html,sha256=3flZinKNqUJ7pvrZk6xu__v67z44rXnaK7UTZ303R-8,16946
-gamesentenceminer-2.9.14.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-gamesentenceminer-2.9.14.dist-info/METADATA,sha256=H-FYTe-rnsAEphGMvv9OJthUnHzJPt9kSSHF924m98Y,7221
-gamesentenceminer-2.9.14.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-gamesentenceminer-2.9.14.dist-info/entry_points.txt,sha256=2APEP25DbfjSxGeHtwBstMH8mulVhLkqF_b9bqzU6vQ,65
-gamesentenceminer-2.9.14.dist-info/top_level.txt,sha256=V1hUY6xVSyUEohb0uDoN4UIE6rUZ_JYx8yMyPGX4PgQ,18
-gamesentenceminer-2.9.14.dist-info/RECORD,,
+gamesentenceminer-2.9.16.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+gamesentenceminer-2.9.16.dist-info/METADATA,sha256=ybDsHKiVvTzpQUq5v7g8XQa8NKmf0Vl0Pcsuw18DXIo,7221
+gamesentenceminer-2.9.16.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+gamesentenceminer-2.9.16.dist-info/entry_points.txt,sha256=2APEP25DbfjSxGeHtwBstMH8mulVhLkqF_b9bqzU6vQ,65
+gamesentenceminer-2.9.16.dist-info/top_level.txt,sha256=V1hUY6xVSyUEohb0uDoN4UIE6rUZ_JYx8yMyPGX4PgQ,18
+gamesentenceminer-2.9.16.dist-info/RECORD,,