GameSentenceMiner 2.9.29__py3-none-any.whl → 2.10.1__py3-none-any.whl

GameSentenceMiner/gametext.py

@@ -14,11 +14,13 @@ current_line = ''
 current_line_after_regex = ''
 current_line_time = datetime.now()
 
+last_clipboard = ''
+
 reconnecting = False
 websocket_connected = {}
 
 async def monitor_clipboard():
-    global current_line
+    global current_line, last_clipboard
     current_line = pyperclip.paste()
     send_message_on_resume = False
     while True:
@@ -37,7 +39,8 @@ async def monitor_clipboard():
         gsm_status.clipboard_enabled = True
         current_clipboard = pyperclip.paste()
 
-        if current_clipboard and current_clipboard != current_line:
+        if current_clipboard and current_clipboard != current_line and current_clipboard != last_clipboard:
+            last_clipboard = current_clipboard
             await handle_new_text_event(current_clipboard)
 
         await asyncio.sleep(0.05)

GameSentenceMiner/gsm.py

@@ -3,7 +3,7 @@ import subprocess
 import sys
 
 import os
-
+import warnings
 
 os.environ.pop('TCL_LIBRARY', None)
 
@@ -60,7 +60,7 @@ obs_paused = False
 icon: Icon
 menu: Menu
 root = None
-
+warnings.simplefilter("ignore", DeprecationWarning)
 
 
 class VideoToAudioHandler(FileSystemEventHandler):
@@ -78,14 +78,20 @@ class VideoToAudioHandler(FileSystemEventHandler):
 
     def process_replay(self, video_path):
         vad_trimmed_audio = ''
+        final_audio_output = ''
         skip_delete = False
+        selected_lines = []
+        anki_card_creation_time = None
+        mined_line = None
         gsm_state.previous_replay = video_path
         if gsm_state.line_for_audio or gsm_state.line_for_screenshot:
             handle_texthooker_button(video_path, get_audio_from_video=VideoToAudioHandler.get_audio)
             return
         try:
             if anki.card_queue and len(anki.card_queue) > 0:
-                last_note, anki_card_creation_time = anki.card_queue.pop(0)
+                last_note, anki_card_creation_time, selected_lines = anki.card_queue.pop(0)
+            elif get_config().features.backfill_audio:
+                last_note = anki.get_cards_by_sentence(gametext.current_line_after_regex)
             else:
                 logger.info("Replay buffer initiated externally. Skipping processing.")
                 skip_delete = True
@@ -102,8 +108,9 @@ class VideoToAudioHandler(FileSystemEventHandler):
                 logger.error(
                     f"Video was unusually small, potentially empty! Check OBS for Correct Scene Settings! Path: {video_path}")
                 return
+
+            # Just for safety
             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:
@@ -115,9 +122,7 @@ class VideoToAudioHandler(FileSystemEventHandler):
                 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()
+            if selected_lines:
                 start_line = selected_lines[0]
                 mined_line = get_mined_line(last_note, selected_lines)
                 line_cutoff = selected_lines[-1].get_next_time()
@@ -126,7 +131,6 @@ class VideoToAudioHandler(FileSystemEventHandler):
                 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")
@@ -138,7 +142,7 @@ class VideoToAudioHandler(FileSystemEventHandler):
                     mined_line=mined_line)
             else:
                 final_audio_output = ""
-                vad_result = VADResult(False, 0, 0, '')
+                vad_result = VADResult(True, 0, 0, '')
                 vad_trimmed_audio = ""
                 if not get_config().audio.enabled:
                     logger.info("Audio is disabled in config, skipping audio processing!")
@@ -167,7 +171,8 @@ class VideoToAudioHandler(FileSystemEventHandler):
             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()
+            if mined_line:
+                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()
@@ -177,6 +182,8 @@ class VideoToAudioHandler(FileSystemEventHandler):
                     os.remove(video_path)
                 if vad_trimmed_audio and get_config().paths.remove_audio and os.path.exists(vad_trimmed_audio):
                     os.remove(vad_trimmed_audio)
+                if final_audio_output and get_config().paths.remove_audio and os.path.exists(final_audio_output):
+                    os.remove(final_audio_output)
 
     @staticmethod
     def get_audio(game_line, next_line_time, video_path, anki_card_creation_time=None, temporary=False, timing_only=False, mined_line=None):
@@ -191,9 +198,9 @@ class VideoToAudioHandler(FileSystemEventHandler):
         vad_result = vad_processor.trim_audio_with_vad(trimmed_audio, vad_trimmed_audio, game_line)
         if timing_only:
             return vad_result
-        if get_config().audio.ffmpeg_reencode_options and os.path.exists(vad_trimmed_audio):
+        if get_config().audio.ffmpeg_reencode_options_to_use and os.path.exists(vad_trimmed_audio):
             ffmpeg.reencode_file_with_user_config(vad_trimmed_audio, final_audio_output,
-                                                  get_config().audio.ffmpeg_reencode_options)
+                                                  get_config().audio.ffmpeg_reencode_options_to_use)
         elif os.path.exists(vad_trimmed_audio):
             shutil.move(vad_trimmed_audio, final_audio_output)
         return final_audio_output, vad_result, vad_trimmed_audio

GameSentenceMiner/ocr/gsm_ocr_config.py

@@ -1,4 +1,5 @@
 import ctypes
+from copy import deepcopy
 from dataclasses import dataclass
 from math import floor, ceil
 
@@ -43,12 +44,14 @@ class WindowGeometry:
 class OCRConfig:
     scene: str
     rectangles: List[Rectangle]
+    pre_scale_rectangles: List[Rectangle] = None
     coordinate_system: str = None
     window_geometry: Optional[WindowGeometry] = None
     window: Optional[str] = None
     language: str = "ja"
 
     def __post_init__(self):
+        self.pre_scale_rectangles = deepcopy(self.rectangles)
         if self.coordinate_system and self.coordinate_system == "percentage" and self.window:
             import pygetwindow as gw
             try:
@@ -71,6 +74,19 @@ class OCRConfig:
                     ceil(rectangle.coordinates[3] * self.window_geometry.height),
                 ]
 
+    def scale_to_custom_size(self, width, height):
+        print(self.pre_scale_rectangles)
+        self.rectangles = self.pre_scale_rectangles.copy()
+        if self.coordinate_system and self.coordinate_system == "percentage":
+            for rectangle in self.rectangles:
+                rectangle.coordinates = [
+                    floor(rectangle.coordinates[0] * width),
+                    floor(rectangle.coordinates[1] * height),
+                    floor(rectangle.coordinates[2] * width),
+                    floor(rectangle.coordinates[3] * height),
+                ]
+
+
 def get_window(title):
     import pygetwindow as gw
     windows = gw.getWindowsWithTitle(title)

GameSentenceMiner/ocr/owocr_area_selector.py

@@ -731,6 +731,8 @@ class ScreenSelector:
         window.bind('<Button-3>', on_right_click)  # Right click delete
         window.bind("<m>", toggle_image_mode)  # Toggle image mode (alpha)
 
+        canvas.focus_set()
+
     def start(self):
         """Initializes the Tkinter root and creates windows for each monitor."""
         self.root = tk.Tk()

GameSentenceMiner/ocr/owocr_helper.py

@@ -1,4 +1,5 @@
 import asyncio
+import io
 import json
 import logging
 import os
@@ -11,7 +12,9 @@ from pathlib import Path
 from tkinter import messagebox
 
 import mss
+import mss.tools
 import websockets
+from PIL import Image
 from rapidfuzz import fuzz
 
 from GameSentenceMiner import obs
@@ -44,35 +47,6 @@ console_handler.setFormatter(formatter)
 logger.addHandler(console_handler)
 
 
-def get_new_game_cords():
-    """Allows multiple coordinate selections."""
-    coords_list = []
-    with mss.mss() as sct:
-        monitors = sct.monitors
-        monitor_map = {i: mon for i, mon in enumerate(monitors)}
-        while True:
-            selected_monitor_index, cords = screen_coordinate_picker.get_screen_selection_with_monitor(monitor_map)
-            selected_monitor = monitor_map[selected_monitor_index]
-            coords_list.append({"monitor": {"left": selected_monitor["left"], "top": selected_monitor["top"],
-                                            "width": selected_monitor["width"], "height": selected_monitor["height"],
-                                            "index": selected_monitor_index}, "coordinates": cords,
-                                "is_excluded": False})
-            if messagebox.askyesno("Add Another Region", "Do you want to add another region?"):
-                continue
-            else:
-                break
-    app_dir = Path.home() / "AppData" / "Roaming" / "GameSentenceMiner"
-    ocr_config_dir = app_dir / "ocr_config"
-    ocr_config_dir.mkdir(parents=True, exist_ok=True)
-    obs.connect_to_obs_sync()
-    scene = sanitize_filename(obs.get_current_scene())
-    config_path = ocr_config_dir / f"{scene}.json"
-    with open(config_path, 'w') as f:
-        json.dump({"scene": scene, "window": None, "rectangles": coords_list}, f, indent=4)
-    print(f"Saved OCR config to {config_path}")
-    return coords_list
-
-
 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"
@@ -213,11 +187,11 @@ def do_second_ocr(ocr1_text, time, img, filtering):
     try:
         orig_text, text = run.process_and_write_results(img, None, last_ocr2_result, filtering, None,
                                                         engine=ocr2, furigana_filter_sensitivity=furigana_filter_sensitivity)
-        if fuzz.ratio(last_ocr2_result, text) >= 90:
+        if fuzz.ratio(last_ocr2_result, orig_text) >= 90:
             logger.info("Seems like the same text from previous ocr2 result, not sending")
             return
         save_result_image(img)
-        last_ocr2_result = text
+        last_ocr2_result = orig_text
         asyncio.run(send_result(text, time))
     except json.JSONDecodeError:
         print("Invalid JSON received.")
@@ -238,7 +212,7 @@ def save_result_image(img):
 async def send_result(text, time):
     if text:
         text = do_text_replacements(text, OCR_REPLACEMENTS_FILE)
-        if get_config().advanced.ocr_sends_to_clipboard or manual:
+        if clipboard_output:
             import pyperclip
             pyperclip.copy(text)
         try:
@@ -365,14 +339,23 @@ def run_oneocr(ocr_config: OCRConfig, rectangles):
 
 def add_ss_hotkey(ss_hotkey="ctrl+shift+g"):
     import keyboard
-    cropper = ScreenCropper()
+    secret_ss_hotkey = "F15"
     filtering = TextFiltering(lang=language)
+    cropper = ScreenCropper()
     def capture():
         print("Taking screenshot...")
         img = cropper.run()
         do_second_ocr("", datetime.now(), img, filtering)
+    def capture_main_monitor():
+        print("Taking screenshot of main monitor...")
+        with mss.mss() as sct:
+            main_monitor = sct.monitors[1] if len(sct.monitors) > 1 else sct.monitors[0]
+            img = sct.grab(main_monitor)
+            img_bytes = mss.tools.to_png(img.rgb, img.size)
+            do_second_ocr("", datetime.now(), img_bytes, filtering)
     try:
         keyboard.add_hotkey(ss_hotkey, capture)
+        keyboard.add_hotkey(secret_ss_hotkey, capture_main_monitor)
         print(f"Press {ss_hotkey} to take a screenshot.")
     except Exception as e:
         logger.error(f"Error setting up screenshot hotkey with keyboard, Attempting Backup: {e}")
@@ -414,6 +397,7 @@ if __name__ == "__main__":
     parser.add_argument("--twopassocr", type=int, choices=[0, 1], default=1, help="Enable two-pass OCR (default: 1)")
     parser.add_argument("--manual", action="store_true", help="Use screenshot-only mode")
     parser.add_argument("--clipboard", action="store_true", help="Use clipboard for input")
+    parser.add_argument("--clipboard-output", action="store_true", default=False, help="Use clipboard for output")
     parser.add_argument("--window", type=str, help="Specify the window name for OCR")
     parser.add_argument("--furigana_filter_sensitivity", type=float, default=0, help="Furigana Filter Sensitivity for OCR (default: 0)")
     parser.add_argument("--manual_ocr_hotkey", type=str, default=None, help="Hotkey for manual OCR (default: None)")
@@ -431,6 +415,7 @@ if __name__ == "__main__":
     furigana_filter_sensitivity = args.furigana_filter_sensitivity
     ss_hotkey = args.area_select_ocr_hotkey.lower()
     manual_ocr_hotkey = args.manual_ocr_hotkey.lower().replace("ctrl", "<ctrl>").replace("shift", "<shift>").replace("alt", "<alt>") if args.manual_ocr_hotkey else None
+    clipboard_output = args.clipboard_output
 
     logger.info(f"Received arguments: {vars(args)}")
     # set_force_stable_hotkey()

GameSentenceMiner/ocr/ss_picker.py

@@ -7,6 +7,7 @@ import io
 
 class ScreenCropper:
     def __init__(self):
+        self.main_monitor = None
         self.root = None
         self.canvas = None
         self.captured_image = None
@@ -23,6 +24,7 @@ class ScreenCropper:
         try:
             with mss.mss() as sct:
                 all_monitors_bbox = sct.monitors[0]
+                self.main_monitor = sct.monitors[1]
                 self.monitor_geometry = {
                     'left': all_monitors_bbox['left'],
                     'top': all_monitors_bbox['top'],
@@ -74,6 +76,15 @@ class ScreenCropper:
 
         self.root.destroy()
 
+    def _on_enter(self, event):
+        print(event)
+        print("Enter key pressed, grabbing main monitor area.")
+        self.cropped_image = self.captured_image.crop((self.main_monitor['left'], self.main_monitor['top'],
+                                                  self.main_monitor['left'] + self.main_monitor['width'],
+                                                   self.main_monitor['top'] + self.main_monitor['height']))
+        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.")
@@ -101,13 +112,18 @@ class ScreenCropper:
         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):
+    def run(self, return_main_monitor=False):
         self.grab_all_monitors()
+        if return_main_monitor and self.captured_image:
+            return self.captured_image.crop((self.main_monitor['left'], self.main_monitor['top'],
+                                                  self.main_monitor['left'] + self.main_monitor['width'],
+                                                   self.main_monitor['top'] + self.main_monitor['height']))
         if self.captured_image and self.monitor_geometry:
             self.show_image_and_select_box()
             return self.get_cropped_image()

GameSentenceMiner/util/audio_offset_selector.py

@@ -0,0 +1,205 @@
+import os
+import tkinter as tk
+from tkinter import filedialog, messagebox
+import soundfile as sf
+import numpy as np
+import matplotlib.pyplot as plt
+from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg
+import sounddevice as sd
+
+from GameSentenceMiner.util import ffmpeg
+
+
+class AudioOffsetGUI:
+
+    def __init__(self, master, audio_file_path=None):
+        self.master = master
+        master.title("Audio Offset Adjuster")
+        master.geometry("1000x700")
+
+        master.tk_setPalette(background='#2E2E2E', foreground='white',
+                             activeBackground='#4F4F4F', activeForeground='white')
+
+        self.audio_data = None
+        self.samplerate = None
+        self.duration = 0.0
+
+        self.fig, self.ax = plt.subplots(figsize=(10, 4))
+        self.canvas = FigureCanvasTkAgg(self.fig, master=master)
+        self.canvas_widget = self.canvas.get_tk_widget()
+        self.canvas_widget.pack(side=tk.TOP, fill=tk.BOTH, expand=True, padx=10, pady=10)
+
+        plt.style.use('dark_background')
+        self.fig.set_facecolor('#2E2E2E')
+        self.ax.set_facecolor('#2E2E2E')
+        self.ax.tick_params(axis='x', colors='white')
+        self.ax.tick_params(axis='y', colors='white')
+        self.ax.spines['bottom'].set_color('white')
+        self.ax.spines['left'].set_color('white')
+        self.ax.spines['top'].set_color('white')
+        self.ax.spines['right'].set_color('white')
+        self.ax.set_xlabel("Time (s)", color='white')
+        self.ax.set_ylabel("Amplitude", color='white')
+
+        self.beg_offset_line = None
+        # self.end_offset_line is removed as there's no end slider
+
+        self.create_widgets()
+
+        self.load_audio(audio_file_path)
+
+
+    def create_widgets(self):
+        control_frame = tk.Frame(self.master, bg='#2E2E2E')
+        control_frame.pack(side=tk.BOTTOM, fill=tk.X, pady=10, padx=10)
+
+        self.play_button = tk.Button(control_frame, text="Play/Pause Segment", command=self.play_segment, bg='#4F4F4F', fg='white')
+        self.play_button.pack(side=tk.RIGHT, padx=5)
+
+        self.output_button = tk.Button(control_frame, text="Get Offset", command=self.get_offsets, bg='#4F4F4F', fg='white')
+        self.output_button.pack(side=tk.RIGHT, padx=5)
+
+        self.beg_offset_label = tk.Label(control_frame, text="Beginning Offset: 0.00s", bg='#2E2E2E', fg='white')
+        self.beg_offset_label.pack(side=tk.LEFT, padx=10)
+
+        self.end_offset_label = tk.Label(control_frame, text="End Offset: Full Duration", bg='#2E2E2E', fg='white')
+        self.end_offset_label.pack(side=tk.LEFT, padx=10)
+
+        slider_frame = tk.Frame(self.master, bg='#2E2E2E')
+        slider_frame.pack(side=tk.BOTTOM, fill=tk.X, pady=5, padx=10)
+
+        beg_slider_label = tk.Label(slider_frame, text="Start Trim:", bg='#2E2E2E', fg='white')
+        beg_slider_label.pack(side=tk.LEFT)
+        self.beg_slider = tk.Scale(slider_frame, from_=0, to=100, orient=tk.HORIZONTAL, resolution=0.5,
+                                   command=self.on_slider_change, bg='#2E2E2E', fg='white', troughcolor='#4F4F4F',
+                                   highlightbackground='#2E2E2E', length=300)
+        self.beg_slider.pack(side=tk.LEFT, expand=True, fill=tk.X, padx=5)
+
+        # Removed end_slider and its associated label
+
+    def load_audio(self, file_path):
+        if file_path:
+            try:
+                self.audio_data, self.samplerate = sf.read(file_path)
+                if self.audio_data.ndim > 1:
+                    self.audio_data = self.audio_data[:, 0]
+                self.duration = len(self.audio_data) / self.samplerate
+                self.plot_waveform()
+                self.beg_slider.config(to=self.duration)
+                self.beg_slider.set(0) # Reset start slider to 0
+            except Exception as e:
+                messagebox.showerror("Error", f"Failed to load audio file: {e}")
+                self.audio_data = None
+                self.samplerate = None
+                self.duration = 0.0
+
+    def plot_waveform(self):
+        self.ax.clear()
+        if self.audio_data is not None:
+            time = np.linspace(0, self.duration, len(self.audio_data))
+            self.ax.plot(time, self.audio_data, color='#1E90FF')
+            self.ax.set_xlim(0, self.duration)
+            self.ax.set_ylim(np.min(self.audio_data), np.max(self.audio_data))
+            self.ax.set_title("Audio", color='white')
+
+            if self.beg_offset_line:
+                self.beg_offset_line.remove()
+            # self.end_offset_line.remove() is removed
+
+            self.beg_offset_line = self.ax.axvline(self.beg_slider.get(), color='red', linestyle='--', linewidth=2)
+            # The end line is now always at the duration
+            self.ax.axvline(self.duration, color='green', linestyle='--', linewidth=2)
+
+            self.update_offset_labels()
+        else:
+            self.ax.text(0.5, 0.5, "No audio loaded",
+                         horizontalalignment='center', verticalalignment='center',
+                         transform=self.ax.transAxes, color='white', fontsize=16)
+
+        self.fig.canvas.draw_idle()
+
+    def on_slider_change(self, val):
+        if self.audio_data is None:
+            return
+
+        beg_val = float(self.beg_slider.get())
+
+        if self.beg_offset_line:
+            self.beg_offset_line.set_xdata([beg_val])
+
+        self.update_offset_labels()
+        self.fig.canvas.draw_idle()
+
+    def play_segment(self):
+        if self.audio_data is None:
+            messagebox.showinfo("Play Audio", "No audio file loaded yet.")
+            return
+
+        if hasattr(self, 'is_playing') and self.is_playing:
+            sd.stop()
+            self.is_playing = False
+            return
+
+        beg_offset = self.beg_slider.get()
+        end_offset = self.duration # End offset is now always full duration
+
+        if beg_offset >= end_offset:
+            messagebox.showwarning("Play Audio", "Start offset must be less than end offset.")
+            return
+
+        start_frame = int(beg_offset * self.samplerate)
+        end_frame = int(end_offset * self.samplerate)
+
+        if start_frame >= len(self.audio_data) or end_frame <= 0:
+            messagebox.showwarning("Play Audio", "Selected segment is out of audio range.")
+            return
+
+        segment_to_play = self.audio_data[start_frame:end_frame]
+
+        try:
+            self.is_playing = True
+            sd.play(segment_to_play, self.samplerate)
+        except Exception as e:
+            self.is_playing = False
+            messagebox.showerror("Audio Playback Error", f"Failed to play audio: {e}")
+
+    def update_offset_labels(self):
+        if self.beg_offset_line:  # We no longer have an end_offset_line object
+            beg_val = self.beg_offset_line.get_xdata()[0] - 5.0  # Adjusting for the 5 seconds offset
+            self.beg_offset_label.config(text=f"Beginning Offset: {beg_val:.2f}s")
+
+    def get_offsets(self):
+        if self.audio_data is None:
+            messagebox.showinfo("Offsets", "No audio file loaded yet.")
+            return
+
+        beg_offset = self.beg_slider.get() - 5.0
+        end_offset = self.duration # End offset is always full duration
+
+        print(f"{beg_offset:.2f}")
+        exit(0)
+
+def run_audio_offset_gui(path=None, beginning_offset=0, end_offset=None):
+    temp_file_path = os.path.join(os.path.dirname(path), "temp_audio.opus")
+
+    if os.path.exists(temp_file_path):
+        os.remove(temp_file_path)
+
+    ffmpeg.trim_audio(path, beginning_offset - 5, end_offset, temp_file_path, True, 0, 0)
+
+    root = tk.Tk()
+    root.protocol("WM_DELETE_WINDOW", lambda: exit(1))  # Exit when the window is closed
+    app = AudioOffsetGUI(root, audio_file_path=temp_file_path)
+    root.mainloop()
+
+
+if __name__ == "__main__":
+    import argparse
+
+    parser = argparse.ArgumentParser(description="Run Audio Offset GUI")
+    parser.add_argument("--path", type=str, required=True, help="Path to the audio file")
+    parser.add_argument("--beginning_offset", type=float, default=0, help="Beginning offset in seconds")
+    parser.add_argument("--end_offset", type=float, default=None, help="End offset in seconds")
+
+    args = parser.parse_args()
+    run_audio_offset_gui(path=args.path, beginning_offset=args.beginning_offset, end_offset=args.end_offset)