GameSentenceMiner 2.9.9__py3-none-any.whl → 2.9.11__py3-none-any.whl

GameSentenceMiner/ai/ai_prompting.py

@@ -10,6 +10,7 @@ from google.generativeai import GenerationConfig
 from groq import Groq
 
 from GameSentenceMiner.util.configuration import get_config, Ai, logger
+from GameSentenceMiner.util.gsm_utils import is_connected
 from GameSentenceMiner.util.text_log import GameLine
 
 # Suppress debug logs from httpcore
@@ -184,6 +185,9 @@ current_ai_config: Ai | None = None
 def get_ai_prompt_result(lines: List[GameLine], sentence: str, current_line: GameLine, game_title: str = ""):
     global ai_manager, current_ai_config
     try:
+        if not is_connected():
+            logger.error("No internet connection. Unable to proceed with AI prompt.")
+            return ""
         if not ai_manager or get_config().ai != current_ai_config:
             if get_config().ai.provider == AIType.GEMINI.value:
                 ai_manager = GeminiAI(model=get_config().ai.gemini_model, api_key=get_config().ai.gemini_api_key, logger=logger)

GameSentenceMiner/anki.py

@@ -8,7 +8,8 @@ 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 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 *
 from GameSentenceMiner.util.configuration import get_config
@@ -39,15 +40,17 @@ def update_anki_card(last_note: AnkiCard, note=None, audio_path='', video_path='
     if not reuse_audio:
         if update_audio:
             audio_in_anki = store_media_file(audio_path)
+            if get_config().audio.external_tool and get_config().audio.external_tool_enabled:
+                open_audio_in_external(f"{get_config().audio.anki_media_collection}/{audio_in_anki}")
         if update_picture:
             logger.info("Getting Screenshot...")
-            screenshot = ffmpeg.get_screenshot(video_path, ss_time)
+            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)
+            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)
             prev_screenshot_in_anki = store_media_file(prev_screenshot)
             if get_config().paths.remove_screenshot:
@@ -92,12 +95,7 @@ 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])
 
-    check_and_update_note(last_note, note, tags)
-
-    if get_config().features.notify_on_update:
-        notification.send_note_updated(tango)
-    if get_config().audio.external_tool and get_config().audio.external_tool_enabled and update_audio:
-        open_audio_in_external(f"{get_config().audio.anki_media_collection}/{audio_in_anki}")
+    run_new_thread(lambda: check_and_update_note(last_note, note, tags))
 
 def check_and_update_note(last_note, note, tags=[]):
     selected_notes = invoke("guiSelectedNotes")
@@ -110,13 +108,8 @@ def check_and_update_note(last_note, note, tags=[]):
         notification.open_browser_window(last_note.noteId, get_config().features.browser_query)
     if get_config().features.open_anki_edit:
         notification.open_anki_card(last_note.noteId)
-
-def open_audio_in_external(fileabspath, shell=False):
-    logger.info(f"Opening audio in external program...")
-    if shell:
-        subprocess.Popen(f' "{get_config().audio.external_tool}" "{fileabspath}" ', shell=True)
-    else:
-        subprocess.Popen([get_config().audio.external_tool, fileabspath])
+    if get_config().features.notify_on_update:
+        notification.send_note_updated(last_note.noteId)
 
 
 def add_image_to_card(last_note: AnkiCard, image_path):
@@ -135,7 +128,7 @@ def add_image_to_card(last_note: AnkiCard, image_path):
     if update_picture:
         note['fields'][get_config().anki.picture_field] = image_html
 
-    check_and_update_note(last_note, note)
+    run_new_thread(lambda: check_and_update_note(last_note, note))
 
     logger.info(f"UPDATED IMAGE FOR ANKI CARD {last_note.noteId}")
 
@@ -311,7 +304,7 @@ def update_new_card():
 def sentence_is_same_as_previous(last_card):
     if not gsm_state.last_mined_line:
         return False
-    return remove_html_and_cloze_tags(get_sentence(last_card)) == remove_html_and_cloze_tags(gsm_state.last_mined_line)
+    return gsm_state.last_mined_line.id == get_mined_line(last_card).id
 
 def get_sentence(card):
     return card.get_field(get_config().anki.sentence_field)

GameSentenceMiner/config_gui.py

@@ -184,10 +184,11 @@ class ConfigApp:
                 extension=self.screenshot_extension.get(),
                 custom_ffmpeg_settings=self.screenshot_custom_ffmpeg_settings.get(),
                 screenshot_hotkey_updates_anki=self.screenshot_hotkey_update_anki.get(),
-                seconds_after_line = self.seconds_after_line.get(),
+                seconds_after_line = float(self.seconds_after_line.get()) if self.seconds_after_line.get() else 0.0,
                 # use_beginning_of_line_as_screenshot=self.use_beginning_of_line_as_screenshot.get(),
                 # use_new_screenshot_logic=self.use_new_screenshot_logic.get(),
-                screenshot_timing_setting=self.screenshot_timing.get()
+                screenshot_timing_setting=self.screenshot_timing.get(),
+                use_screenshot_selector=self.use_screenshot_selector.get(),
             ),
             audio=Audio(
                 enabled=self.audio_enabled.get(),
@@ -198,6 +199,7 @@ class ConfigApp:
                 external_tool = self.external_tool.get(),
                 anki_media_collection=self.anki_media_collection.get(),
                 external_tool_enabled=self.external_tool_enabled.get(),
+                pre_vad_end_offset=float(self.pre_vad_audio_offset.get()),
             ),
             obs=OBS(
                 enabled=self.obs_enabled.get(),
@@ -483,6 +485,13 @@ class ConfigApp:
         self.vad_beginning_offset.grid(row=self.current_row, column=1)
         self.add_label_and_increment_row(vad_frame, 'Beginning offset after VAD Trim, Only active if "Trim Beginning" is ON. Negative values = more time at the beginning', row=self.current_row, column=2)
 
+        ttk.Label(vad_frame, text="Audio End Offset:").grid(row=self.current_row, column=0, sticky='W')
+        self.end_offset = ttk.Entry(vad_frame)
+        self.end_offset.insert(0, str(self.settings.audio.end_offset))
+        self.end_offset.grid(row=self.current_row, column=1)
+        self.add_label_and_increment_row(vad_frame, "Offset in seconds from end of the video to extract.",
+                                         row=self.current_row, column=2)
+
         ttk.Label(vad_frame, text="Add Audio on No Results:").grid(row=self.current_row, column=0, sticky='W')
         self.add_audio_on_no_results = tk.BooleanVar(value=self.settings.vad.add_audio_on_no_results)
         ttk.Checkbutton(vad_frame, variable=self.add_audio_on_no_results).grid(row=self.current_row, column=1, sticky='W')
@@ -847,6 +856,12 @@ class ConfigApp:
         self.add_label_and_increment_row(screenshot_frame, "Time in seconds to offset the screenshot based on the Timing setting above (should almost always be positive, can be negative if you use \"middle\")", row=self.current_row,
                                          column=2)
 
+        ttk.Label(screenshot_frame, text="Use Screenshot Selector for every card:").grid(row=self.current_row, column=0, sticky='W')
+        self.use_screenshot_selector = tk.BooleanVar(value=self.settings.screenshot.use_screenshot_selector)
+        ttk.Checkbutton(screenshot_frame, variable=self.use_screenshot_selector).grid(row=self.current_row, column=1, sticky='W')
+        self.add_label_and_increment_row(screenshot_frame, "Enable to use the screenshot selector to choose the screenshot point on every card.", row=self.current_row,
+                                            column=2)
+
         # ttk.Label(screenshot_frame, text="Use Beginning of Line as Screenshot:").grid(row=self.current_row, column=0, sticky='W')
         # self.use_beginning_of_line_as_screenshot = tk.BooleanVar(value=self.settings.screenshot.use_beginning_of_line_as_screenshot)
         # ttk.Checkbutton(screenshot_frame, variable=self.use_beginning_of_line_as_screenshot).grid(row=self.current_row, column=1, sticky='W')
@@ -883,19 +898,21 @@ class ConfigApp:
         self.audio_extension.grid(row=self.current_row, column=1)
         self.add_label_and_increment_row(audio_frame, "File extension for audio files.", row=self.current_row, column=2)
 
-        ttk.Label(audio_frame, text="Beginning Offset:").grid(row=self.current_row, column=0, sticky='W')
+
+        ttk.Label(audio_frame, text="Audio Extraction Beginning Offset:").grid(row=self.current_row, column=0, sticky='W')
         self.beginning_offset = ttk.Entry(audio_frame)
         self.beginning_offset.insert(0, str(self.settings.audio.beginning_offset))
         self.beginning_offset.grid(row=self.current_row, column=1)
-        self.add_label_and_increment_row(audio_frame, "Offset in seconds to start audio processing.",
+        self.add_label_and_increment_row(audio_frame, "Offset in seconds from beginning of the video to extract",
                                          row=self.current_row, column=2)
 
-        ttk.Label(audio_frame, text="End Offset:").grid(row=self.current_row, column=0, sticky='W')
-        self.end_offset = ttk.Entry(audio_frame)
-        self.end_offset.insert(0, str(self.settings.audio.end_offset))
-        self.end_offset.grid(row=self.current_row, column=1)
-        self.add_label_and_increment_row(audio_frame, "Offset in seconds to end audio processing.",
-                                         row=self.current_row, column=2)
+        ttk.Label(audio_frame, text="Audio Extraction End Offset:").grid(row=self.current_row, column=0, sticky='W')
+        self.pre_vad_audio_offset = ttk.Entry(audio_frame)
+        self.pre_vad_audio_offset.insert(0, str(self.settings.audio.pre_vad_end_offset))
+        self.pre_vad_audio_offset.grid(row=self.current_row, column=1)
+        self.add_label_and_increment_row(audio_frame, "Offset in seconds to trim from the end before VAD processing starts. Negative = Less time on the end of the pre-vad trimmed audio (should usually be negative)",
+                                            row=self.current_row, column=2)
+
 
         ttk.Label(audio_frame, text="FFmpeg Preset Options:").grid(row=self.current_row, column=0, sticky='W')
 

GameSentenceMiner/gsm.py

@@ -2,7 +2,12 @@ import asyncio
 import subprocess
 import sys
 
-from GameSentenceMiner.util.gsm_utils import wait_for_stable_file, make_unique_file_name, run_new_thread
+import os
+
+os.environ.pop('TCL_LIBRARY', None)
+
+from GameSentenceMiner.util.gsm_utils import wait_for_stable_file, make_unique_file_name, run_new_thread, \
+    open_audio_in_external
 from GameSentenceMiner.util.communication.send import send_restart_signal
 from GameSentenceMiner.util.downloader.download_tools import download_obs_if_needed, download_ffmpeg_if_needed
 from GameSentenceMiner.vad import vad_processor, VADResult
@@ -13,12 +18,12 @@ try:
     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
+    import psutil
 
 
     from GameSentenceMiner import anki
@@ -86,7 +91,8 @@ class VideoToAudioHandler(FileSystemEventHandler):
                 logger.info("Replay buffer initiated externally. Skipping processing.")
                 return
             with gsm_state.lock:
-                gsm_state.last_mined_line = anki.get_sentence(last_note)
+                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,
@@ -104,7 +110,6 @@ class VideoToAudioHandler(FileSystemEventHandler):
                         last_note = anki.get_cards_by_sentence(gametext.current_line_after_regex)
                 line_cutoff = None
                 start_line = None
-                mined_line = get_text_event(last_note)
                 if mined_line:
                     start_line = mined_line
                     if mined_line.next:
@@ -151,12 +156,14 @@ class VideoToAudioHandler(FileSystemEventHandler):
                 #                                                  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,
+                    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)
+                        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:
@@ -268,7 +275,7 @@ def play_video_in_external(line, filepath):
 
     command = [get_config().advanced.video_player_path]
 
-    start, _, _ = get_video_timings(filepath, line)
+    start, _, _, _ = get_video_timings(filepath, line)
 
     if start:
         if "vlc" in get_config().advanced.video_player_path:
@@ -708,4 +715,3 @@ if __name__ == "__main__":
         asyncio.run(async_main())
     except Exception as e:
         logger.exception(e)
-        time.sleep(5)

GameSentenceMiner/ocr/owocr_helper.py

@@ -211,7 +211,7 @@ def do_second_ocr(ocr1_text, time, img, filtering, scrolling=False):
                                                         engine=ocr2)
         if scrolling:
             return text
-        if fuzz.ratio(last_ocr2_result, text) >= 80:
+        if fuzz.ratio(last_ocr2_result, text) >= 90:
             logger.info("Seems like the same text from previous ocr2 result, not sending")
             return
         save_result_image(img)
@@ -280,6 +280,8 @@ def text_callback(text, orig_text, time, img=None, came_from_ss=False, filtering
         last_oneocr_time = None
         return
     if not text or force_stable:
+            # or FUTURE ATTEMPT, I THINK THIS IS CLOSE?
+            # (orig_text and previous_text and len(orig_text) == len(previous_text_list) and len(orig_text[0] < len(previous_text_list)))):
         force_stable = False
         if previous_text and text_stable_start_time:
             stable_time = text_stable_start_time

GameSentenceMiner/owocr/owocr/ocr.py

@@ -763,6 +763,13 @@ class OneOCR:
 
     def __call__(self, img):
         img = input_to_pil_image(img)
+        if img.width < 51 or img.height < 51:
+            new_width = max(img.width, 51)
+            new_height = max(img.height, 51)
+            new_img = Image.new("RGBA", (new_width, new_height), (0, 0, 0, 0))
+            new_img.paste(img, ((new_width - img.width) // 2, (new_height - img.height) // 2))
+            img = new_img
+
         if not img:
             return (False, 'Invalid image provided')
         crop_coords = None

GameSentenceMiner/owocr/owocr/run.py

@@ -381,11 +381,15 @@ class TextFiltering:
             else:
                 orig_text_filtered.append(None)
 
-        if isinstance(last_result, list):
-            last_text = last_result
-        elif last_result and last_result[1] == engine_index:
-            last_text = last_result[0]
-        else:
+        try:
+            if isinstance(last_result, list):
+                last_text = last_result
+            elif last_result and last_result[1] == engine_index:
+                last_text = last_result[0]
+            else:
+                last_text = []
+        except Exception as e:
+            logger.error(f"Error processing last_result {last_result}: {e}")
             last_text = []
 
         new_blocks = []
@@ -895,7 +899,6 @@ def process_and_write_results(img_or_path, write_to=None, last_result=None, filt
     result = engine_instance(img_or_path)
     res, text, crop_coords = (*result, None)[:3]
 
-    end_time = time.time()
 
     if not res and ocr_2 == engine:
         logger.opt(ansi=True).info(f"<{engine_color}>{engine_instance.readable_name}</{engine_color}> failed with message: {text}, trying <{engine_color}>{ocr_1}</{engine_color}>")
@@ -905,9 +908,13 @@ def process_and_write_results(img_or_path, write_to=None, last_result=None, filt
                 if last_result:
                     last_result = []
                 break
+        start_time = time.time()
         result = engine_instance(img_or_path)
         res, text, crop_coords = (*result, None)[:3]
 
+    end_time = time.time()
+
+
     orig_text = []
     # print(filtering)
     #

GameSentenceMiner/util/configuration.py

@@ -145,6 +145,7 @@ class Screenshot:
     use_beginning_of_line_as_screenshot: bool = True
     use_new_screenshot_logic: bool = False
     screenshot_timing_setting: str = ''  # 'middle', 'end'
+    use_screenshot_selector: bool = False
 
     def __post_init__(self):
         if not self.screenshot_timing_setting and self.use_beginning_of_line_as_screenshot:
@@ -163,6 +164,7 @@ class Audio:
     extension: str = 'opus'
     beginning_offset: float = 0.0
     end_offset: float = 0.5
+    pre_vad_end_offset: float = 0.0
     ffmpeg_reencode_options: str = '-c:a libopus -f opus -af \"afade=t=in:d=0.10\"' if is_windows() else ''
     external_tool: str = ""
     anki_media_collection: str = ""
@@ -629,11 +631,14 @@ console_handler.setFormatter(formatter)
 logger.addHandler(console_handler)
 
 # Create rotating file handler with level DEBUG
-if 'gsm' in sys.argv[0].lower() or 'gamesentenceminer' in sys.argv[0].lower():
-    file_handler = RotatingFileHandler(get_log_path(), maxBytes=1024 * 1024, backupCount=5, encoding='utf-8')
-    file_handler.setLevel(logging.DEBUG)
-    file_handler.setFormatter(formatter)
-    logger.addHandler(file_handler)
+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"))
+
+file_handler = logging.FileHandler(file_path, encoding='utf-8')
+file_handler.setLevel(logging.DEBUG)
+file_handler.setFormatter(formatter)
+logger.addHandler(file_handler)
 
 DB_PATH = os.path.join(get_app_directory(), 'gsm.db')
 

GameSentenceMiner/util/electron_config.py

@@ -7,13 +7,13 @@ from dataclasses_json import dataclass_json
 from GameSentenceMiner.util.configuration import get_app_directory
 
 
-@dataclass_json
-@dataclass
-class SteamGame:
-    id: int
-    name: str
-    processName: str
-    script: str
+# @dataclass_json
+# @dataclass
+# class SteamGame:
+#     id: str = ''
+#     name: str = ''
+#     processName: str = ''
+#     script: str = ''
 
 @dataclass_json
 @dataclass
@@ -31,13 +31,13 @@ class VNConfig:
     launchVNOnStart: str = ""
     lastVNLaunched: str = ""
 
-@dataclass_json
-@dataclass
-class SteamConfig:
-    steamPath: str = ""
-    steamGames: List[SteamGame] = field(default_factory=list)
-    launchSteamOnStart: int = 0
-    lastGameLaunched: int = 0
+# @dataclass_json
+# @dataclass
+# class SteamConfig:
+#     steamPath: str = ""
+#     steamGames: List[SteamGame] = field(default_factory=list)
+#     launchSteamOnStart: int = 0
+#     lastGameLaunched: int = 0
 
 @dataclass_json
 @dataclass
@@ -60,7 +60,7 @@ class StoreConfig:
     autoUpdateGSMApp: bool = False
     pythonPath: str = ""
     VN: VNConfig = field(default_factory=VNConfig)
-    steam: SteamConfig = field(default_factory=SteamConfig)
+    # steam: SteamConfig = field(default_factory=SteamConfig)
     agentPath: str = ""
     OCR: OCRConfig = field(default_factory=OCRConfig)
 
@@ -290,12 +290,12 @@ def get_last_steam_game_launched() -> int:
 def set_last_steam_game_launched(game_id: int):
     store.set('steam.lastGameLaunched', game_id)
 
-def get_steam_games() -> List[SteamGame]:
-    steam_games_data = store.get('steam.steamGames')
-    return [SteamGame.from_dict(game_data) for game_data in steam_games_data] if isinstance(steam_games_data, list) else []
+# def get_steam_games() -> List[SteamGame]:
+#     steam_games_data = store.get('steam.steamGames')
+#     return [SteamGame.from_dict(game_data) for game_data in steam_games_data] if isinstance(steam_games_data, list) else []
 
-def set_steam_games(games: List[SteamGame]):
-    store.set('steam.steamGames', [game.to_dict() for game in games])
+# def set_steam_games(games: List[SteamGame]):
+#     store.set('steam.steamGames', [game.to_dict() for game in games])
 
 # if __name__ == "__main__":
 #     # Example usage:

GameSentenceMiner/util/ffmpeg.py

@@ -298,20 +298,27 @@ def get_video_duration(file_path):
 def trim_audio_based_on_last_line(untrimmed_audio, video_path, game_line, next_line, anki_card_creation_time):
     trimmed_audio = tempfile.NamedTemporaryFile(dir=configuration.get_temporary_directory(),
                                                 suffix=f".{get_config().audio.extension}").name
-    start_trim_time, total_seconds, total_seconds_after_offset = get_video_timings(video_path, game_line, anki_card_creation_time)
+    start_trim_time, total_seconds, total_seconds_after_offset, file_length = get_video_timings(video_path, game_line, anki_card_creation_time)
     end_trim_time = ""
 
     ffmpeg_command = ffmpeg_base_command_list + [
         "-i", untrimmed_audio,
         "-ss", str(start_trim_time)]
     if next_line and next_line > game_line.time:
-        end_total_seconds = total_seconds + (next_line - game_line.time).total_seconds() + 1
+        end_total_seconds = total_seconds + (next_line - game_line.time).total_seconds() + get_config().audio.pre_vad_end_offset
         hours, remainder = divmod(end_total_seconds, 3600)
         minutes, seconds = divmod(remainder, 60)
         end_trim_time = "{:02}:{:02}:{:06.3f}".format(int(hours), int(minutes), seconds)
         ffmpeg_command.extend(['-to', end_trim_time])
         logger.debug(
             f"Looks Like this is mining from History, or Multiple Lines were selected Trimming end of audio to {end_trim_time}")
+    elif get_config().audio.pre_vad_end_offset and get_config().audio.pre_vad_end_offset < 0:
+        end_total_seconds = file_length + get_config().audio.pre_vad_end_offset
+        hours, remainder = divmod(end_total_seconds, 3600)
+        minutes, seconds = divmod(remainder, 60)
+        end_trim_time = "{:02}:{:02}:{:06.3f}".format(int(hours), int(minutes), seconds)
+        ffmpeg_command.extend(['-to', end_trim_time])
+        logger.debug(f"Trimming end of audio to {end_trim_time} due to pre-vad end offset")
 
     ffmpeg_command.extend([
         "-c", "copy",  # Using copy to avoid re-encoding, adjust if needed
@@ -349,7 +356,7 @@ def get_video_timings(video_path, game_line, anki_card_creation_time=None):
     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
+    return start_trim_time, total_seconds, total_seconds_after_offset, file_length
 
 
 def reencode_file_with_user_config(input_file, final_output_audio, user_ffmpeg_options):

GameSentenceMiner/util/gsm_utils.py

@@ -2,6 +2,7 @@ import json
 import os
 import random
 import re
+import socket
 import string
 import subprocess
 import threading
@@ -220,6 +221,22 @@ def do_text_replacements(text, replacements_json):
     return text
 
 
+def open_audio_in_external(fileabspath, shell=False):
+    logger.info(f"Opening audio in external program...")
+    if shell:
+        subprocess.Popen(f' "{get_config().audio.external_tool}" "{fileabspath}" ', shell=True)
+    else:
+        subprocess.Popen([get_config().audio.external_tool, fileabspath])
+
+def is_connected():
+    try:
+        # Attempt to connect to a well-known host
+        socket.create_connection(("www.google.com", 80), timeout=2)
+        return True
+    except OSError:
+        return False
+
+
 TEXT_REPLACEMENTS_FILE = os.path.join(get_app_directory(), 'config', 'text_replacements.json')
 OCR_REPLACEMENTS_FILE = os.path.join(get_app_directory(), 'config', 'ocr_replacements.json')
 os.makedirs(os.path.dirname(TEXT_REPLACEMENTS_FILE), exist_ok=True)

GameSentenceMiner/util/notification.py

@@ -32,9 +32,21 @@ def open_browser_window(note_id, query=None):
     }
 
     try:
+        if query:
+            blank_req_data = {
+                "action": "guiBrowse",
+                "version": 6,
+                "params": {
+                    "query": "refreshing...",
+                }
+            }
+            requests.post(url, json=blank_req_data, headers=headers)
         response = requests.post(url, json=data, headers=headers)
         if response.status_code == 200:
-            logger.info(f"Opened Anki note with ID {note_id}")
+            if query:
+                logger.info(f"Opened Anki browser with query: {query}")
+            else:
+                logger.info(f"Opened Anki note in browser with ID {note_id}")
         else:
             logger.error(f"Failed to open Anki note with ID {note_id}")
     except Exception as e:

GameSentenceMiner/util/text_log.py

@@ -151,7 +151,9 @@ def get_line_and_future_lines(last_note):
     return found_lines
 
 
-def get_mined_line(last_note: AnkiCard, lines):
+def get_mined_line(last_note: AnkiCard, lines=None):
+    if lines is None:
+        lines = []
     if not last_note:
         return lines[-1]
     if not lines:

{gamesentenceminer-2.9.9.dist-info → gamesentenceminer-2.9.11.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: GameSentenceMiner
-Version: 2.9.9
+Version: 2.9.11
 Summary: A tool for mining sentences from games.
 Author-email: Beangate <bpwhelan95@gmail.com>
 License: MIT License
@@ -37,7 +37,6 @@ Requires-Dist: pygetwindow; sys_platform == "win32"
 Requires-Dist: flask
 Requires-Dist: groq
 Requires-Dist: obsws-python~=1.7.2
-Requires-Dist: Flask-SocketIO
 Dynamic: license-file
 
 # GameSentenceMiner (GSM)

{gamesentenceminer-2.9.9.dist-info → gamesentenceminer-2.9.11.dist-info}/RECORD

@@ -1,12 +1,12 @@
 GameSentenceMiner/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-GameSentenceMiner/anki.py,sha256=OPamV4p5mSEkfrUdflauzDJ4Uh2rLYtHq9F7D1aMyhY,15077
-GameSentenceMiner/config_gui.py,sha256=r-ASCXVNS4Io6Ej3svwC8aJEWc9Rc7u-pzfsAwD4ru8,82079
+GameSentenceMiner/anki.py,sha256=1DN00SUCSd4adIRrEqirXXf-2jSeFEuYNrr_WB8nlVE,14950
+GameSentenceMiner/config_gui.py,sha256=3prvLmQ8LBw5jEYBIelPW_cdmxcpS375tYs4YY7FbSI,83544
 GameSentenceMiner/gametext.py,sha256=mM-gw1d7c2EEvMUznaAevTQFLswNZavCuxMXhA9pV4g,6251
-GameSentenceMiner/gsm.py,sha256=fSMVLyglpqNy8h5NsznWYap-Bu41tVUPwApWUpvSadY,29105
+GameSentenceMiner/gsm.py,sha256=ycv1wMEqTBM919qC5rlr0AVzfPwpYP1yIrbSgfibv4I,29174
 GameSentenceMiner/obs.py,sha256=O9NYOGu7kwp4flq8LLXp8YJQg0JTZ8qBqiQNQ6u4ku4,14724
 GameSentenceMiner/vad.py,sha256=Gk_VthD7mDp3-wM_S6bEv8ykGmqzCDbbcRiaEBzAE_o,14835
 GameSentenceMiner/ai/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-GameSentenceMiner/ai/ai_prompting.py,sha256=tPDiTHlrfZul0hlvEFgZS4V_6oaHkVb-4v79Sd4gtlM,10018
+GameSentenceMiner/ai/ai_prompting.py,sha256=0jBAnngNwmc3dqJiVWe_QRy4Syr-muV-ML2rq0FiUtU,10215
 GameSentenceMiner/assets/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 GameSentenceMiner/assets/icon.png,sha256=9GRL8uXUAgkUSlvbm9Pv9o2poFVRGdW6s2ub_DeUD9M,937624
 GameSentenceMiner/assets/icon128.png,sha256=l90j7biwdz5ahwOd5wZ-406ryEV9Pan93dquJQ3e1CI,18395
@@ -19,24 +19,24 @@ GameSentenceMiner/ocr/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3h
 GameSentenceMiner/ocr/gsm_ocr_config.py,sha256=fEQ2o2NXksGRHpueO8c4TfAp75GEdAtAr1ngTFOsdpg,2257
 GameSentenceMiner/ocr/ocrconfig.py,sha256=_tY8mjnzHMJrLS8E5pHqYXZjMuLoGKYgJwdhYgN-ny4,6466
 GameSentenceMiner/ocr/owocr_area_selector.py,sha256=71trzwz9Isyy-kN9mLS8vIX-giC8Lkin4slLXaxudac,47162
-GameSentenceMiner/ocr/owocr_helper.py,sha256=FQXk5PSCS9gWtcgoIFsPxjVELUwA4Dg1hEX83902K0Q,18114
+GameSentenceMiner/ocr/owocr_helper.py,sha256=upbuBWKGj6VIg0P5lTopZ8kPPu_ErpdIduM21kpvGmI,18310
 GameSentenceMiner/owocr/owocr/__init__.py,sha256=opjBOyGGyEqZCE6YdZPnyt7nVfiwyELHsXA0jAsjm14,25
 GameSentenceMiner/owocr/owocr/__main__.py,sha256=XQaqZY99EKoCpU-gWQjNbTs7Kg17HvBVE7JY8LqIE0o,157
 GameSentenceMiner/owocr/owocr/config.py,sha256=qM7kISHdUhuygGXOxmgU6Ef2nwBShrZtdqu4InDCViE,8103
 GameSentenceMiner/owocr/owocr/lens_betterproto.py,sha256=oNoISsPilVVRBBPVDtb4-roJtAhp8ZAuFTci3TGXtMc,39141
-GameSentenceMiner/owocr/owocr/ocr.py,sha256=y8RHHaJw8M4BG4CbbtIw0DrV8KP9RjbJNJxjM5v91oU,42236
-GameSentenceMiner/owocr/owocr/run.py,sha256=jFN7gYYriHgfqORJiBTz8mPkQsDJ6ZugA0_ATWUxk-U,54750
+GameSentenceMiner/owocr/owocr/ocr.py,sha256=vZR3du1fGg5-3cmPvYKTO4PFk7Lxyf6-BrIy7CmeG0I,42578
+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=VCIDRjulbWu-xgU2B_k2i8POVrP-Lw5dN3ghatDcxGs,25901
-GameSentenceMiner/util/electron_config.py,sha256=ZZf54QifdNHbII-JDsMZmdT8nTyrq-7gVvalyLRecfw,9792
-GameSentenceMiner/util/ffmpeg.py,sha256=qaCXkfK2fd-1NRqbm7burrdBYgnGx07kBuyenee8Mtk,18697
-GameSentenceMiner/util/gsm_utils.py,sha256=RoOTvWCVpmfYA7fLDdIPcgH1c6TZK4jDZq98BectPhg,8272
+GameSentenceMiner/util/configuration.py,sha256=mUhdjtuWJGWzgtcuM3b4zpqlM4m0f8Vl431AjfZfnaw,26070
+GameSentenceMiner/util/electron_config.py,sha256=3VmIrcXhC-wIMMc4uqV85NrNenRl4ZUbnQfSjWEwuig,9852
+GameSentenceMiner/util/ffmpeg.py,sha256=daItJprEqi5PQe-aFb836rls3tBHNqIQKz61vlJK07M,19276
+GameSentenceMiner/util/gsm_utils.py,sha256=TLKA4CFAdboE8jOoN0MB0aKS1U5mXcINhOkKbnJqw_g,8802
 GameSentenceMiner/util/model.py,sha256=iDtLTfR6D-ZC0gCiDqYno6-gA6Z07PZTM4B5MAA6xZI,5704
-GameSentenceMiner/util/notification.py,sha256=euTnnNDJm0izr0Z5AhZGV2wrrioCASeKUtm5aZFO5zU,3462
+GameSentenceMiner/util/notification.py,sha256=hAUKWWDB4F_9exQhgiajfP5DT8u464RowsJGmBVRN_E,3882
 GameSentenceMiner/util/package.py,sha256=u1ym5z869lw5EHvIviC9h9uH97bzUXSXXA8KIn8rUvk,1157
 GameSentenceMiner/util/ss_selector.py,sha256=oCzmDbpEGvVselF-oDPIrBcQktGIZT0Zt16uDLDAHMQ,4493
-GameSentenceMiner/util/text_log.py,sha256=JQS0JpcdaTvcdKgfKs3lWskG4dk6NPjqjMJpm2--37I,5310
+GameSentenceMiner/util/text_log.py,sha256=wdFOapIwHzDntR9G0YzJzDcbhO6b1taFkhdgsTnRGJ4,5356
 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
@@ -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.9.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-gamesentenceminer-2.9.9.dist-info/METADATA,sha256=nThHRsiJF7JUpr6q0Y51JndWC6p1zLGwGnxkLtLRhvM,7250
-gamesentenceminer-2.9.9.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-gamesentenceminer-2.9.9.dist-info/entry_points.txt,sha256=2APEP25DbfjSxGeHtwBstMH8mulVhLkqF_b9bqzU6vQ,65
-gamesentenceminer-2.9.9.dist-info/top_level.txt,sha256=V1hUY6xVSyUEohb0uDoN4UIE6rUZ_JYx8yMyPGX4PgQ,18
-gamesentenceminer-2.9.9.dist-info/RECORD,,
+gamesentenceminer-2.9.11.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+gamesentenceminer-2.9.11.dist-info/METADATA,sha256=PIPovVreLcPokhDBGRaLjZBTxCbQBqk0lxMNjlx9YmU,7221
+gamesentenceminer-2.9.11.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+gamesentenceminer-2.9.11.dist-info/entry_points.txt,sha256=2APEP25DbfjSxGeHtwBstMH8mulVhLkqF_b9bqzU6vQ,65
+gamesentenceminer-2.9.11.dist-info/top_level.txt,sha256=V1hUY6xVSyUEohb0uDoN4UIE6rUZ_JYx8yMyPGX4PgQ,18
+gamesentenceminer-2.9.11.dist-info/RECORD,,