GameSentenceMiner 2.11.2__py3-none-any.whl → 2.11.3__py3-none-any.whl

GameSentenceMiner/obs.py

@@ -203,6 +203,7 @@ def connect_to_obs_sync(retry=2):
                 obs_connection_manager = OBSConnectionManager()
                 obs_connection_manager.start()
             update_current_game()
+            logger.info("Connected to OBS WebSocket.")
             break  # Exit the loop once connected
         except Exception as e:
             if retry <= 0:
@@ -295,6 +296,12 @@ def get_source_from_scene(scene_name):
         logger.error(f"Error getting source from scene: {e}")
         return ''
 
+def get_active_source():
+    current_game = get_current_game()
+    if not current_game:
+        return None
+    return get_source_from_scene(current_game)
+
 def get_record_directory():
     try:
         response = client.get_record_directory()
@@ -362,7 +369,7 @@ def get_screenshot_base64(compression=0, width=None, height=None):
             return None
         response = client.get_source_screenshot(name=current_source_name, img_format='png', quality=compression, width=width, height=height)
         if response and response.image_data:
-            return response.image_data
+            return response.image_data.split(',', 1)[-1]  # Remove data:image/png;base64, prefix if present
         else:
             logger.error(f"Error getting base64 screenshot: {response}")
             return None

GameSentenceMiner/ocr/gsm_ocr_config.py

@@ -1,12 +1,15 @@
-import ctypes
+import os
 from copy import deepcopy
 from dataclasses import dataclass
 from math import floor, ceil
+from pathlib import Path
 
+from GameSentenceMiner import obs
 from dataclasses_json import dataclass_json
 from typing import List, Optional, Union
 
-from GameSentenceMiner.util.configuration import logger
+from GameSentenceMiner.util.configuration import logger, get_app_directory
+from GameSentenceMiner.util.gsm_utils import sanitize_filename
 
 
 @dataclass_json
@@ -50,8 +53,10 @@ class OCRConfig:
     window: Optional[str] = None
     language: str = "ja"
 
-    def scale_coords(self):
+    def __post_init__(self):
         self.pre_scale_rectangles = deepcopy(self.rectangles)
+
+    def scale_coords(self):
         if self.coordinate_system and self.coordinate_system == "percentage" and self.window:
             import pygetwindow as gw
             try:
@@ -116,7 +121,28 @@ def get_window(title):
             return window
     return ret
 
-# try w10+, fall back to w8.1+
+# if windows, set dpi awareness to per-monitor v2
 def set_dpi_awareness():
+    import sys
+    if sys.platform != "win32":
+        return
+    import ctypes
     per_monitor_awareness = 2
     ctypes.windll.shcore.SetProcessDpiAwareness(per_monitor_awareness)
+
+def get_scene_ocr_config(use_window_as_config=False, window=""):
+    ocr_config_dir = get_ocr_config_path()
+    try:
+        if use_window_as_config:
+            scene = sanitize_filename(window)
+        else:
+            scene = sanitize_filename(obs.get_current_scene() or "Default")
+    except Exception as e:
+        print(f"Error getting OBS scene: {e}. Using default config name.")
+        scene = "Default"
+    return os.path.join(ocr_config_dir, f"{scene}.json")
+
+def get_ocr_config_path():
+    ocr_config_dir = os.path.join(get_app_directory(), "ocr_config")
+    os.makedirs(ocr_config_dir, exist_ok=True)
+    return ocr_config_dir

GameSentenceMiner/ocr/owocr_area_selector.py

@@ -1,23 +1,19 @@
+import argparse
+import base64
 import ctypes
+import io
 import json
 import sys
 from multiprocessing import Process, Manager
 from pathlib import Path
 
-import mss
 from PIL import Image, ImageTk
 
 # Assuming a mock or real obs module exists in this path
 from GameSentenceMiner import obs
-from GameSentenceMiner.ocr.gsm_ocr_config import set_dpi_awareness, get_window
+from GameSentenceMiner.ocr.gsm_ocr_config import set_dpi_awareness, get_window, get_scene_ocr_config
 from GameSentenceMiner.util.gsm_utils import sanitize_filename
 
-try:
-    import pygetwindow as gw
-except ImportError:
-    print("Error: pygetwindow library not found. Please install it: pip install pygetwindow")
-    gw = None
-
 try:
     import tkinter as tk
     from tkinter import font as tkfont  # NEW: Import for better font control
@@ -34,30 +30,59 @@ COORD_SYSTEM_PERCENTAGE = "percentage"
 
 
 class ScreenSelector:
-    def __init__(self, result, window_name, use_window_as_config):
-        if not selector_available or not gw:
-            raise RuntimeError("tkinter or pygetwindow is not available.")
+    def __init__(self, result, window_name, use_window_as_config, use_obs_screenshot=False):
+        if not selector_available:
+            raise RuntimeError("tkinter is not available.")
         if not window_name:
-            raise ValueError("A target window name is required for percentage-based coordinates.")
+            raise ValueError("A target window name is required for configuration.")
 
         obs.connect_to_obs_sync()
         self.window_name = window_name
-        print(f"Targeting window: '{window_name}'")
-
-        self.sct = mss.mss()
-        self.monitors = self.sct.monitors[1:]
-        if not self.monitors:
-            raise RuntimeError("No monitors found by mss.")
-        for i, monitor in enumerate(self.monitors):
-            monitor['index'] = i
-
-        # --- Window Awareness is now critical ---
-        self.target_window = self._find_target_window()
-        self.target_window_geometry = self._get_window_geometry(self.target_window)
-        if not self.target_window_geometry:
-            raise RuntimeError(f"Could not find or get geometry for window '{self.window_name}'.")
-        print(f"Found target window at: {self.target_window_geometry}")
-        # ---
+        self.use_obs_screenshot = use_obs_screenshot
+        self.screenshot_img = None
+        try:
+            import mss
+            self.sct = mss.mss()
+            self.monitors = self.sct.monitors[1:]
+            if not self.monitors:
+                raise RuntimeError("No monitors found by mss.")
+            for i, monitor in enumerate(self.monitors):
+                monitor['index'] = i
+        except ImportError:
+            print("Error: mss library not found. Please install it: pip install mss")
+            raise RuntimeError("mss is required for screen selection.")
+
+        if self.use_obs_screenshot:
+            print("Using OBS screenshot as target.")
+            screenshot_base64 = obs.get_screenshot_base64(compression=75)
+            # print(screenshot_base64)
+            if not screenshot_base64:
+                raise RuntimeError("Failed to get OBS screenshot.")
+            try:
+                img_data = base64.b64decode(screenshot_base64)
+                self.screenshot_img = Image.open(io.BytesIO(img_data))
+                # Scale image to 1280x720
+                self.screenshot_img = self.screenshot_img.resize((1280, 720), Image.LANCZOS)
+            except Exception as e:
+                raise RuntimeError(f"Failed to decode or open OBS screenshot: {e}")
+
+            self.target_window = None
+            self.target_window_geometry = {
+                "left": 0, "top": 0,
+                "width": self.screenshot_img.width,
+                "height": self.screenshot_img.height
+            }
+            print(f"OBS Screenshot dimensions: {self.target_window_geometry}")
+        else:
+            import pygetwindow as gw
+            if not gw:
+                raise RuntimeError("pygetwindow is not available for window selection.")
+            print(f"Targeting window: '{window_name}'")
+            self.target_window = self._find_target_window()
+            self.target_window_geometry = self._get_window_geometry(self.target_window)
+            if not self.target_window_geometry:
+                raise RuntimeError(f"Could not find or get geometry for window '{self.window_name}'.")
+            print(f"Found target window at: {self.target_window_geometry}")
 
         self.root = None
         self.scene = ''
@@ -71,6 +96,11 @@ class ScreenSelector:
         self.redo_stack = []
         self.bounding_box = {}  # Geometry of the single large canvas window
 
+        self.canvas = None
+        self.window = None
+        self.instructions_widget = None
+        self.instructions_window_id = None
+
         self.load_existing_rectangles()
 
     def _find_target_window(self):
@@ -91,23 +121,9 @@ class ScreenSelector:
                 return None
         return None
 
-    def get_scene_ocr_config(self):
-        app_dir = Path.home() / "AppData" / "Roaming" / "GameSentenceMiner"
-        ocr_config_dir = app_dir / "ocr_config"
-        ocr_config_dir.mkdir(parents=True, exist_ok=True)
-        try:
-            if self.use_window_as_config:
-                self.scene = sanitize_filename(self.window_name)
-            else:
-                self.scene = sanitize_filename(obs.get_current_scene() or "")
-        except Exception as e:
-            print(f"Error getting OBS scene: {e}. Using default config name.")
-            self.scene = ""
-        return ocr_config_dir / f"{self.scene}.json"
-
     def load_existing_rectangles(self):
         """Loads rectangles from config, converting from percentage to absolute pixels for use."""
-        config_path = self.get_scene_ocr_config()
+        config_path = get_scene_ocr_config(self.use_window_as_config, self.window_name)
         win_geom = self.target_window_geometry  # Use current geometry for conversion
         win_w, win_h, win_l, win_t = win_geom['width'], win_geom['height'], win_geom['left'], win_geom['top']
 
@@ -152,7 +168,7 @@ class ScreenSelector:
 
     def save_rects(self, event=None):
         """Saves rectangles to config, converting from absolute pixels to percentages."""
-        config_path = self.get_scene_ocr_config()
+        config_path = get_scene_ocr_config(self.use_window_as_config, self.window_name)
         win_geom = self.target_window_geometry
         win_l, win_t, win_w, win_h = win_geom['left'], win_geom['top'], win_geom['width'], win_geom['height']
         print(f"Saving rectangles to: {config_path} relative to window: {win_geom}")
@@ -200,6 +216,12 @@ class ScreenSelector:
             event.widget.winfo_toplevel().winfo_children()[0].delete(last_rect_id)
             print("Undo: Removed last rectangle.")
 
+    def toggle_image_mode(self, e=None):
+        self.image_mode = not self.image_mode
+        # Only change alpha of the main window, not the text widget
+        self.window.attributes("-alpha", 1.0 if self.image_mode else 0.25)
+        print("Toggled background visibility.")
+
     def redo_last_rect(self, event=None):
         if not self.redo_stack: return
         monitor, abs_coords, is_excluded, old_rect_id = self.redo_stack.pop()
@@ -213,8 +235,63 @@ class ScreenSelector:
         print("Redo: Restored rectangle.")
 
     # --- NEW METHOD TO DISPLAY INSTRUCTIONS ---
-    def _create_instructions_widget(self, canvas):
-        """Creates a text box with usage instructions on the canvas."""
+    def _create_instructions_widget(self, parent_canvas):
+        """Creates a separate, persistent window for instructions and control buttons."""
+        if self.instructions_widget and self.instructions_widget.winfo_exists():
+            self.instructions_widget.lift()
+            return
+
+        self.instructions_widget = tk.Toplevel(parent_canvas)
+        self.instructions_widget.title("Controls")
+
+        # --- Position it near the main window ---
+        parent_window = parent_canvas.winfo_toplevel()
+        # Make the instructions window transient to the main window to keep it on top
+        # self.instructions_widget.transient(parent_window)
+        self.instructions_widget.attributes('-topmost', 1)
+        # parent_window.update_idletasks()  # Ensure dimensions are up-to-date
+        pos_x = parent_window.winfo_x() + 50
+        pos_y = parent_window.winfo_y() + 50
+        self.instructions_widget.geometry(f"+{pos_x}+{pos_y}")
+        
+        main_frame = tk.Frame(self.instructions_widget, padx=10, pady=10)
+        main_frame.pack(fill=tk.BOTH, expand=True)
+
+        instructions_text = (
+            "How to Use:\n"
+            "• Left Click + Drag: Create a capture area (green).\n"
+            "• Shift + Left Click + Drag: Create an exclusion area (orange).\n"
+            "• Right-Click on a box: Delete it."
+        )
+        tk.Label(main_frame, text=instructions_text, justify=tk.LEFT, anchor="w").pack(pady=(0, 10), fill=tk.X)
+
+        button_frame = tk.Frame(main_frame)
+        button_frame.pack(fill=tk.X, pady=5)
+
+        def canvas_event_wrapper(func):
+            class MockEvent:
+                def __init__(self, widget):
+                    self.widget = widget
+            return lambda: func(MockEvent(self.canvas))
+
+        def root_event_wrapper(func):
+            return lambda: func(None)
+
+        tk.Button(button_frame, text="Save and Quit (Ctrl+S)", command=root_event_wrapper(self.save_rects)).pack(fill=tk.X, pady=2)
+        tk.Button(button_frame, text="Undo (Ctrl+Z)", command=canvas_event_wrapper(self.undo_last_rect)).pack(fill=tk.X, pady=2)
+        tk.Button(button_frame, text="Redo (Ctrl+Y)", command=canvas_event_wrapper(self.redo_last_rect)).pack(fill=tk.X, pady=2)
+        tk.Button(button_frame, text="Toggle Background (M)", command=root_event_wrapper(self.toggle_image_mode)).pack(fill=tk.X, pady=2)
+        tk.Button(button_frame, text="Quit without Saving (Esc)", command=root_event_wrapper(self.quit_app)).pack(fill=tk.X, pady=2)
+
+        hotkeys_text = "\n• I: Toggle this instruction panel"
+        tk.Label(main_frame, text=hotkeys_text, justify=tk.LEFT, anchor="w").pack(pady=(10, 0), fill=tk.X)
+
+        self.instructions_widget.protocol("WM_DELETE_WINDOW", self.toggle_instructions)
+
+
+    # --- NEW METHOD TO DISPLAY INSTRUCTIONS ---
+    def print_instructions_box(self, canvas):
+        """Creates a separate, persistent window for instructions and control buttons."""
         instructions_text = (
             "How to Use:\n"
             "  • Left Click + Drag: Create a capture area (green).\n"
@@ -260,44 +337,51 @@ class ScreenSelector:
         canvas.tag_lower(rect_id, text_id)
 
     def toggle_instructions(self, event=None):
-        canvas = event.widget.winfo_toplevel().winfo_children()[0]
-        # Find all text and rectangle items (assuming only one of each for instructions)
-        text_items = [item for item in canvas.find_all() if canvas.type(item) == 'text']
-        rect_items = [item for item in canvas.find_all() if canvas.type(item) == 'rectangle']
-
-        if text_items and rect_items:
-            current_state = canvas.itemcget(text_items[0], 'state')
-            new_state = tk.NORMAL if current_state == tk.HIDDEN else tk.HIDDEN
-            for item in text_items + rect_items:
-                canvas.itemconfigure(item, state=new_state)
-            print("Toggled instructions visibility.")
+        if self.instructions_widget and self.instructions_widget.winfo_exists() and self.instructions_widget.state() == "normal":
+            self.instructions_widget.withdraw()
+            print("Toggled instructions visibility: OFF")
+        else:
+            self._create_instructions_widget(self.canvas)
+            print("Toggled instructions visibility: ON")
 
     def start(self):
         self.root = tk.Tk()
         self.root.withdraw()
 
-        # Calculate bounding box of all monitors
-        left = min(m['left'] for m in self.monitors)
-        top = min(m['top'] for m in self.monitors)
-        right = max(m['left'] + m['width'] for m in self.monitors)
-        bottom = max(m['top'] + m['height'] for m in self.monitors)
-        self.bounding_box = {'left': left, 'top': top, 'width': right - left, 'height': bottom - top}
-
-        sct_img = self.sct.grab(self.sct.monitors[0])
-        img = Image.frombytes("RGB", sct_img.size, sct_img.bgra, "raw", "BGRX")
-
-        window = tk.Toplevel(self.root)
-        window.geometry(f"{self.bounding_box['width']}x{self.bounding_box['height']}+{left}+{top}")
-        window.overrideredirect(1)
-        window.attributes('-topmost', 1)
+        if self.use_obs_screenshot:
+            # Use the pre-loaded OBS screenshot
+            img = self.screenshot_img
+            self.bounding_box = self.target_window_geometry
+            # Center the window on the primary monitor
+            primary_monitor = self.sct.monitors[1] if len(self.sct.monitors) > 1 else self.sct.monitors[0]
+            win_x = primary_monitor['left'] + (primary_monitor['width'] - img.width) // 2
+            win_y = primary_monitor['top'] + (primary_monitor['height'] - img.height) // 2
+            window_geometry = f"{img.width}x{img.height}+{int(win_x)}+{int(win_y)}"
+        else:
+            # Calculate bounding box of all monitors for the overlay
+            left = min(m['left'] for m in self.monitors)
+            top = min(m['top'] for m in self.monitors)
+            right = max(m['left'] + m['width'] for m in self.monitors)
+            bottom = max(m['top'] + m['height'] for m in self.monitors)
+            self.bounding_box = {'left': left, 'top': top, 'width': right - left, 'height': bottom - top}
+
+            # Capture the entire desktop area covered by all monitors
+            sct_img = self.sct.grab(self.bounding_box)
+            img = Image.frombytes("RGB", sct_img.size, sct_img.bgra, "raw", "BGRX")
+            window_geometry = f"{self.bounding_box['width']}x{self.bounding_box['height']}+{left}+{top}"
+
+        self.window = tk.Toplevel(self.root)
+        self.window.geometry(window_geometry)
+        self.window.overrideredirect(1)
+        self.window.attributes('-topmost', 1)
 
         self.photo_image = ImageTk.PhotoImage(img)
-        canvas = tk.Canvas(window, cursor='cross', highlightthickness=0)
-        canvas.pack(fill=tk.BOTH, expand=True)
-        canvas.create_image(0, 0, image=self.photo_image, anchor=tk.NW)
+        self.canvas = tk.Canvas(self.window, cursor='cross', highlightthickness=0)
+        self.canvas.pack(fill=tk.BOTH, expand=True)
+        self.canvas.create_image(0, 0, image=self.photo_image, anchor=tk.NW)
 
         # --- MODIFIED: CALL THE INSTRUCTION WIDGET CREATOR ---
-        self._create_instructions_widget(canvas)
+        # self._create_instructions_widget(self.canvas)
         # --- END MODIFICATION ---
 
         # Draw existing rectangles (which were converted to absolute pixels on load)
@@ -305,29 +389,29 @@ class ScreenSelector:
             x_abs, y_abs, w_abs, h_abs = abs_coords
             canvas_x = x_abs - self.bounding_box['left']
             canvas_y = y_abs - self.bounding_box['top']
-            rect_id = canvas.create_rectangle(canvas_x, canvas_y, canvas_x + w_abs, canvas_y + h_abs,
+            rect_id = self.canvas.create_rectangle(canvas_x, canvas_y, canvas_x + w_abs, canvas_y + h_abs,
                                               outline='orange' if is_excluded else 'green', width=2)
             self.drawn_rect_ids.append(rect_id)
 
         def on_click(event):
             self.start_x, self.start_y = event.x, event.y
             outline = 'purple' if bool(event.state & 0x0001) else 'red'
-            self.current_rect_id = canvas.create_rectangle(self.start_x, self.start_y, self.start_x, self.start_y,
+            self.current_rect_id = self.canvas.create_rectangle(self.start_x, self.start_y, self.start_x, self.start_y,
                                                            outline=outline, width=2)
 
         def on_drag(event):
-            if self.current_rect_id: canvas.coords(self.current_rect_id, self.start_x, self.start_y, event.x, event.y)
+            if self.current_rect_id: self.canvas.coords(self.current_rect_id, self.start_x, self.start_y, event.x, event.y)
 
         def on_release(event):
             if not self.current_rect_id: return
-            coords = canvas.coords(self.current_rect_id)
+            coords = self.canvas.coords(self.current_rect_id)
             x_abs = int(min(coords[0], coords[2]) + self.bounding_box['left'])
             y_abs = int(min(coords[1], coords[3]) + self.bounding_box['top'])
             w, h = int(abs(coords[2] - coords[0])), int(abs(coords[3] - coords[1]))
 
             if w >= MIN_RECT_WIDTH and h >= MIN_RECT_HEIGHT:
                 is_excl = bool(event.state & 0x0001)
-                canvas.itemconfig(self.current_rect_id, outline='orange' if is_excl else 'green')
+                self.canvas.itemconfig(self.current_rect_id, outline='orange' if is_excl else 'green')
 
                 center_x, center_y = x_abs + w / 2, y_abs + h / 2
                 target_mon = self.monitors[0]
@@ -341,7 +425,7 @@ class ScreenSelector:
                 self.drawn_rect_ids.append(self.current_rect_id)
                 self.redo_stack.clear()
             else:
-                canvas.delete(self.current_rect_id)
+                self.canvas.delete(self.current_rect_id)
             self.current_rect_id = self.start_x = self.start_y = None
 
         def on_right_click(event):
@@ -366,45 +450,45 @@ class ScreenSelector:
                     # Now, perform the deletion
                     del self.rectangles[i]
                     del self.drawn_rect_ids[i]
-                    canvas.delete(item_id_to_del)
+                    self.canvas.delete(item_id_to_del)
                     print("Deleted rectangle.")
 
                     break  # Stop after deleting the topmost one
 
-        def toggle_image_mode(e=None):
-            self.image_mode = not self.image_mode
-            # Only change alpha of the main window, not the text widget
-            window.attributes("-alpha", 1.0 if self.image_mode else 0.25)
-            print("Toggled background visibility.")
-
         def on_enter(e=None):
-            canvas.focus_set()
-
-        canvas.bind('<Enter>', on_enter)
-        canvas.bind('<ButtonPress-1>', on_click)
-        canvas.bind('<B1-Motion>', on_drag)
-        canvas.bind('<ButtonRelease-1>', on_release)
-        canvas.bind('<Button-3>', on_right_click)
-        canvas.bind('<Control-s>', self.save_rects)
-        canvas.bind('<Control-y>', self.redo_last_rect)
-        canvas.bind('<Control-z>', self.undo_last_rect)
-        canvas.bind("<Escape>", self.quit_app)
-        canvas.bind("<m>", toggle_image_mode)
-        canvas.bind("<i>", self.toggle_instructions)
-
-        canvas.focus_set()
+            self.canvas.focus_set()
+
+        self.canvas.bind('<Enter>', on_enter)
+        self.canvas.bind('<ButtonPress-1>', on_click)
+        self.canvas.bind('<B1-Motion>', on_drag)
+        self.canvas.bind('<ButtonRelease-1>', on_release)
+        self.canvas.bind('<Button-3>', on_right_click)
+        self.canvas.bind('<Control-s>', self.save_rects)
+        self.canvas.bind('<Control-y>', self.redo_last_rect)
+        self.canvas.bind('<Control-z>', self.undo_last_rect)
+        self.canvas.bind("<Escape>", self.quit_app)
+        self.canvas.bind("<m>", self.toggle_image_mode)
+        self.canvas.bind("<i>", self.toggle_instructions)
+
+        self.canvas.focus_set()
+        self._create_instructions_widget(self.window)
+        self.window.winfo_toplevel().update_idletasks()
+        self.print_instructions_box(self.canvas)
         # The print message is now redundant but kept for console feedback
         print("Starting UI. See on-screen instructions. Press Esc to quit, Ctrl+S to save.")
+        # self.canvas.update_idletasks()
         self.root.mainloop()
 
     def quit_app(self, event=None):
+        if self.instructions_widget and self.instructions_widget.winfo_exists():
+            self.instructions_widget.destroy()
         if self.root and self.root.winfo_exists(): self.root.destroy()
         self.root = None
 
 
-def run_screen_selector(result_dict, window_name, use_window_as_config):
+def run_screen_selector(result_dict, window_name, use_window_as_config, use_obs_screenshot):
     try:
-        selector = ScreenSelector(result_dict, window_name, use_window_as_config)
+        selector = ScreenSelector(result_dict, window_name, use_window_as_config, use_obs_screenshot)
         selector.start()
     except Exception as e:
         print(f"Error in selector process: {e}", file=sys.stderr)
@@ -413,15 +497,15 @@ def run_screen_selector(result_dict, window_name, use_window_as_config):
         result_dict['error'] = str(e)
 
 
-def get_screen_selection(window_name, use_window_as_config=False):
-    if not selector_available or not gw: return None
+def get_screen_selection(window_name, use_window_as_config=False, use_obs_screenshot=False):
+    if not selector_available: return None
     if not window_name:
         print("Error: A target window name must be provided.", file=sys.stderr)
         return None
 
     with Manager() as manager:
         result_data = manager.dict()
-        process = Process(target=run_screen_selector, args=(result_data, window_name, use_window_as_config))
+        process = Process(target=run_screen_selector, args=(result_data, window_name, use_window_as_config, use_obs_screenshot))
         print(f"Starting ScreenSelector process...")
         process.start()
         process.join()
@@ -439,18 +523,24 @@ def get_screen_selection(window_name, use_window_as_config=False):
 
 if __name__ == "__main__":
     set_dpi_awareness()
-    target_window_title = "YouTube - JP"
-    use_window_as_config = False
-    if len(sys.argv) > 1:
-        target_window_title = sys.argv[1]
-    if len(sys.argv) > 2:
-        use_window_as_config = True
-        target_window_title = sys.argv[1]
 
-    selection_result = get_screen_selection(target_window_title, use_window_as_config)
+    parser = argparse.ArgumentParser(description="Screen Selector Arguments")
+    parser.add_argument("window_title", nargs="?", default="", help="Target window title")
+    parser.add_argument("--obs_ocr", action="store_true", help="Use OBS screenshot")
+    parser.add_argument("--use_window_for_config", action="store_true", help="Use window for config")
+    args = parser.parse_args()
+
+    target_window_title = args.window_title
+    use_obs_screenshot = args.obs_ocr
+    use_window_as_config = args.use_window_for_config
+
+    print(f"Arguments: Window Title='{target_window_title}', Use OBS Screenshot={use_obs_screenshot}, Use Window for Config={use_window_as_config}")
+
+    # Example of how to call it
+    selection_result = get_screen_selection(target_window_title, use_window_as_config, use_obs_screenshot)
 
     if selection_result is None:
-        print("\n--- Screen selection failed. ---")
+        print("--- Screen selection failed. ---")
     elif not selection_result:
         print("\n--- Screen selection cancelled. ---")
     elif 'rectangles' in selection_result:

GameSentenceMiner/ocr/owocr_helper.py

@@ -22,7 +22,7 @@ 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, get_window
+from GameSentenceMiner.ocr.gsm_ocr_config import OCRConfig, set_dpi_awareness, get_window, get_ocr_config_path
 from GameSentenceMiner.owocr.owocr import screen_coordinate_picker, run
 from GameSentenceMiner.util.gsm_utils import sanitize_filename, do_text_replacements, OCR_REPLACEMENTS_FILE
 
@@ -49,15 +49,13 @@ logger.addHandler(console_handler)
 
 def get_ocr_config(window=None, use_window_for_config=False) -> 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"
-    os.makedirs(ocr_config_dir, exist_ok=True)
+    ocr_config_dir = get_ocr_config_path()
     obs.connect_to_obs_sync(retry=0)
     if use_window_for_config and window:
         scene = sanitize_filename(window)
     else:
         scene = sanitize_filename(obs.get_current_scene())
-    config_path = ocr_config_dir / f"{scene}.json"
+    config_path = Path(ocr_config_dir) / f"{scene}.json"
     if not config_path.exists():
         ocr_config = OCRConfig(scene=scene, window=window, rectangles=[], coordinate_system="percentage")
         with open(config_path, 'w', encoding="utf-8") as f:
@@ -202,7 +200,8 @@ def do_second_ocr(ocr1_text, time, img, filtering, ignore_furigana_filter=False,
                                                         engine=ocr2, furigana_filter_sensitivity=furigana_filter_sensitivity if not ignore_furigana_filter else 0)
 
         if compare_ocr_results(last_ocr2_result, orig_text):
-            logger.info("Detected similar text from previous OCR2 result, not sending")
+            if text:
+                logger.info("Seems like Text we already sent, not doing anything.")
             return
         save_result_image(img)
         last_ocr2_result = orig_text
@@ -257,7 +256,8 @@ def text_callback(text, orig_text, time, img=None, came_from_ss=False, filtering
 
     if manual or not twopassocr:
         if compare_ocr_results(previous_orig_text, orig_text_string):
-            logger.info("Seems like Text we already sent, not doing anything.")
+            if text:
+                logger.info("Seems like Text we already sent, not doing anything.")
             return
         save_result_image(img)
         asyncio.run(send_result(text, line_start_time))
@@ -275,7 +275,8 @@ def text_callback(text, orig_text, time, img=None, came_from_ss=False, filtering
             stable_time = text_stable_start_time
             previous_img_local = previous_img
             if compare_ocr_results(previous_orig_text, orig_text_string):
-                logger.info("Seems like Text we already sent, not doing anything.")
+                if text:
+                    logger.info("Seems like Text we already sent, not doing anything.")
                 previous_text = None
                 return
             previous_orig_text = orig_text_string
@@ -292,6 +293,10 @@ def text_callback(text, orig_text, time, img=None, came_from_ss=False, filtering
         previous_text = None
         return
 
+    # Make sure it's an actual new line before starting the timer
+    if compare_ocr_results(orig_text_string, previous_orig_text):
+        return
+
     if not text_stable_start_time:
         text_stable_start_time = line_start_time
     previous_text = text
@@ -327,8 +332,14 @@ def run_oneocr(ocr_config: OCRConfig, rectangles):
 
     run.init_config(False)
     try:
-        run.run(read_from="screencapture" if window else "",
-                read_from_secondary="clipboard" if ss_clipboard else None,
+        read_from = ""
+        if obs_ocr:
+            read_from = "obs"
+        elif window:
+            read_from = "screencapture"
+        read_from_secondary = "clipboard" if ss_clipboard else None
+        run.run(read_from=read_from,
+                read_from_secondary=read_from_secondary,
                 write_to="callback",
                 screen_capture_area=screen_area,
                 # screen_capture_monitor=monitor_config['index'],
@@ -405,7 +416,7 @@ def set_force_stable_hotkey():
 
 if __name__ == "__main__":
     try:
-        global ocr1, ocr2, twopassocr, language, ss_clipboard, ss, ocr_config, furigana_filter_sensitivity, area_select_ocr_hotkey, window, optimize_second_scan, use_window_for_config, keep_newline
+        global ocr1, ocr2, twopassocr, language, ss_clipboard, ss, ocr_config, furigana_filter_sensitivity, area_select_ocr_hotkey, window, optimize_second_scan, use_window_for_config, keep_newline, obs_ocr
         import sys
 
         import argparse
@@ -430,6 +441,7 @@ if __name__ == "__main__":
         parser.add_argument("--use_window_for_config", action="store_true",
                             help="Use the specified window for loading OCR configuration")
         parser.add_argument("--keep_newline", action="store_true", help="Keep new lines in OCR output")
+        parser.add_argument('--obs_ocr', action='store_true', help='Use OBS for Picture Source (not implemented)')
 
         args = parser.parse_args()
 
@@ -449,12 +461,13 @@ if __name__ == "__main__":
         optimize_second_scan = args.optimize_second_scan
         use_window_for_config = args.use_window_for_config
         keep_newline = args.keep_newline
+        obs_ocr = args.obs_ocr
 
         window = None
         logger.info(f"Received arguments: {vars(args)}")
         # set_force_stable_hotkey()
         ocr_config: OCRConfig = get_ocr_config(window=window_name, use_window_for_config=use_window_for_config)
-        if ocr_config:
+        if ocr_config and not obs_ocr:
             if ocr_config.window:
                 start_time = time.time()
                 while time.time() - start_time < 30:

GameSentenceMiner/owocr/owocr/ocr.py

@@ -326,7 +326,6 @@ class GoogleLens:
                     # logger.info(f"Vertical space: {vertical_space}, Average height: {avg_height}")
                     # logger.info(avg_height * 2)
                     if vertical_space > avg_height * 2:
-                        logger.info('Adding blank line')
                         res += 'BLANK_LINE'
                 for line in paragraph['lines']:
                     if furigana_filter_sensitivity:

GameSentenceMiner/owocr/owocr/run.py

@@ -55,7 +55,7 @@ except ImportError:
     pass
 from .config import Config
 from .screen_coordinate_picker import get_screen_selection
-from GameSentenceMiner.util.configuration import get_temporary_directory
+from GameSentenceMiner.util.configuration import get_temporary_directory, get_config
 
 config = None
 
@@ -763,6 +763,100 @@ class ScreenshotThread(threading.Thread):
         elif self.windows_window_tracker_instance:
             self.windows_window_tracker_instance.join()
 
+# Use OBS for Screenshot Source (i.e. Linux)
+class OBSScreenshotThread(threading.Thread):
+    def __init__(self, ocr_config, screen_capture_on_combo, width=1280, height=720, interval=1):
+        super().__init__(daemon=True)
+        self.ocr_config = ocr_config
+        self.interval = interval
+        self.obs_client = None
+        self.websocket = None
+        self.width = width
+        self.height = height
+        self.use_periodic_queue = not screen_capture_on_combo
+
+    def write_result(self, result):
+        if self.use_periodic_queue:
+            periodic_screenshot_queue.put(result)
+        else:
+            image_queue.put((result, True))
+
+    def connect_obs(self):
+        try:
+            import obsws_python as obs
+            self.obs_client = obs.ReqClient(
+                host=get_config().obs.host,
+                port=get_config().obs.port,
+                password=get_config().obs.password,
+                timeout=10
+            )
+            logger.info("Connected to OBS WebSocket.")
+        except Exception as e:
+            logger.error(f"Failed to connect to OBS: {e}")
+            self.obs_client = None
+
+    def run(self):
+        import base64
+        import io
+        from PIL import Image
+        import GameSentenceMiner.obs as obs
+
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+
+        self.connect_obs()
+        self.ocr_config.scale_to_custom_size(self.width, self.height)
+        current_source = obs.get_active_source()
+        current_source_name = current_source.get('sourceName') if isinstance(current_source, dict) else None
+
+        while not terminated:
+            try:
+                response = self.obs_client.get_source_screenshot(
+                    name=current_source_name,
+                    img_format='png',
+                    quality=75,
+                    width=self.width,
+                    height=self.height,
+                )
+
+                if response.image_data:
+                    image_data = base64.b64decode(response.image_data.split(",")[1])
+                    img = Image.open(io.BytesIO(image_data)).convert("RGBA")
+
+                    for rectangle in self.ocr_config.rectangles:
+                        if rectangle.is_excluded:
+                            left, top, width, height = rectangle.coordinates
+                            draw = ImageDraw.Draw(img)
+                            draw.rectangle((left, top, left + width, top + height), fill=(0, 0, 0, 0))
+
+                    cropped_sections = []
+                    for rectangle in [r for r in self.ocr_config.rectangles if not r.is_excluded]:
+                        area = rectangle.coordinates
+                        cropped_sections.append(img.crop((area[0], area[1], area[0] + area[2], area[1] + area[3])))
+
+                    if len(cropped_sections) > 1:
+                        combined_width = max(section.width for section in cropped_sections)
+                        combined_height = sum(section.height for section in cropped_sections) + (
+                            len(cropped_sections) - 1) * 10
+                        combined_img = Image.new("RGBA", (combined_width, combined_height))
+                        y_offset = 0
+                        for section in cropped_sections:
+                            combined_img.paste(section, (0, y_offset))
+                            y_offset += section.height + 50
+                        img = combined_img
+                    elif cropped_sections:
+                        img = cropped_sections[0]
+
+                    self.write_result(img)
+                else:
+                    logger.error("Failed to get screenshot data from OBS.")
+
+            except Exception as e:
+                logger.error(f"An unexpected error occurred with OBS connection: {e}")
+                continue
+
+            time.sleep(self.interval)
+
 class AutopauseTimer:
     def __init__(self, timeout):
         self.stop_event = threading.Event()
@@ -1137,7 +1231,7 @@ def run(read_from=None,
     prefix_to_use = ""
     delay_secs = config.get_general('delay_secs')
 
-    non_path_inputs = ('screencapture', 'clipboard', 'websocket', 'unixsocket')
+    non_path_inputs = ('screencapture', 'clipboard', 'websocket', 'unixsocket', 'obs')
     read_from_path = None
     read_from_readable = []
     terminated = False
@@ -1176,22 +1270,33 @@ def run(read_from=None,
         global txt_callback
         txt_callback = text_callback
 
-    if 'screencapture' in (read_from, read_from_secondary):
-        global take_screenshot
+    if 'screencapture' in (read_from, read_from_secondary) or 'obs' in (read_from, read_from_secondary):
         global screenshot_event
-        last_screenshot_time = 0
-        last_result = ([], engine_index)
+        global take_screenshot
         if screen_capture_combo != '':
             screen_capture_on_combo = True
             key_combos[screen_capture_combo] = on_screenshot_combo
         else:
             global periodic_screenshot_queue
             periodic_screenshot_queue = queue.Queue()
+
+    if 'screencapture' in (read_from, read_from_secondary):
+        last_screenshot_time = 0
+        last_result = ([], engine_index)
+
         screenshot_event = threading.Event()
         screenshot_thread = ScreenshotThread(screen_capture_area, screen_capture_window, screen_capture_exclusions, screen_capture_only_active_windows, screen_capture_areas, screen_capture_on_combo)
         screenshot_thread.start()
         filtering = TextFiltering()
         read_from_readable.append('screen capture')
+    if 'obs' in (read_from, read_from_secondary):
+        last_screenshot_time = 0
+        last_result = ([], engine_index)
+        screenshot_event = threading.Event()
+        obs_screenshot_thread = OBSScreenshotThread(gsm_ocr_config, screen_capture_on_combo, interval=screen_capture_delay_secs)
+        obs_screenshot_thread.start()
+        filtering = TextFiltering()
+        read_from_readable.append('obs')
     if 'websocket' in (read_from, read_from_secondary):
         read_from_readable.append('websocket')
     if 'unixsocket' in (read_from, read_from_secondary):
@@ -1231,7 +1336,7 @@ def run(read_from=None,
         write_to_readable = f'file {write_to}'
 
     process_queue = (any(i in ('clipboard', 'websocket', 'unixsocket') for i in (read_from, read_from_secondary)) or read_from_path or screen_capture_on_combo)
-    process_screenshots = 'screencapture' in (read_from, read_from_secondary) and not screen_capture_on_combo
+    process_screenshots = any(x in ('screencapture', 'obs') for x in (read_from, read_from_secondary)) and not screen_capture_on_combo
     if threading.current_thread() == threading.main_thread():
         signal.signal(signal.SIGINT, signal_handler)
     if (not process_screenshots) and auto_pause != 0:
@@ -1256,7 +1361,7 @@ def run(read_from=None,
                 pass
 
         if (not img) and process_screenshots:
-            if (not paused) and screenshot_thread.screencapture_window_active and screenshot_thread.screencapture_window_visible and (time.time() - last_screenshot_time) > screen_capture_delay_secs:
+            if (not paused) and (not screenshot_thread or (screenshot_thread.screencapture_window_active and screenshot_thread.screencapture_window_visible)) and (time.time() - last_screenshot_time) > screen_capture_delay_secs:
                 screenshot_event.set()
                 img = periodic_screenshot_queue.get()
                 filter_img = True

{gamesentenceminer-2.11.2.dist-info → gamesentenceminer-2.11.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: GameSentenceMiner
-Version: 2.11.2
+Version: 2.11.3
 Summary: A tool for mining sentences from games. Update: Full UI Re-design
 Author-email: Beangate <bpwhelan95@gmail.com>
 License: MIT License

{gamesentenceminer-2.11.2.dist-info → gamesentenceminer-2.11.3.dist-info}/RECORD

@@ -3,7 +3,7 @@ GameSentenceMiner/anki.py,sha256=3BVFXAM7tpJAxHMbsMpnMHUoDfyqHQ1JSYJThW18QWA,168
 GameSentenceMiner/config_gui.py,sha256=QTK1yBDcfHaIUR_JyekkRQY9CVI_rh3Cae0bi7lviIo,99198
 GameSentenceMiner/gametext.py,sha256=6VkjmBeiuZfPk8T6PHFdIAElBH2Y_oLVYvmcafqN7RM,6747
 GameSentenceMiner/gsm.py,sha256=wTERcvG37SeDel51TCFusoQqk5B_b11YY4QZMTF0a6s,24954
-GameSentenceMiner/obs.py,sha256=o_I6213VZvXqYkZDdUBgUg2KWi9SbnNZZjjUnKnQkK4,15190
+GameSentenceMiner/obs.py,sha256=rapxY9PTDczGr7e8_41hVuD5VoRExe3IFFbSWZcYDsQ,15470
 GameSentenceMiner/vad.py,sha256=A3CvBQ67w3c7L8s7mTMxo6U_9ZQXlCToIpGUbePotfA,18321
 GameSentenceMiner/ai/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 GameSentenceMiner/ai/ai_prompting.py,sha256=ojp7i_xg2YB1zALgFbivwtXPMVkThnSbPoUiAs-nz_g,25892
@@ -16,17 +16,17 @@ GameSentenceMiner/assets/icon512.png,sha256=HxUj2GHjyQsk8NV433256UxU9phPhtjCY-YB
 GameSentenceMiner/assets/icon64.png,sha256=N8xgdZXvhqVQP9QUK3wX5iqxX9LxHljD7c-Bmgim6tM,9301
 GameSentenceMiner/assets/pickaxe.png,sha256=VfIGyXyIZdzEnVcc4PmG3wszPMO1W4KCT7Q_nFK6eSE,1403829
 GameSentenceMiner/ocr/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-GameSentenceMiner/ocr/gsm_ocr_config.py,sha256=jtTzAWtMAx8GuA1XIJ_BmyNn3aYaO3u_c5Q7m5D4gS8,4056
+GameSentenceMiner/ocr/gsm_ocr_config.py,sha256=76IuoOMsBxNvU8z8lixqz58YSZpenNVugnHjrUXgCf4,4963
 GameSentenceMiner/ocr/ocrconfig.py,sha256=_tY8mjnzHMJrLS8E5pHqYXZjMuLoGKYgJwdhYgN-ny4,6466
-GameSentenceMiner/ocr/owocr_area_selector.py,sha256=lHMVZuEE_-_wICfDr6jDJNSJIyZd2PnF7dIajknaHCU,20255
-GameSentenceMiner/ocr/owocr_helper.py,sha256=OV31PCPGwLUYq3HBFdS6UoFB2hAyJE8yHm1UoDYoY38,22431
+GameSentenceMiner/ocr/owocr_area_selector.py,sha256=Aj6t-cCePPeYNSF-XxQKo2gVNWmWqK3f3qR-0vxdtuE,25523
+GameSentenceMiner/ocr/owocr_helper.py,sha256=sxmZcori9_ujldclwQFpmMwTyfJyflAQ3mn_3BvIdQs,22888
 GameSentenceMiner/ocr/ss_picker.py,sha256=0IhxUdaKruFpZyBL-8SpxWg7bPrlGpy3lhTcMMZ5rwo,5224
 GameSentenceMiner/owocr/owocr/__init__.py,sha256=87hfN5u_PbL_onLfMACbc0F5j4KyIK9lKnRCj6oZgR0,49
 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=S1unC9FShXApl5mxL0NAdvcH3wISB8KcolZcAxOGdnM,59450
-GameSentenceMiner/owocr/owocr/run.py,sha256=lwZOj5nmQWgXlQOA_b2FYrMjhGWCPA7ZZCBg-cj57-k,56518
+GameSentenceMiner/owocr/owocr/ocr.py,sha256=xAhqCfVY2xKKvUhskAiAaYiL3yQrAl8oYi5GU46NOgI,59392
+GameSentenceMiner/owocr/owocr/run.py,sha256=824KFS5v3c4ZLx7RYafBOezvFmnB4Idexf4mJAJhfp8,61100
 GameSentenceMiner/owocr/owocr/screen_coordinate_picker.py,sha256=Na6XStbQBtpQUSdbN3QhEswtKuU1JjReFk_K8t5ezQE,3395
 GameSentenceMiner/util/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 GameSentenceMiner/util/audio_offset_selector.py,sha256=8Stk3BP-XVIuzRv9nl9Eqd2D-1yD3JrgU-CamBywJmY,8542
@@ -62,9 +62,9 @@ GameSentenceMiner/web/templates/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm
 GameSentenceMiner/web/templates/index.html,sha256=Gv3CJvNnhAzIVV_QxhNq4OD-pXDt1vKCu9k6WdHSXuA,215343
 GameSentenceMiner/web/templates/text_replacements.html,sha256=tV5c8mCaWSt_vKuUpbdbLAzXZ3ATZeDvQ9PnnAfqY0M,8598
 GameSentenceMiner/web/templates/utility.html,sha256=3flZinKNqUJ7pvrZk6xu__v67z44rXnaK7UTZ303R-8,16946
-gamesentenceminer-2.11.2.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-gamesentenceminer-2.11.2.dist-info/METADATA,sha256=zpe9LIoyiK5AyBRjnGH7Blp8z5rksCm3Nrxng5CKhyg,7319
-gamesentenceminer-2.11.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-gamesentenceminer-2.11.2.dist-info/entry_points.txt,sha256=2APEP25DbfjSxGeHtwBstMH8mulVhLkqF_b9bqzU6vQ,65
-gamesentenceminer-2.11.2.dist-info/top_level.txt,sha256=V1hUY6xVSyUEohb0uDoN4UIE6rUZ_JYx8yMyPGX4PgQ,18
-gamesentenceminer-2.11.2.dist-info/RECORD,,
+gamesentenceminer-2.11.3.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+gamesentenceminer-2.11.3.dist-info/METADATA,sha256=mn5TDp9ibeCZhzxmIdhs4JZnVHwZPWtY0JYJRShzYGQ,7319
+gamesentenceminer-2.11.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+gamesentenceminer-2.11.3.dist-info/entry_points.txt,sha256=2APEP25DbfjSxGeHtwBstMH8mulVhLkqF_b9bqzU6vQ,65
+gamesentenceminer-2.11.3.dist-info/top_level.txt,sha256=V1hUY6xVSyUEohb0uDoN4UIE6rUZ_JYx8yMyPGX4PgQ,18
+gamesentenceminer-2.11.3.dist-info/RECORD,,