GameSentenceMiner 2.9.18__py3-none-any.whl → 2.9.20__py3-none-any.whl

GameSentenceMiner/gametext.py

@@ -5,11 +5,9 @@ import pyperclip
 import websockets
 from websockets import InvalidStatus
 
-from GameSentenceMiner import util
 from GameSentenceMiner.util.gsm_utils import do_text_replacements, TEXT_REPLACEMENTS_FILE, run_new_thread
 from GameSentenceMiner.util.configuration import *
 from GameSentenceMiner.util.text_log import *
-
 from GameSentenceMiner.web.texthooking_page import add_event_to_texthooker
 
 current_line = ''
@@ -65,7 +63,6 @@ async def listen_websockets():
                         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
                     websocket_connected[uri] = True
-                    try_other = True
                     line_time = None
                     while True:
                         message = await websocket.recv()

GameSentenceMiner/gsm.py

@@ -4,10 +4,10 @@ import sys
 
 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.gsm_utils import wait_for_stable_file, make_unique_file_name, run_new_thread
 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
@@ -40,6 +40,7 @@ try:
     from GameSentenceMiner.util.text_log import GameLine, get_text_event, get_mined_line, get_all_lines, game_log
     from GameSentenceMiner.util import *
     from GameSentenceMiner.web import texthooking_page
+    from GameSentenceMiner.web.service import handle_texthooker_button
     from GameSentenceMiner.web.texthooking_page import run_text_hooker_page
 except Exception as e:
     from GameSentenceMiner.util.configuration import logger, is_linux, is_windows
@@ -77,13 +78,9 @@ 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
-        else:
-            gsm_state.previous_replay = video_path
+        gsm_state.previous_replay = video_path
         if gsm_state.line_for_audio or gsm_state.line_for_screenshot:
-            self.handle_texthooker_button(video_path)
+            handle_texthooker_button(video_path, get_audio_from_video=VideoToAudioHandler.get_audio)
             return
         try:
             if anki.card_queue and len(anki.card_queue) > 0:
@@ -180,66 +177,11 @@ class VideoToAudioHandler(FileSystemEventHandler):
                 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:
-            if gsm_state.line_for_audio:
-                line: GameLine = gsm_state.line_for_audio
-                gsm_state.line_for_audio = None
-                if line == gsm_state.previous_line_for_audio:
-                    logger.info("Line is the same as the last one, skipping processing.")
-                    if get_config().advanced.audio_player_path:
-                        play_audio_in_external(gsm_state.previous_audio)
-                    elif get_config().advanced.video_player_path:
-                        play_video_in_external(line, gsm_state.previous_audio)
-                    return
-                gsm_state.previous_line_for_audio = line
-                if get_config().advanced.audio_player_path:
-                    audio = VideoToAudioHandler.get_audio(line, line.next.time if line.next else None, video_path,
-                                                          temporary=True)
-                    play_audio_in_external(audio)
-                    gsm_state.previous_audio = audio
-                elif get_config().advanced.video_player_path:
-                    new_video_path = play_video_in_external(line, video_path)
-                    gsm_state.previous_audio = new_video_path
-                    gsm_state.previous_replay = new_video_path
-                return
-            if gsm_state.line_for_screenshot:
-                line: GameLine = gsm_state.line_for_screenshot
-                gsm_state.line_for_screenshot = None
-                gsm_state.previous_line_for_screenshot = line
-                screenshot = ffmpeg.get_screenshot_for_line(video_path, line, True)
-                if gsm_state.anki_note_for_screenshot:
-                    gsm_state.anki_note_for_screenshot = None
-                    encoded_image = ffmpeg.process_image(screenshot)
-                    if get_config().anki.update_anki and get_config().screenshot.screenshot_hotkey_updates_anki:
-                        last_note = anki.get_last_anki_card()
-                        if get_config().features.backfill_audio:
-                            last_note = anki.get_cards_by_sentence(gametext.current_line)
-                        if last_note:
-                            anki.add_image_to_card(last_note, encoded_image)
-                            notification.send_screenshot_updated(last_note.get_field(get_config().anki.word_field))
-                            if get_config().features.open_anki_edit:
-                                notification.open_anki_card(last_note.noteId)
-                        else:
-                            notification.send_screenshot_saved(encoded_image)
-                    else:
-                        notification.send_screenshot_saved(encoded_image)
-                else:
-                    os.startfile(screenshot)
-                return
-        except Exception as e:
-            logger.error(f"Error Playing Audio/Video: {e}")
-            logger.debug(f"Error Playing Audio/Video: {e}", exc_info=True)
-            return
-        finally:
-            if video_path and get_config().paths.remove_video and os.path.exists(video_path):
-                os.remove(video_path)
-
     @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(video_path, game_line, next_line_time, anki_card_creation_time)
         if temporary:
-            return trimmed_audio
+            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,
@@ -256,62 +198,6 @@ class VideoToAudioHandler(FileSystemEventHandler):
         return final_audio_output, vad_result, vad_trimmed_audio
 
 
-def play_audio_in_external(filepath):
-    exe = get_config().advanced.audio_player_path
-
-    filepath = os.path.normpath(filepath)
-
-    command = [exe, "--no-video", filepath]
-
-    try:
-        subprocess.Popen(command)
-        print(f"Opened {filepath} in {exe}.")
-    except Exception as e:
-        print(f"An error occurred: {e}")
-
-def play_video_in_external(line, filepath):
-    def move_video_when_closed(p, fp):
-        p.wait()
-        os.remove(fp)
-
-    shutil.move(filepath, get_temporary_directory())
-    new_filepath = os.path.join(get_temporary_directory(), os.path.basename(filepath))
-
-    command = [get_config().advanced.video_player_path]
-
-    start, _, _, _ = get_video_timings(new_filepath, line)
-
-    if start:
-        if "vlc" in get_config().advanced.video_player_path:
-            command.extend(["--start-time", convert_to_vlc_seconds(start), '--one-instance'])
-        else:
-            command.extend(["--start", convert_to_vlc_seconds(start)])
-    command.append(os.path.normpath(new_filepath))
-
-    logger.info(" ".join(command))
-
-
-
-    try:
-        proc = subprocess.Popen(command)
-        print(f"Opened {filepath} in {get_config().advanced.video_player_path}.")
-        threading.Thread(target=move_video_when_closed, args=(proc, filepath)).start()
-    except FileNotFoundError:
-        print("VLC not found. Make sure it's installed and in your PATH.")
-    except Exception as e:
-        print(f"An error occurred: {e}")
-    return new_filepath
-
-def convert_to_vlc_seconds(time_str):
-    """Converts HH:MM:SS.milliseconds to VLC-compatible seconds."""
-    try:
-        hours, minutes, seconds_ms = time_str.split(":")
-        seconds, milliseconds = seconds_ms.split(".")
-        total_seconds = (int(hours) * 3600) + (int(minutes) * 60) + int(seconds) + (int(milliseconds) / 1000.0)
-        return str(total_seconds)
-    except ValueError:
-        return "Invalid time format"
-
 def initial_checks():
     try:
         subprocess.run(ffmpeg.ffmpeg_base_command_list)

GameSentenceMiner/ocr/owocr_helper.py

@@ -15,6 +15,8 @@ import websockets
 from rapidfuzz import fuzz
 
 from GameSentenceMiner import obs
+from GameSentenceMiner.ocr.ss_picker import ScreenCropper
+from GameSentenceMiner.owocr.owocr.run import TextFiltering
 from GameSentenceMiner.util.configuration import get_config, get_app_directory, get_temporary_directory
 from GameSentenceMiner.util.electron_config import get_ocr_scan_rate, get_requires_open_window
 from GameSentenceMiner.ocr.gsm_ocr_config import OCRConfig, set_dpi_awareness
@@ -71,7 +73,7 @@ def get_new_game_cords():
     return coords_list
 
 
-def get_ocr_config() -> OCRConfig:
+def get_ocr_config(window=None) -> OCRConfig:
     """Loads and updates screen capture areas from the corresponding JSON file."""
     app_dir = Path.home() / "AppData" / "Roaming" / "GameSentenceMiner"
     ocr_config_dir = app_dir / "ocr_config"
@@ -80,8 +82,10 @@ def get_ocr_config() -> OCRConfig:
     scene = sanitize_filename(obs.get_current_scene())
     config_path = ocr_config_dir / f"{scene}.json"
     if not config_path.exists():
-        config_path.touch()
-        return
+        ocr_config = OCRConfig(scene=scene, window=window, rectangles=[], coordinate_system="")
+        with open(config_path, 'w', encoding="utf-8") as f:
+            json.dump(ocr_config.to_dict(), f, indent=4)
+        return ocr_config
     try:
         with open(config_path, 'r', encoding="utf-8") as f:
             config_data = json.load(f)
@@ -204,13 +208,11 @@ all_cords = None
 rectangles = None
 last_ocr2_result = ""
 
-def do_second_ocr(ocr1_text, time, img, filtering, scrolling=False):
+def do_second_ocr(ocr1_text, time, img, filtering):
     global twopassocr, ocr2, last_ocr2_result
     try:
         orig_text, text = run.process_and_write_results(img, None, last_ocr2_result, filtering, None,
                                                         engine=ocr2)
-        if scrolling:
-            return text
         if fuzz.ratio(last_ocr2_result, text) >= 90:
             logger.info("Seems like the same text from previous ocr2 result, not sending")
             return
@@ -239,11 +241,10 @@ async def send_result(text, time):
         if get_config().advanced.ocr_sends_to_clipboard or ssonly:
             import pyperclip
             pyperclip.copy(text)
-        if not ssonly:
-            try:
-                await websocket_server_thread.send_text(text, time)
-            except Exception as e:
-                logger.debug(f"Error sending text to websocket: {e}")
+        try:
+            await websocket_server_thread.send_text(text, time)
+        except Exception as e:
+            logger.debug(f"Error sending text to websocket: {e}")
 
 
 previous_text_list = []
@@ -255,10 +256,9 @@ previous_img = None
 previous_orig_text = ""  # Store original text result
 TEXT_APPEARENCE_DELAY = get_ocr_scan_rate() * 1000 + 500  # Adjust as needed
 force_stable = False
-scrolling_text_images = []
 
 def text_callback(text, orig_text, time, img=None, came_from_ss=False, filtering=None, crop_coords=None):
-    global twopassocr, ocr2, previous_text, last_oneocr_time, text_stable_start_time, previous_orig_text, previous_img, force_stable, previous_ocr1_result, scrolling_text_images, previous_text_list
+    global twopassocr, ocr2, previous_text, last_oneocr_time, text_stable_start_time, previous_orig_text, previous_img, force_stable, previous_ocr1_result, previous_text_list
     orig_text_string = ''.join([item for item in orig_text if item is not None]) if orig_text else ""
     if came_from_ss:
         save_result_image(img)
@@ -341,8 +341,8 @@ def run_oneocr(ocr_config: OCRConfig, rectangles):
         exclusions = list(rect.coordinates for rect in list(filter(lambda x: x.is_excluded, rectangles)))
 
     run.init_config(False)
-    run.run(read_from="screencapture" if not ssonly else "clipboard",
-            read_from_secondary="clipboard" if not ssonly else None,
+    run.run(read_from="screencapture" if not ssonly else "clipboard" if ss_clipboard else "",
+            read_from_secondary="clipboard" if ss_clipboard and not ssonly else None,
             write_to="callback",
             screen_capture_area=screen_area,
             # screen_capture_monitor=monitor_config['index'],
@@ -360,6 +360,20 @@ def run_oneocr(ocr_config: OCRConfig, rectangles):
     done = True
 
 
+
+def add_ss_hotkey():
+    import keyboard
+    cropper = ScreenCropper()
+    filtering = TextFiltering()
+    def capture():
+        print("Taking screenshot...")
+        img = cropper.run()
+        do_second_ocr("", datetime.now(), img, filtering)
+
+    keyboard.add_hotkey('ctrl+shift+g', capture)
+    print("Press Ctrl+Shift+G to take a screenshot.")
+
+
 def get_window(window_name):
     import pygetwindow as gw
     try:
@@ -388,50 +402,48 @@ def set_force_stable_hotkey():
     print("Press Ctrl+Shift+F to toggle force stable mode.")
 
 if __name__ == "__main__":
-    global ocr1, ocr2, twopassocr, language, ssonly
+    global ocr1, ocr2, twopassocr, language, ss_clipboard, ss, ocr_config
     import sys
 
-    args = sys.argv[1:]
-    if len(args) >= 4:
-        language = args[0]
-        ocr1 = args[1]
-        ocr2 = args[2]
-        twopassocr = bool(int(args[3]))
-    elif len(args) == 3:
-        language = args[0]
-        ocr1 = args[1]
-        ocr2 = args[2]
-        twopassocr = True
-    elif len(args) == 2:
-        language = args[0]
-        ocr1 = args[1]
-        ocr2 = None
-        twopassocr = False
-    else:
-        language = "ja"
-        ocr1 = "oneocr"
-        ocr2 = "glens"
-        twopassocr = True
-
-    ssonly = "--ssonly" in args
+    import argparse
+
+    parser = argparse.ArgumentParser(description="OCR Configuration")
+    parser.add_argument("--language", type=str, default="ja", help="Language for OCR (default: ja)")
+    parser.add_argument("--ocr1", type=str, default="oneocr", help="Primary OCR engine (default: oneocr)")
+    parser.add_argument("--ocr2", type=str, default="glens", help="Secondary OCR engine (default: glens)")
+    parser.add_argument("--twopassocr", type=int, choices=[0, 1], default=1, help="Enable two-pass OCR (default: 1)")
+    parser.add_argument("--ssonly", action="store_true", help="Use screenshot-only mode")
+    parser.add_argument("--clipboard", action="store_true", help="Use clipboard for input")
+    parser.add_argument("--window", type=str, help="Specify the window name for OCR")
+
+    args = parser.parse_args()
+
+    language = args.language
+    ocr1 = args.ocr1
+    ocr2 = args.ocr2 if args.ocr2 else None
+    twopassocr = bool(args.twopassocr)
+    ssonly = args.ssonly
+    ss_clipboard = args.clipboard
+    window_name = args.window
     logger.info(f"Received arguments: ocr1={ocr1}, ocr2={ocr2}, twopassocr={twopassocr}")
     # set_force_stable_hotkey()
-    global ocr_config
-    ocr_config: OCRConfig = get_ocr_config()
     set_dpi_awareness()
-    if ocr_config:
-        if ocr_config.window:
-            start_time = time.time()
-            while time.time() - start_time < 30:
-                if get_window(ocr_config.window):
-                    break
-                logger.info(f"Window: {ocr_config.window} Could not be found, retrying in 1 second...")
-                time.sleep(1)
-            else:
-                logger.error(f"Window '{ocr_config.window}' not found within 30 seconds.")
-                sys.exit(1)
-        logger.info(f"Starting OCR with configuration: Window: {ocr_config.window}, Rectangles: {ocr_config.rectangles}, Engine 1: {ocr1}, Engine 2: {ocr2}, Two-pass OCR: {twopassocr}")
-    if ocr_config or ssonly:
+    ocr_config = None
+    if not ssonly:
+        ocr_config: OCRConfig = get_ocr_config(window=window_name)
+        if ocr_config:
+            if ocr_config.window:
+                start_time = time.time()
+                while time.time() - start_time < 30:
+                    if get_window(ocr_config.window):
+                        break
+                    logger.info(f"Window: {ocr_config.window} Could not be found, retrying in 1 second...")
+                    time.sleep(1)
+                else:
+                    logger.error(f"Window '{ocr_config.window}' not found within 30 seconds.")
+                    sys.exit(1)
+            logger.info(f"Starting OCR with configuration: Window: {ocr_config.window}, Rectangles: {ocr_config.rectangles}, Engine 1: {ocr1}, Engine 2: {ocr2}, Two-pass OCR: {twopassocr}")
+    if ssonly or ocr_config:
         rectangles = ocr_config.rectangles if ocr_config and ocr_config.rectangles else []
         oneocr_threads = []
         ocr_thread = threading.Thread(target=run_oneocr, args=(ocr_config,rectangles ), daemon=True)
@@ -439,8 +451,9 @@ if __name__ == "__main__":
         if not ssonly:
             worker_thread = threading.Thread(target=process_task_queue, daemon=True)
             worker_thread.start()
-            websocket_server_thread = WebsocketServerThread(read=True)
-            websocket_server_thread.start()
+        websocket_server_thread = WebsocketServerThread(read=True)
+        websocket_server_thread.start()
+        add_ss_hotkey()
         try:
             while not done:
                 time.sleep(1)

GameSentenceMiner/ocr/ss_picker.py

@@ -0,0 +1,132 @@
+import tkinter as tk
+from tkinter import Canvas
+from PIL import Image, ImageTk
+import mss
+import mss.tools
+import io
+import sys
+import ctypes
+
+if sys.platform == "win32":
+    try:
+        ctypes.windll.shcore.SetProcessDpiAwareness(1)
+    except AttributeError:
+        ctypes.windll.user32.SetProcessDPIAware()
+
+class ScreenCropper:
+    def __init__(self):
+        self.root = None
+        self.canvas = None
+        self.captured_image = None
+        self.tk_image = None
+        self.start_x = None
+        self.start_y = None
+        self.end_x = None
+        self.end_y = None
+        self.rect_id = None
+        self.cropped_image = None
+        self.monitor_geometry = None
+
+    def grab_all_monitors(self):
+        try:
+            with mss.mss() as sct:
+                all_monitors_bbox = sct.monitors[0]
+                self.monitor_geometry = {
+                    'left': all_monitors_bbox['left'],
+                    'top': all_monitors_bbox['top'],
+                    'width': all_monitors_bbox['width'],
+                    'height': all_monitors_bbox['height']
+                }
+                sct_grab = sct.grab(all_monitors_bbox)
+
+                img_bytes = mss.tools.to_png(sct_grab.rgb, sct_grab.size)
+                self.captured_image = Image.open(io.BytesIO(img_bytes))
+
+            print("All monitors captured successfully.")
+        except Exception as e:
+            print(f"An error occurred during screen capture: {e}")
+            self.captured_image = None
+            self.monitor_geometry = None
+
+    def _on_button_press(self, event):
+        self.start_x = self.end_x = event.x
+        self.start_y = self.end_y = event.y
+
+        if self.rect_id:
+            self.canvas.delete(self.rect_id)
+        self.rect_id = self.canvas.create_rectangle(self.start_x, self.start_y,
+                                                    self.end_x, self.end_y,
+                                                    outline="red", width=2)
+
+    def _on_mouse_drag(self, event):
+        self.end_x = event.x
+        self.end_y = event.y
+        self.canvas.coords(self.rect_id, self.start_x, self.start_y,
+                           self.end_x, self.end_y)
+
+    def _on_button_release(self, event):
+        self.end_x = event.x
+        self.end_y = event.y
+
+        x1 = min(self.start_x, self.end_x)
+        y1 = min(self.start_y, self.end_y)
+        x2 = max(self.start_x, self.end_x)
+        y2 = max(self.start_y, self.end_y)
+
+        if (x2 - x1) > 0 and (y2 - y1) > 0:
+            self.cropped_image = self.captured_image.crop((x1, y1, x2, y2))
+            print(f"Selection made: ({x1}, {y1}) to ({x2}, {y2})")
+        else:
+            print("No valid selection made (area was too small).")
+            self.cropped_image = None
+
+        self.root.destroy()
+
+    def show_image_and_select_box(self):
+        if self.captured_image is None or self.monitor_geometry is None:
+            print("No image or monitor geometry to display. Capture all monitors first.")
+            return
+
+        self.root = tk.Tk()
+        self.root.attributes('-topmost', True)
+        self.root.overrideredirect(True)
+
+        window_width = self.monitor_geometry['width']
+        window_height = self.monitor_geometry['height']
+        window_x = self.monitor_geometry['left']
+        window_y = self.monitor_geometry['top']
+
+        self.root.geometry(f"{window_width}x{window_height}+{window_x}+{window_y}")
+
+        self.tk_image = ImageTk.PhotoImage(self.captured_image)
+
+        self.canvas = Canvas(self.root, cursor="cross", highlightthickness=0)
+        self.canvas.pack(fill=tk.BOTH, expand=True)
+
+        self.canvas.create_image(0, 0, anchor="nw", image=self.tk_image)
+
+        self.canvas.bind("<Button-1>", self._on_button_press)
+        self.canvas.bind("<B1-Motion>", self._on_mouse_drag)
+        self.canvas.bind("<ButtonRelease-1>", self._on_button_release)
+
+        self.root.mainloop()
+
+    def get_cropped_image(self):
+        return self.cropped_image
+
+    def run(self):
+        self.grab_all_monitors()
+        if self.captured_image and self.monitor_geometry:
+            self.show_image_and_select_box()
+            return self.get_cropped_image()
+        return None
+
+if __name__ == "__main__":
+    cropper = ScreenCropper()
+    cropped_img = cropper.run()
+
+    if cropped_img:
+        print("Image cropped successfully. Displaying cropped image...")
+        cropped_img.show()
+    else:
+        print("No image was cropped.")

GameSentenceMiner/util/ffmpeg.py

@@ -500,6 +500,32 @@ def convert_audio_to_wav(input_audio, output_wav):
     logger.debug(" ".join(command))
     subprocess.run(command)
 
+def convert_audio_to_wav_lossless(input_audio):
+    output_wav = make_unique_file_name(
+        os.path.join(configuration.get_temporary_directory(), "output.wav")
+    )
+    command = ffmpeg_base_command_list + [
+        "-i", input_audio,
+        output_wav
+    ]
+    logger.debug(" ".join(command))
+    subprocess.run(command)
+    return output_wav
+
+def convert_audio_to_mp3(input_audio):
+    output_mp3 = make_unique_file_name(
+        os.path.join(configuration.get_temporary_directory(), "output.mp3")
+    )
+    command = ffmpeg_base_command_list + [
+        "-i", input_audio,
+        "-codec:a", "libmp3lame",
+        "-qscale:a", "2",  # Quality scale for MP3
+        output_mp3
+    ]
+    logger.debug(" ".join(command))
+    subprocess.run(command)
+    return output_mp3
+
 
 # Trim the audio using FFmpeg based on detected speech timestamps
 def trim_audio(input_audio, start_time, end_time, output_audio):

GameSentenceMiner/web/service.py

@@ -0,0 +1,135 @@
+import os
+import shutil
+import subprocess
+import threading
+
+import simpleaudio as sa
+
+from GameSentenceMiner import anki
+from GameSentenceMiner.util import ffmpeg, notification
+from GameSentenceMiner.util.configuration import gsm_state, logger, get_config, get_temporary_directory
+from GameSentenceMiner.util.ffmpeg import get_video_timings
+from GameSentenceMiner.util.text_log import GameLine
+
+
+def handle_texthooker_button(video_path='', get_audio_from_video=None):
+    try:
+        if gsm_state.line_for_audio:
+            line: GameLine = gsm_state.line_for_audio
+            gsm_state.line_for_audio = None
+            if line == gsm_state.previous_line_for_audio:
+                logger.info("Line is the same as the last one, skipping processing.")
+                if get_config().advanced.audio_player_path:
+                    play_audio_in_external(gsm_state.previous_audio)
+                elif get_config().advanced.video_player_path:
+                    play_video_in_external(line, gsm_state.previous_audio)
+                else:
+                    play_obj = gsm_state.previous_audio.play()
+                    play_obj.wait_done()
+                return
+            gsm_state.previous_line_for_audio = line
+            if get_config().advanced.audio_player_path:
+                audio = get_audio_from_video(line, line.next.time if line.next else None, video_path,
+                                             temporary=True)
+                play_audio_in_external(audio)
+                gsm_state.previous_audio = audio
+            elif get_config().advanced.video_player_path:
+                new_video_path = play_video_in_external(line, video_path)
+                gsm_state.previous_audio = new_video_path
+                gsm_state.previous_replay = new_video_path
+            else:
+                audio = get_audio_from_video(line, line.next.time if line.next else None, video_path,
+                                             temporary=True)
+                wave_obj = sa.WaveObject.from_wave_file(audio)
+                play_obj = wave_obj.play()
+                play_obj.wait_done()
+                gsm_state.previous_audio = wave_obj
+            return
+        if gsm_state.line_for_screenshot:
+            line: GameLine = gsm_state.line_for_screenshot
+            gsm_state.line_for_screenshot = None
+            gsm_state.previous_line_for_screenshot = line
+            screenshot = ffmpeg.get_screenshot_for_line(video_path, line, True)
+            if gsm_state.anki_note_for_screenshot:
+                gsm_state.anki_note_for_screenshot = None
+                encoded_image = ffmpeg.process_image(screenshot)
+                if get_config().anki.update_anki and get_config().screenshot.screenshot_hotkey_updates_anki:
+                    last_note = anki.get_last_anki_card()
+                    if last_note:
+                        anki.add_image_to_card(last_note, encoded_image)
+                        notification.send_screenshot_updated(last_note.get_field(get_config().anki.word_field))
+                        if get_config().features.open_anki_edit:
+                            notification.open_anki_card(last_note.noteId)
+                    else:
+                        notification.send_screenshot_saved(encoded_image)
+                else:
+                    notification.send_screenshot_saved(encoded_image)
+            else:
+                os.startfile(screenshot)
+            return
+    except Exception as e:
+        logger.error(f"Error Playing Audio/Video: {e}")
+        logger.debug(f"Error Playing Audio/Video: {e}", exc_info=True)
+        return
+    finally:
+        if video_path and get_config().paths.remove_video and os.path.exists(video_path):
+            os.remove(video_path)
+
+
+def play_audio_in_external(filepath):
+    exe = get_config().advanced.audio_player_path
+
+    filepath = os.path.normpath(filepath)
+
+    command = [exe, "--no-video", filepath]
+
+    try:
+        subprocess.Popen(command)
+        print(f"Opened {filepath} in {exe}.")
+    except Exception as e:
+        print(f"An error occurred: {e}")
+
+
+def play_video_in_external(line, filepath):
+    def move_video_when_closed(p, fp):
+        p.wait()
+        os.remove(fp)
+
+    shutil.move(filepath, get_temporary_directory())
+    new_filepath = os.path.join(get_temporary_directory(), os.path.basename(filepath))
+
+    command = [get_config().advanced.video_player_path]
+
+    start, _, _, _ = get_video_timings(new_filepath, line)
+
+    if start:
+        if "vlc" in get_config().advanced.video_player_path:
+            command.extend(["--start-time", convert_to_vlc_seconds(start), '--one-instance'])
+        else:
+            command.extend(["--start", convert_to_vlc_seconds(start)])
+    command.append(os.path.normpath(new_filepath))
+
+    logger.info(" ".join(command))
+
+
+
+    try:
+        proc = subprocess.Popen(command)
+        print(f"Opened {filepath} in {get_config().advanced.video_player_path}.")
+        threading.Thread(target=move_video_when_closed, args=(proc, filepath)).start()
+    except FileNotFoundError:
+        print("VLC not found. Make sure it's installed and in your PATH.")
+    except Exception as e:
+        print(f"An error occurred: {e}")
+    return new_filepath
+
+
+def convert_to_vlc_seconds(time_str):
+    """Converts HH:MM:SS.milliseconds to VLC-compatible seconds."""
+    try:
+        hours, minutes, seconds_ms = time_str.split(":")
+        seconds, milliseconds = seconds_ms.split(".")
+        total_seconds = (int(hours) * 3600) + (int(minutes) * 60) + int(seconds) + (int(milliseconds) / 1000.0)
+        return str(total_seconds)
+    except ValueError:
+        return "Invalid time format"

GameSentenceMiner/web/texthooking_page.py

@@ -16,6 +16,7 @@ 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, gsm_status
+from GameSentenceMiner.web.service import handle_texthooker_button
 
 port = get_config().general.texthooker_port
 url = f"http://localhost:{port}"
@@ -252,6 +253,7 @@ async def add_event_to_texthooker(line: GameLine):
         'sentence': line.text,
         'data': new_event.to_serializable()
     })
+    await plaintext_websocket_server_thread.send_text(line.text)
 
 
 @app.route('/update_checkbox', methods=['POST'])
@@ -274,7 +276,7 @@ def get_screenshot():
         return jsonify({'error': 'Missing id'}), 400
     gsm_state.line_for_screenshot = get_line_by_id(event_id)
     if gsm_state.previous_line_for_screenshot and gsm_state.line_for_screenshot.id == gsm_state.previous_line_for_screenshot.id:
-        open(os.path.join(get_config().paths.folder_to_watch, "previous.mkv"), 'a').close()
+        handle_texthooker_button()
     else:
         obs.save_replay_buffer()
     return jsonify({}), 200
@@ -288,7 +290,7 @@ def play_audio():
         return jsonify({'error': 'Missing id'}), 400
     gsm_state.line_for_audio = get_line_by_id(event_id)
     if gsm_state.previous_line_for_audio and gsm_state.line_for_audio == gsm_state.previous_line_for_audio:
-        open(os.path.join(get_config().paths.folder_to_watch, "previous.mkv"), 'a').close()
+        handle_texthooker_button()
     else:
         obs.save_replay_buffer()
     return jsonify({}), 200
@@ -362,12 +364,13 @@ paused = False
 
 
 class WebsocketServerThread(threading.Thread):
-    def __init__(self, read):
+    def __init__(self, read, ws_port):
         super().__init__(daemon=True)
         self._loop = None
         self.read = read
         self.clients = set()
         self._event = threading.Event()
+        self.ws_port = ws_port
 
     @property
     def loop(self):
@@ -400,8 +403,10 @@ class WebsocketServerThread(threading.Thread):
 
     async def send_text(self, text):
         if text:
+            if isinstance(text, dict):
+                text = json.dumps(text)
             return asyncio.run_coroutine_threadsafe(
-                self.send_text_coroutine(json.dumps(text)), self.loop)
+                self.send_text_coroutine(text), self.loop)
 
     def stop_server(self):
         self.loop.call_soon_threadsafe(self._stop_event.set)
@@ -415,7 +420,7 @@ class WebsocketServerThread(threading.Thread):
                 try:
                     self.server = start_server = websockets.serve(self.server_handler,
                                                                   "0.0.0.0",
-                                                                  get_config().advanced.texthooker_communication_websocket_port,
+                                                                  self.ws_port,
                                                                   max_size=1000000000)
                     async with start_server:
                         await stop_event.wait()
@@ -432,15 +437,18 @@ def handle_exit_signal(loop):
         task.cancel()
 
 async def texthooker_page_coro():
-    global websocket_server_thread
+    global websocket_server_thread, plaintext_websocket_server_thread
     # Run the WebSocket server in the asyncio event loop
     flask_thread = threading.Thread(target=start_web_server)
     flask_thread.daemon = True
     flask_thread.start()
 
-    websocket_server_thread = WebsocketServerThread(read=True)
+    websocket_server_thread = WebsocketServerThread(read=True, ws_port=get_config().advanced.texthooker_communication_websocket_port)
     websocket_server_thread.start()
 
+    plaintext_websocket_server_thread = WebsocketServerThread(read=False, ws_port=get_config().advanced.texthooker_communication_websocket_port + 1)
+    plaintext_websocket_server_thread.start()
+
     # Keep the main asyncio event loop running (for the WebSocket server)
 
 def run_text_hooker_page():

{gamesentenceminer-2.9.18.dist-info → gamesentenceminer-2.9.20.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: GameSentenceMiner
-Version: 2.9.18
+Version: 2.9.20
 Summary: A tool for mining sentences from games.
 Author-email: Beangate <bpwhelan95@gmail.com>
 License: MIT License
@@ -37,6 +37,7 @@ Requires-Dist: pygetwindow; sys_platform == "win32"
 Requires-Dist: flask
 Requires-Dist: groq
 Requires-Dist: obsws-python~=1.7.2
+Requires-Dist: simpleaudio
 Dynamic: license-file
 
 # GameSentenceMiner (GSM)
@@ -155,4 +156,4 @@ If you encounter issues, please ask for help in my [Discord](https://discord.gg/
 
 ## Donations
 
-If you've found this or any of my other projects helpful, please consider supporting my work through [GitHub Sponsors](https://github.com/sponsors/bpwhelan) or [Ko-fi](https://ko-fi.com/beangate).
+If you've found this or any of my other projects helpful, please consider supporting my work through [GitHub Sponsors](https://github.com/sponsors/bpwhelan), [Ko-fi](https://ko-fi.com/beangate), or [Patreon](https://www.patreon.com/GameSentenceMiner).

{gamesentenceminer-2.9.18.dist-info → gamesentenceminer-2.9.20.dist-info}/RECORD

@@ -1,8 +1,8 @@
 GameSentenceMiner/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 GameSentenceMiner/anki.py,sha256=hNHBIoJRrsWIhLe0sehOYPXTWzPREeXl4gYCPHUCaiE,16331
 GameSentenceMiner/config_gui.py,sha256=iAOLD47sQW67kzBcZKSQ0Dwctc1ngZK1lwSVIaLpQPI,83559
-GameSentenceMiner/gametext.py,sha256=iO1o2980XBzBc2nsgBVr_ZaKHRLotebVpDhwGqBCK9k,6696
-GameSentenceMiner/gsm.py,sha256=MFptrbACty8wP3dCSb8VLSBmoTsiBUvomJgAcIpBZw4,29259
+GameSentenceMiner/gametext.py,sha256=nAwGMQSrmc6sUAw-OAURK2n6MG5Ecm6psJ7YF9q5KTA,6623
+GameSentenceMiner/gsm.py,sha256=b3hOjaPGHn_3_G_0Ro43bX84oLX8SltfKEX_LtujX0U,24127
 GameSentenceMiner/obs.py,sha256=YG8LwBf9BTsGbROm_Uq6LhFDSrbf3jgogp78rBbJq94,14728
 GameSentenceMiner/vad.py,sha256=TbP3NVdjfB1TFJeB0QpOXZysgo_UHHKLdx95pYmM0JI,14902
 GameSentenceMiner/ai/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -19,7 +19,8 @@ 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=upbuBWKGj6VIg0P5lTopZ8kPPu_ErpdIduM21kpvGmI,18310
+GameSentenceMiner/ocr/owocr_helper.py,sha256=7XpuLT8ezdrEXiODyXgh1X7iNbW7OI-QrSgEmTBMaqQ,19505
+GameSentenceMiner/ocr/ss_picker.py,sha256=943tlCJ8536TyAFJFfRt0OGjWwe7QuT-X2UoLl1LyUY,4469
 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
@@ -30,7 +31,7 @@ GameSentenceMiner/owocr/owocr/screen_coordinate_picker.py,sha256=Na6XStbQBtpQUSd
 GameSentenceMiner/util/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 GameSentenceMiner/util/configuration.py,sha256=Wgr1UAf_JoXBlp9h_f3-d2DAmIWnR1FtCmMX6mCfMNM,27461
 GameSentenceMiner/util/electron_config.py,sha256=3VmIrcXhC-wIMMc4uqV85NrNenRl4ZUbnQfSjWEwuig,9852
-GameSentenceMiner/util/ffmpeg.py,sha256=Z3lD5jd7P59-aNWIQDgovwmjT1kCo4-7DLxoG_VBU4M,22618
+GameSentenceMiner/util/ffmpeg.py,sha256=7ZrgnXRa67IH7EYrc93pagkH_2rsO8-QBCDVrMWSg-Y,23398
 GameSentenceMiner/util/gsm_utils.py,sha256=Z_Lu4jSIfUaM2VljIJXQkSJD0UsyJ5hMB46H2NS0gZo,8819
 GameSentenceMiner/util/model.py,sha256=iDtLTfR6D-ZC0gCiDqYno6-gA6Z07PZTM4B5MAA6xZI,5704
 GameSentenceMiner/util/notification.py,sha256=0OnEYjn3DUEZ6c6OtPjdVZe-DG-QSoMAl9fetjjCvNU,3874
@@ -45,7 +46,8 @@ GameSentenceMiner/util/downloader/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeR
 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=d3OiPPgxZ4H5wIh9HrlZutDSiwY3ayvMNrY4c0PdRAE,15158
+GameSentenceMiner/web/service.py,sha256=paRUbmdh6msANHplFX-UAyYWfmYL43ltJJhXeuXXr30,5658
+GameSentenceMiner/web/texthooking_page.py,sha256=v4fh79uAO9jM-ZKoLAlLOBaMTn02GfNGAOuxZUXfs-k,15536
 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 +61,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.18.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-gamesentenceminer-2.9.18.dist-info/METADATA,sha256=wgfdfg6X6daqvG3SlEiFlFgU_TVV8QPBpmBl57eV-_4,7221
-gamesentenceminer-2.9.18.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-gamesentenceminer-2.9.18.dist-info/entry_points.txt,sha256=2APEP25DbfjSxGeHtwBstMH8mulVhLkqF_b9bqzU6vQ,65
-gamesentenceminer-2.9.18.dist-info/top_level.txt,sha256=V1hUY6xVSyUEohb0uDoN4UIE6rUZ_JYx8yMyPGX4PgQ,18
-gamesentenceminer-2.9.18.dist-info/RECORD,,
+gamesentenceminer-2.9.20.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+gamesentenceminer-2.9.20.dist-info/METADATA,sha256=XisQQFOoUzR3uLNWSMvQv8fMWuxDt22kXxNBKXsMDJk,7303
+gamesentenceminer-2.9.20.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+gamesentenceminer-2.9.20.dist-info/entry_points.txt,sha256=2APEP25DbfjSxGeHtwBstMH8mulVhLkqF_b9bqzU6vQ,65
+gamesentenceminer-2.9.20.dist-info/top_level.txt,sha256=V1hUY6xVSyUEohb0uDoN4UIE6rUZ_JYx8yMyPGX4PgQ,18
+gamesentenceminer-2.9.20.dist-info/RECORD,,