GameSentenceMiner 2.7.7__py3-none-any.whl → 2.7.9__py3-none-any.whl

GameSentenceMiner/obs.py

@@ -60,7 +60,7 @@ def get_obs_websocket_config_values():
 
     # Extract values
     server_enabled = config.get("server_enabled", False)
-    server_port = config.get("server_port", 4455)  # Default to 4455 if not set
+    server_port = config.get("server_port", 7274)  # Default to 4455 if not set
     server_password = config.get("server_password", None)
 
     if not server_enabled:
@@ -73,8 +73,8 @@ def get_obs_websocket_config_values():
     if get_config().obs.password == 'your_password':
         logger.info("OBS WebSocket password is not set. Setting it now...")
         config = get_master_config()
-        config.obs.port = server_port
-        config.obs.password = server_password
+        config.get_config().port = server_port
+        config.get_config().password = server_password
         with open(get_config_path(), 'w') as file:
             json.dump(config.to_dict(), file, indent=4)
         reload_config()

GameSentenceMiner/ocr/gsm_ocr_config.py

@@ -0,0 +1,42 @@
+from dataclasses import dataclass
+from dataclasses_json import dataclass_json
+from typing import List, Optional
+
+@dataclass_json
+@dataclass
+class Monitor:
+    left: int
+    top: int
+    width: int
+    height: int
+    index: int
+
+@dataclass_json
+@dataclass
+class Rectangle:
+    monitor: Monitor
+    coordinates: List[int]
+    is_excluded: bool
+
+@dataclass_json
+@dataclass
+class OCRConfig:
+    scene: str
+    rectangles: List[Rectangle]
+    window: Optional[str] = None
+
+# Example of how you might use from_dict (assuming you have a dictionary called 'data')
+data = {
+    "scene": "CODEVEIN",
+    "window": "CODE VEIN",
+    "rectangles": [
+        {
+            "monitor": {"left": 0, "top": 0, "width": 2560, "height": 1440, "index": 0},
+            "coordinates": [749, 1178, 1100, 147],
+            "is_excluded": False,
+        }
+    ],
+}
+
+config = OCRConfig.from_dict(data)
+print(config)

GameSentenceMiner/ocr/owocr_area_selector.py

@@ -1,275 +1,294 @@
-import ctypes
 import sys
+from multiprocessing import Process, Manager
+import mss
+from GameSentenceMiner import obs
+
+from GameSentenceMiner.util import sanitize_filename
+from PIL import Image, ImageTk
 import tkinter as tk
-from tkinter import messagebox, simpledialog
 import json
 from pathlib import Path
-import time  # Optional: for debugging timing if needed
-from PIL import Image, ImageTk
-import io
-import keyboard
-
-from GameSentenceMiner import obs, util
-
-class DynamicAreaSelector(tk.Tk):
-    def __init__(self, window_title):
-        super().__init__()
-        self.title("Dynamic Area Selector")
-        self.attributes('-fullscreen', True)
-        self.attributes("-topmost", True)  # Make the window always on top
-        self.attributes("-alpha", 0.20)
-
-        self.window_title = window_title
-        self.rects = []
+import re
+
+try:
+    import tkinter as tk
+    selector_available = True
+except:
+    selector_available = False
+
+MIN_RECT_WIDTH = 25  # Minimum width in pixels
+MIN_RECT_HEIGHT = 25 # Minimum height in pixels
+
+class ScreenSelector:
+    def __init__(self, result, window_name):
+        obs.connect_to_obs()
+        self.window_name = window_name
+        print(window_name)
+        self.sct = mss.mss()
+        self.monitors = self.sct.monitors[1:]
+        self.root = None
+        self.result = result
+        self.rectangles = []  # List to store (monitor, coordinates, is_excluded) tuples
+        self.drawn_rect_ids = []  # List to store canvas rectangle IDs
+        self.current_rect_id = None
         self.start_x = None
         self.start_y = None
-        self.current_rect_id = None
-        self.drawn_rect_ids = []
-        self.saved_rect_coords = []
-        self.excluded_rect_coords = []  # New list for excluded rectangles
-        self.drawn_excluded_rect_ids = []  # New list for excluded rect ids
-        self.image_mode = False
-        self.image_item = None
-        self.image_tk = None
-        self.canvas = None
-
-        if not self.initialize_ui():
-            self.after(0, self.destroy)
-            return
+        self.canvas_windows = {}  # Dictionary to store canvas per monitor
+        self.load_existing_rectangles()
+        self.image_mode = True
+        self.monitor_windows = {}
+        self.redo_stack = []
 
-        self.canvas.bind("<ButtonPress-1>", self.on_press)
-        self.canvas.bind("<B1-Motion>", self.on_drag)
-        self.canvas.bind("<ButtonRelease-1>", self.on_release)
-        self.canvas.bind("<Button-3>", self.on_right_click)  # Bind right-click
-        self.bind("<Control-s>", self.save_rects_event)
-        self.bind("<Control-z>", self.undo_last_rect)
-        self.bind("<Escape>", self.quit_app)
-        self.bind("<Control-i>", self.toggle_image_mode)
-
-        self.protocol("WM_DELETE_WINDOW", self.on_close)
+    def get_scene_ocr_config(self):
+        """Return the path to the OCR config file in GameSentenceMiner/ocr_config."""
+        app_dir = Path.home() / "AppData" / "Roaming" / "GameSentenceMiner"
+        ocr_config_dir = app_dir / "ocr_config"
+        ocr_config_dir.mkdir(parents=True, exist_ok=True)
+        scene = sanitize_filename(obs.get_current_scene())
+        config_path = ocr_config_dir / f"{scene}.json"
+        return config_path
 
-    def initialize_ui(self):
+    def load_existing_rectangles(self):
+        config_path = self.get_scene_ocr_config()
         try:
-            self.canvas = tk.Canvas(self, highlightthickness=0)
-            self.canvas.pack(fill=tk.BOTH, expand=True)
-
-            self.load_and_draw_existing_rects()
-            return True
-
-        except Exception as e:
-            messagebox.showerror("Initialization Error", f"Failed: {e}")
-            print(f"Initialization error details: {e}")
-            return False
-
-    def load_and_draw_existing_rects(self):
-        if self.get_scene_ocr_config().exists():
-            try:
-                with open(self.get_scene_ocr_config(), 'r') as f:
-                    config_data = json.load(f)
-                    loaded_rects = []
-                    loaded_excluded_rects = []
-                    for r in config_data.get("rectangles", []):
-                        try:
-                            coords = tuple(map(float, r))
-                            if len(coords) == 4:
-                                loaded_rects.append(coords)
+            with open(config_path, 'r') as f:
+                config_data = json.load(f)
+                if "rectangles" in config_data:
+                    self.rectangles = []
+                    for rect_data in config_data["rectangles"]:
+                        monitor_data = rect_data.get("monitor")
+                        coords = rect_data.get("coordinates")
+                        is_excluded = rect_data.get("is_excluded", False)
+                        if monitor_data and isinstance(coords, list) and len(coords) == 4:
+                            x, y, w, h = coords
+                            if w >= MIN_RECT_WIDTH and h >= MIN_RECT_HEIGHT:
+                                self.rectangles.append((monitor_data, tuple(coords), is_excluded))
                             else:
-                                print(f"Skipping invalid rectangle data: {r}")
-                        except (ValueError, TypeError) as coord_err:
-                            print(f"Skipping invalid coordinate data in rectangle {r}: {coord_err}")
-
-                    for r in config_data.get("excluded_rectangles", []):
-                        try:
-                            coords = tuple(map(float, r))
-                            if len(coords) == 4:
-                                loaded_excluded_rects.append(coords)
-                            else:
-                                print(f"Skipping invalid excluded rectangle data: {r}")
-                        except (ValueError, TypeError) as coord_err:
-                            print(f"Skipping invalid coordinate data in excluded rectangle {r}: {coord_err}")
-
-                    self.saved_rect_coords = loaded_rects
-                    self.excluded_rect_coords = loaded_excluded_rects
-                    for rect_id in self.drawn_rect_ids:
-                        self.canvas.delete(rect_id)
-                    for rect_id in self.drawn_excluded_rect_ids:
-                        self.canvas.delete(rect_id)
-                    self.drawn_rect_ids = []
-                    self.drawn_excluded_rect_ids = []
-
-                    for rect in self.saved_rect_coords:
-                        x1, y1, x2, y2 = rect
-                        rect_id = self.canvas.create_rectangle(x1, y1, x2, y2, outline='blue', width=2)
-                        self.drawn_rect_ids.append(rect_id)
-
-                    for rect in self.excluded_rect_coords:
-                        x1, y1, x2, y2 = rect
-                        rect_id = self.canvas.create_rectangle(x1, y1, x2, y2, outline='orange', width=2)
-                        self.drawn_excluded_rect_ids.append(rect_id)
-
-            except json.JSONDecodeError:
-                messagebox.showwarning("Config Load Warning", f"Could not parse {self.get_scene_ocr_config()}. Starting with no rectangles.")
-                self.saved_rect_coords = []
-                self.excluded_rect_coords = []
-            except FileNotFoundError:
-                self.saved_rect_coords = []
-                self.excluded_rect_coords = []
-            except Exception as e:
-                messagebox.showerror("Config Load Error", f"Error loading rectangles: {e}")
-                self.saved_rect_coords = []
-                self.excluded_rect_coords = []
-
-    def on_press(self, event):
-        if self.current_rect_id is None:
-            self.start_x = self.canvas.canvasx(event.x)
-            self.start_y = self.canvas.canvasy(event.y)
-            outline_color = 'red' if not event.state & 0x0001 else 'purple'  # check if shift is pressed
-            self.current_rect_id = self.canvas.create_rectangle(
-                self.start_x, self.start_y, self.start_x, self.start_y,
-                outline=outline_color, width=2
-            )
-
-    def on_drag(self, event):
-        if self.current_rect_id is not None:
-            cur_x = self.canvas.canvasx(event.x)
-            cur_y = self.canvas.canvasy(event.y)
-            self.canvas.coords(self.current_rect_id, self.start_x, self.start_y, cur_x, cur_y)
-
-    def on_release(self, event):
-        if self.current_rect_id is not None:
-            end_x = self.canvas.canvasx(event.x)
-            end_y = self.canvas.canvasy(event.y)
-            x1 = min(self.start_x, end_x)
-            y1 = min(self.start_y, end_y)
-            x2 = max(self.start_x, end_x)
-            y2 = max(self.start_y, end_y)
-
-            self.canvas.coords(self.current_rect_id, x1, y1, x2, y2)
-            if event.state & 0x0001:  # shift is pressed
-                self.canvas.itemconfig(self.current_rect_id, outline='orange')
-                self.excluded_rect_coords.append((x1, y1, x2, y2))
-                self.drawn_excluded_rect_ids.append(self.current_rect_id)
-            else:
-                self.canvas.itemconfig(self.current_rect_id, outline='green')
-                self.saved_rect_coords.append((x1, y1, x2, y2))
-                self.drawn_rect_ids.append(self.current_rect_id)
-
-            self.current_rect_id = None
-            self.start_x = None
-            self.start_y = None
+                                print(f"Skipping small rectangle from config: {coords}")
+            print(f"Loaded existing rectangles from {config_path}")
+        except FileNotFoundError:
+            print(f"No existing config found at {config_path}")
+        except json.JSONDecodeError:
+            print(f"Error decoding JSON from {config_path}")
+        except Exception as e:
+            print(f"An error occurred while loading rectangles: {e}")
 
-    def save_rects(self):
+    def save_rects(self, event=None):
         try:
-            serializable_rects = [
-                tuple(map(int, rect)) for rect in self.saved_rect_coords
-            ]
-            serializable_excluded_rects = [
-                tuple(map(int, rect)) for rect in self.excluded_rect_coords
-            ]
-            with open(self.get_scene_ocr_config(), 'w') as f:
-                json.dump({"window": self.window_title if self.window_title else "", "scene": obs.get_current_scene(), "rectangles": serializable_rects, "excluded_rectangles": serializable_excluded_rects}, f, indent=4)
-            for rect_id in self.drawn_rect_ids:
-                if self.canvas.winfo_exists():
-                    try:
-                        self.canvas.itemconfig(rect_id, outline='blue')
-                    except tk.TclError:
-                        pass
-            for rect_id in self.drawn_excluded_rect_ids:
-                if self.canvas.winfo_exists():
-                    try:
-                        self.canvas.itemconfig(rect_id, outline='orange')
-                    except tk.TclError:
-                        pass
+            print("Saving rectangles...")
+            config_path = self.get_scene_ocr_config()
+            print(config_path)
+            serializable_rects = []
+            for monitor, coords, is_excluded in self.rectangles:
+                rect_data = {
+                    "monitor": monitor,
+                    "coordinates": list(coords),  # Convert tuple to list for JSON
+                    "is_excluded": is_excluded
+                }
+                serializable_rects.append(rect_data)
+
+            print(serializable_rects)
+            with open(config_path, 'w') as f:
+                json.dump({"scene": sanitize_filename(obs.get_current_scene()), "window": self.window_name, "rectangles": serializable_rects}, f, indent=4)
             print("Rectangles saved.")
-            self.on_close()
+            self.result['rectangles'] = self.rectangles.copy()
+            self.root.destroy()
         except Exception as e:
-            messagebox.showerror("Error", f"Failed to save rectangles: {e}")
-
-    def save_rects_event(self, event=None):
-        self.save_rects()
+            print(f"Failed to save rectangles: {e}")
 
     def undo_last_rect(self, event=None):
-        if self.saved_rect_coords and self.drawn_rect_ids:
-            self.saved_rect_coords.pop()
+        if self.rectangles and self.drawn_rect_ids:
+            last_rect = self.rectangles.pop()
             last_rect_id = self.drawn_rect_ids.pop()
-            if self.canvas.winfo_exists():
-                self.canvas.delete(last_rect_id)
-        elif self.excluded_rect_coords and self.drawn_excluded_rect_ids:
-            self.excluded_rect_coords.pop()
-            last_rect_id = self.drawn_excluded_rect_ids.pop()
-            if self.canvas.winfo_exists():
-                self.canvas.delete(last_rect_id)
+
+            monitor, coords, is_excluded = last_rect
+            self.redo_stack.append((monitor, coords, is_excluded, last_rect_id))
+
+            for canvas in self.canvas_windows.values():
+                try:
+                    canvas.delete(last_rect_id)
+                except tk.TclError:
+                    pass
         elif self.current_rect_id is not None:
-            if self.canvas.winfo_exists():
-                self.canvas.delete(self.current_rect_id)
+            for canvas in self.canvas_windows.values():
+                try:
+                    canvas.delete(self.current_rect_id)
+                except tk.TclError:
+                    pass
             self.current_rect_id = None
             self.start_x = None
             self.start_y = None
 
+
+    def redo_last_rect(self, event=None):
+        if not self.redo_stack:
+            return
+
+        monitor, coords, is_excluded, rect_id = self.redo_stack.pop()
+        canvas = self.canvas_windows.get(monitor['index'])
+        if canvas:
+            x, y, w, h = coords
+            outline_color = 'green' if not is_excluded else 'orange'
+            new_rect_id = canvas.create_rectangle(x, y, x + w, y + h, outline=outline_color, width=2)
+            self.rectangles.append((monitor, coords, is_excluded))
+            self.drawn_rect_ids.append(new_rect_id)
+
+
+    def create_window(self, monitor):
+        screenshot = self.sct.grab(monitor)
+        img = Image.frombytes('RGB', screenshot.size, screenshot.rgb)
+
+        if img.width != monitor['width']:
+            img = img.resize((monitor['width'], monitor['height']), Image.Resampling.LANCZOS)
+
+        AscendingScale = 1.0  # For semi-transparent background
+        window = tk.Toplevel(self.root)
+        window.geometry(f"{monitor['width']}x{monitor['height']}+{monitor['left']}+{monitor['top']}")
+        window.overrideredirect(1)
+        window.attributes('-topmost', 1)
+
+        img_tk = ImageTk.PhotoImage(img)
+
+        canvas = tk.Canvas(window, cursor='cross', highlightthickness=0)
+        canvas.pack(fill=tk.BOTH, expand=True)
+        canvas.image = img_tk
+        canvas.bg_img_id = canvas.create_image(0, 0, image=img_tk, anchor=tk.NW)  # Store image ID
+        self.canvas_windows[monitor['index']] = canvas
+
+        # Save monitor and window references for refreshing
+        self.monitor_windows[monitor['index']] = {
+            'window': window,
+            'canvas': canvas,
+            'bg_img_id': canvas.bg_img_id,
+        }
+
+        # Draw existing rectangles for this monitor
+        for mon, coords, is_excluded in self.rectangles:
+            if mon['index'] == monitor['index']:
+                x, y, w, h = coords
+                outline_color = 'green' if not is_excluded else 'orange'
+                rect_id = canvas.create_rectangle(x, y, x + w, y + h, outline=outline_color, width=2)
+                self.drawn_rect_ids.append(rect_id)
+
+        def on_click(event):
+            if self.current_rect_id is None:
+                self.start_x, self.start_y = event.x, event.y
+                outline_color = 'red' if not event.state & 0x0001 else 'purple'  # Shift for exclusion
+                self.current_rect_id = canvas.create_rectangle(
+                    self.start_x, self.start_y, self.start_x, self.start_y,
+                    outline=outline_color, 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)
+
+        def on_release(event):
+            if self.current_rect_id:
+                end_x, end_y = event.x, event.y
+                x1 = min(self.start_x, end_x)
+                y1 = min(self.start_y, end_y)
+                x2 = max(self.start_x, end_x)
+                y2 = max(self.start_y, end_y)
+                width = abs(x2 - x1)
+                height = abs(y2 - y1)
+                if width >= MIN_RECT_WIDTH and height >= MIN_RECT_HEIGHT:
+                    is_excluded = bool(event.state & 0x0001)  # Shift key for exclusion
+                    canvas.itemconfig(self.current_rect_id, outline='green' if not is_excluded else 'orange')
+                    self.rectangles.append((monitor, (x1, y1, width, height), is_excluded))
+                    self.drawn_rect_ids.append(self.current_rect_id)
+                else:
+                    canvas.delete(self.current_rect_id)
+                    print(f"Skipping small rectangle: width={width}, height={height}")
+                self.current_rect_id = None
+                self.start_x = None
+                self.start_y = None
+
+        def on_right_click(event):
+            item = canvas.find_closest(event.x, event.y)
+            if item:
+                for idx, rect_id in enumerate(self.drawn_rect_ids):
+                    if rect_id == item[0]:
+                        canvas.delete(rect_id)
+                        # Need to find the corresponding rectangle in self.rectangles and remove it
+                        for i, (mon, coords, excluded) in enumerate(self.rectangles):
+                            if mon['index'] == monitor['index']:
+                                x_r, y_r, w_r, h_r = coords
+                                item_coords = canvas.coords(item[0])
+                                if x_r == item_coords[0] and y_r == item_coords[1] and x_r + w_r == item_coords[2] and y_r + h_r == item_coords[3]:
+                                    del self.rectangles[i]
+                                    break
+                        del self.drawn_rect_ids[idx]
+                        break
+
+        def toggle_image_mode(event=None):
+            self.image_mode = not self.image_mode
+            if self.image_mode:
+                window.attributes("-alpha", 1.0)
+            else:
+                window.attributes("-alpha", 0.20)
+
+
+        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)
+        window.bind('<Control-s>', self.save_rects)
+        window.bind('<Control-z>', self.undo_last_rect)
+        window.bind('<s>', self.save_rects)
+        window.bind('<z>', self.undo_last_rect)
+        window.bind("<Escape>", self.quit_app)
+        window.bind("<m>", toggle_image_mode)
+        window.bind('<Control-y>', self.redo_last_rect)
+        window.bind('<y>', self.redo_last_rect)
+
+    def start(self):
+        self.root = tk.Tk()
+        self.root.withdraw()
+
+        for monitor in self.monitors:
+            monitor['index'] = self.monitors.index(monitor)
+            self.create_window(monitor)
+
+        self.root.mainloop()
+
     def quit_app(self, event=None):
         print("Escape pressed, closing application.")
         self.on_close()
 
     def on_close(self):
-        self.destroy()
+        self.root.destroy()
 
-    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)
-        scene = util.sanitize_filename(obs.get_current_scene())
-        config_path = ocr_config_dir / f"{scene}.json"
-        return config_path
 
-    def on_right_click(self, event):
-        """Deletes the rectangle clicked with the right mouse button."""
-        item = self.canvas.find_closest(event.x, event.y)
-
-        if item:
-            if item[0] in self.drawn_rect_ids:  # Check if it's a saved rectangle
-                index = self.drawn_rect_ids.index(item[0])
-                self.canvas.delete(item[0])
-                del self.drawn_rect_ids[index]
-                del self.saved_rect_coords[index]
-            elif item[0] in self.drawn_excluded_rect_ids:
-                index = self.drawn_excluded_rect_ids.index(item[0])
-                self.canvas.delete(item[0])
-                del self.drawn_excluded_rect_ids[index]
-                del self.excluded_rect_coords[index]
-
-    def setup_hotkey(self):
-        keyboard.add_hotkey('F13', self.lift_window)  # Example hotkey
-
-    def lift_window(self):
-        self.lift()  # Bring the window to the front
-
-    def toggle_image_mode(self, event=None):
-        self.image_mode = not self.image_mode
-        if self.image_mode:
-            self.attributes("-alpha", 1.0)
-            self.load_image_from_obs()
-        else:
-            self.attributes("-alpha", 0.20)
-            if self.image_item:
-                self.canvas.delete(self.image_item)
-                self.image_item = None
-                self.image_tk = None
+def run_screen_selector(result, window_name):
+    selector = ScreenSelector(result, window_name)
+    selector.start()
 
-    def load_image_from_obs(self):
-        try:
-            image_path = obs.get_screenshot()
-            image = Image.open(image_path)
-            self.image_tk = ImageTk.PhotoImage(image)
-            self.image_item = self.canvas.create_image(0, 0, anchor=tk.NW, image=self.image_tk)
-            self.canvas.tag_lower(self.image_item)
-        except Exception as e:
-            messagebox.showerror("Image Load Error", f"Failed to load image from OBS: {e}")
 
-def run_screen_picker(window_title):
-    app = DynamicAreaSelector(window_title)
-    app.mainloop()
+def get_screen_selection(window_name):
+    if not selector_available:
+        raise ValueError('tkinter is not installed, unable to open picker')
+
+    with Manager() as manager:
+        res = manager.dict()
+        process = Process(target=run_screen_selector, args=(res,window_name))
+
+        process.start()
+        process.join()
+
+        if 'rectangles' in res:
+            return res.copy()
+        else:
+            return False
+
 
 if __name__ == "__main__":
     args = sys.argv[1:]
-    obs.connect_to_obs()
-    run_screen_picker(args[0] if len(args) > 0 else None)
+    window_name = args[0] if args else None
+    selection = get_screen_selection(window_name)
+    if selection:
+        print("Selected rectangles:")
+        for monitor, coords, is_excluded in selection['rectangles']:
+            print(f"Monitor: {monitor}, Coordinates: {coords}, Excluded: {is_excluded}")
+    else:
+        print("No selection made or process was interrupted.")

GameSentenceMiner/ocr/owocr_helper.py

@@ -1,7 +1,6 @@
-# area_selector.py
 import asyncio
-import base64
 import difflib
+import json
 import logging
 import os
 import queue
@@ -9,52 +8,61 @@ import threading
 import time
 from datetime import datetime
 from logging.handlers import RotatingFileHandler
+from pathlib import Path
 from tkinter import messagebox
 
 import mss
 import websockets
 from PIL import Image, ImageDraw
-import json
-from pathlib import Path
 
 from GameSentenceMiner import obs, util
 from GameSentenceMiner.configuration import get_config, get_app_directory
-from GameSentenceMiner.gametext import get_line_history
+from GameSentenceMiner.electron_config import get_ocr_scan_rate, get_requires_open_window
+from GameSentenceMiner.ocr.gsm_ocr_config import OCRConfig, Rectangle
 from GameSentenceMiner.owocr.owocr import screen_coordinate_picker, run
 from GameSentenceMiner.owocr.owocr.run import TextFiltering
-from GameSentenceMiner.electron_config import store, get_ocr_scan_rate, get_requires_open_window
+
+from dataclasses import dataclass
+from typing import List, Optional
 
 CONFIG_FILE = Path("ocr_config.json")
 DEFAULT_IMAGE_PATH = r"C:\Users\Beangate\Pictures\msedge_acbl8GL7Ax.jpg"  # CHANGE THIS
-
 logger = logging.getLogger("GSM_OCR")
 logger.setLevel(logging.DEBUG)
-
 # Create a file handler for logging
 log_file = os.path.join(get_app_directory(), "logs", "ocr_log.txt")
 os.makedirs(os.path.join(get_app_directory(), "logs"), exist_ok=True)
-
 file_handler = RotatingFileHandler(log_file, maxBytes=1024 * 1024, backupCount=5, encoding='utf-8')
 file_handler.setLevel(logging.DEBUG)
-
 # Create a formatter and set it for the handler
 formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')
 file_handler.setFormatter(formatter)
-
 # Add the handler to the logger
 logger.addHandler(file_handler)
 
+console_handler = logging.StreamHandler()
+console_handler.setLevel(logging.INFO)
+console_handler.setFormatter(formatter)
+logger.addHandler(console_handler)
+
+
 def get_new_game_cords():
     """Allows multiple coordinate selections."""
     coords_list = []
-    while True:
-        cords = screen_coordinate_picker.get_screen_selection()
-        coords_list.append({"coordinates": cords})
-        if messagebox.askyesno("Add Another Region", "Do you want to add another region?"):
-            continue
-        else:
-            break
-
+    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)
@@ -62,13 +70,13 @@ def get_new_game_cords():
     scene = util.sanitize_filename(obs.get_current_scene())
     config_path = ocr_config_dir / f"{scene}.json"
     with open(config_path, 'w') as f:
-        json.dump(coords_list, f, indent=4)
+        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():
-    """Loads multiple screen capture areas from the corresponding JSON file."""
+    """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"
     obs.connect_to_obs()
@@ -76,14 +84,58 @@ def get_ocr_config():
     config_path = ocr_config_dir / f"{scene}.json"
     if not config_path.exists():
         raise Exception(f"No config file found at {config_path}.")
-
-    if not config_path.exists():
-        print("Config Screen picker failed to make file. Please run again.")
-        return
-
-    with open(config_path, 'r') as f:
-        coords_list = json.load(f)
-        return coords_list
+    try:
+        with open(config_path, 'r') as f:
+            config_data = json.load(f)
+        if "rectangles" in config_data and isinstance(config_data["rectangles"], list) and all(
+                isinstance(item, list) and len(item) == 4 for item in config_data["rectangles"]):
+            # Old config format, convert to new
+            new_rectangles = []
+            with mss.mss() as sct:
+                monitors = sct.monitors
+                default_monitor = monitors[1] if len(monitors) > 1 else monitors[0]
+                for rect in config_data["rectangles"]:
+                    new_rectangles.append({
+                        "monitor": {
+                            "left": default_monitor["left"],
+                            "top": default_monitor["top"],
+                            "width": default_monitor["width"],
+                            "height": default_monitor["height"],
+                            "index": 0  # Assuming single monitor for old config
+                        },
+                        "coordinates": rect,
+                        "is_excluded": False
+                    })
+                for rect in config_data['excluded_rectangles']:
+                    new_rectangles.append({
+                        "monitor": {
+                            "left": default_monitor["left"],
+                            "top": default_monitor["top"],
+                            "width": default_monitor["width"],
+                            "height": default_monitor["height"],
+                            "index": 0  # Assuming single monitor for old config
+                        },
+                        "coordinates": rect,
+                        "is_excluded": True
+                    })
+            new_config_data = {"scene": config_data.get("scene", scene), "window": config_data.get("window", None),
+                               "rectangles": new_rectangles}
+            with open(config_path, 'w') as f:
+                json.dump(new_config_data, f, indent=4)
+            return OCRConfig.from_dict(new_config_data)
+        elif "rectangles" in config_data and isinstance(config_data["rectangles"], list) and all(
+                isinstance(item, dict) and "coordinates" in item for item in config_data["rectangles"]):
+            logger.info("Loading new OCR config format.")
+            logger.info(config_data)
+            return OCRConfig.from_dict(config_data)
+        else:
+            raise Exception(f"Invalid config format in {config_path}.")
+    except json.JSONDecodeError:
+        print("Error decoding JSON. Please check your config file.")
+        return None
+    except Exception as e:
+        print(f"Error loading config: {e}")
+        return None
 
 
 websocket_server_thread = None
@@ -130,7 +182,8 @@ class WebsocketServerThread(threading.Thread):
 
     def send_text(self, text, line_time: datetime):
         if text:
-            return asyncio.run_coroutine_threadsafe(self.send_text_coroutine(json.dumps({"sentence": text, "time": line_time.isoformat()})), self.loop)
+            return asyncio.run_coroutine_threadsafe(
+                self.send_text_coroutine(json.dumps({"sentence": text, "time": line_time.isoformat()})), self.loop)
 
     def stop_server(self):
         self.loop.call_soon_threadsafe(self._stop_event.set)
@@ -140,15 +193,21 @@ class WebsocketServerThread(threading.Thread):
             self._loop = asyncio.get_running_loop()
             self._stop_event = stop_event = asyncio.Event()
             self._event.set()
-            self.server = start_server = websockets.serve(self.server_handler, get_config().general.websocket_uri.split(":")[0], get_config().general.websocket_uri.split(":")[1], max_size=1000000000)
+            self.server = start_server = websockets.serve(self.server_handler,
+                                                          get_config().general.websocket_uri.split(":")[0],
+                                                          get_config().general.websocket_uri.split(":")[1],
+                                                          max_size=1000000000)
             async with start_server:
                 await stop_event.wait()
+
         asyncio.run(main())
 
+
 all_cords = None
 rectangles = None
 
-def text_callback(text, rectangle, time):
+
+def text_callback(text, rectangle_index, time, img=None):
     global twopassocr, ocr2, last_oneocr_results
     if not text:
         return
@@ -159,8 +218,9 @@ def text_callback(text, rectangle, time):
         line_time = time if time else datetime.now()
         logger.info(f"Received message: {text}, ATTEMPTING LENS OCR")
         if rectangles:
-            cords = rectangles[rectangle]
-            i = rectangle
+            rect_data: Rectangle = rectangles[rectangle_index]
+            cords = rect_data.coordinates
+            i = rectangle_index
         else:
             i = 0
             mon = sct.monitors
@@ -172,15 +232,23 @@ def text_callback(text, rectangle, time):
         last_oneocr_results[i] = text
         last_result = ([], -1)
         try:
-            sct_params = {'left': cords[0], 'top': cords[1], 'width': cords[2], 'height': cords[3]}
-            sct_img = sct.grab(sct_params)
-            img = Image.frombytes('RGB', sct_img.size, sct_img.bgra, 'raw', 'BGRX')
-            img = img.convert("RGBA")
-            draw = ImageDraw.Draw(img)
-            for exclusion in ocr_config.get("excluded_rectangles", []):
-                left, top, right, bottom = exclusion
-                draw.rectangle((left, top, right, bottom), fill=(0, 0, 0, 0))
-                # draw.rectangle((left, top, right, bottom), fill=(0,0,0))
+            # sct_params = {'left': cords[0], 'top': cords[1], 'width': cords[2], 'height': cords[3]}
+            # sct_img = sct.grab(sct_params)
+            # img = Image.frombytes('RGB', sct_img.size, sct_img.bgra, 'raw', 'BGRX')
+            # img = img.convert("RGBA")
+            # draw = ImageDraw.Draw(img)
+            # excluded_rects = ocr_config.get("excluded_rectangles", [])
+            # if isinstance(excluded_rects, list) and all(
+            #         isinstance(item, list) and len(item) == 4 for item in excluded_rects):
+            #     for exclusion in excluded_rects:
+            #         left, top, right, bottom = exclusion
+            #         draw.rectangle((left, top, right, bottom), fill=(0, 0, 0, 0))
+            # elif isinstance(excluded_rects, list) and all(
+            #         isinstance(item, dict) and "coordinates" in item and isinstance(item["coordinates"], list) and len(
+            #                 item["coordinates"]) == 4 for item in excluded_rects):
+            #     for exclusion in excluded_rects:
+            #         left, top, right, bottom = exclusion["coordinates"]
+            #         draw.rectangle((left, top, right, bottom), fill=(0, 0, 0, 0))
             orig_text, text = run.process_and_write_results(img, None, None, last_result, TextFiltering(),
                                                             engine=ocr2)
             if ":gsm_prefix:" in text:
@@ -195,74 +263,34 @@ def text_callback(text, rectangle, time):
             logger.exception(e)
             print(f"Error processing message: {e}")
 
+
 done = False
 
-def run_oneocr(ocr_config, i):
+
+def run_oneocr(ocr_config: OCRConfig, i):
     global done
+    rect_config = ocr_config.rectangles[i]
+    coords = rect_config.coordinates
+    monitor_config = rect_config.monitor
+    exclusions = (rect.coordinates for rect in list(filter(lambda x: x.is_excluded, ocr_config.rectangles)))
+    screen_area = ",".join(str(c) for c in coords)
     run.run(read_from="screencapture", write_to="callback",
-            screen_capture_area=",".join(str(c) for c in ocr_config['rectangles'][i]) if ocr_config['rectangles'] else 'screen_1',
-            screen_capture_window=ocr_config.get("window", None),
+            screen_capture_area=screen_area,
+            # screen_capture_monitor=monitor_config['index'],
+            screen_capture_window=ocr_config.window,
             screen_capture_only_active_windows=get_requires_open_window(),
             screen_capture_delay_secs=get_ocr_scan_rate(), engine=ocr1,
             text_callback=text_callback,
-            screen_capture_exclusions=ocr_config.get('excluded_rectangles', None),
+            screen_capture_exclusions=exclusions,
             rectangle=i)
     done = True
 
 
-# async def websocket_client():
-#     uri = "ws://localhost:7331"  # Replace with your hosted websocket address
-#     print("Connecting to WebSocket...")
-#     async with websockets.connect(uri) as websocket:
-#         print("Connected to WebSocket.")
-#
-#         try:
-#             while True:
-#                 message = await websocket.recv()
-#                 if not message:
-#                     continue
-#                 line_time = datetime.now()
-#                 get_line_history().add_secondary_line(message)
-#                 print(f"Received message: {message}, ATTEMPTING LENS OCR")
-#                 if ":gsm_prefix:" in message:
-#                     i = int(message.split(":gsm_prefix:")[0])
-#                 cords = all_cords[i] if i else all_cords[0]
-#                 similarity = difflib.SequenceMatcher(None, last_oneocr_results[i], message).ratio()
-#                 if similarity > .8:
-#                     continue
-#                 print(f"Similarity for region {i}: {similarity}")
-#                 last_oneocr_results[i] = message
-#                 last_result = ([], -1)
-#                 try:
-#                     sct_params = {'top': cords[1], 'left': cords[0], 'width': cords[2], 'height': cords[3]}
-#                     with mss.mss() as sct:
-#                         sct_img = sct.grab(sct_params)
-#                     img = Image.frombytes('RGB', sct_img.size, sct_img.bgra, 'raw', 'BGRX')
-#                     draw = ImageDraw.Draw(img)
-#                     for exclusion in ocr_config.get("excluded_rectangles", []):
-#                         exclusion = tuple(exclusion)
-#                         draw.rectangle(exclusion, fill="black")
-#                     orig_text, text = run.process_and_write_results(img, "results.txt", None, last_result, TextFiltering(), engine="glens")
-#                     if ":gsm_prefix:" in text:
-#                         text = text.split(":gsm_prefix:")[1]
-#                     websocket_server_thread.send_text(text, line_time)
-#                 except json.JSONDecodeError:
-#                     print("Invalid JSON received.")
-#                 except Exception as e:
-#                     logger.exception(e)
-#                     print(f"Error processing message: {e}")
-#         except websockets.exceptions.ConnectionClosed:
-#             print("WebSocket connection closed.")
-#         except Exception as e:
-#             print(f"WebSocket error: {e}")
-
-
 if __name__ == "__main__":
     global ocr1, ocr2, twopassocr
     import sys
 
     args = sys.argv[1:]
-
     if len(args) == 3:
         ocr1 = args[0]
         ocr2 = args[1]
@@ -277,34 +305,32 @@ if __name__ == "__main__":
         twopassocr = False
     else:
         ocr1 = "oneocr"
-
     logger.info(f"Received arguments: ocr1={ocr1}, ocr2={ocr2}, twopassocr={twopassocr}")
     global ocr_config
-    ocr_config = get_ocr_config()
-    rectangles = ocr_config['rectangles']
-    last_oneocr_results = [""] * len(rectangles) if rectangles else [""]
-    oneocr_threads = []
-    run.init_config(False)
-    if rectangles:
-        for i, rectangle in enumerate(rectangles):
-            thread = threading.Thread(target=run_oneocr, args=(ocr_config,i,), daemon=True)
-            oneocr_threads.append(thread)
-            thread.start()
+    ocr_config: OCRConfig = get_ocr_config()
+    if ocr_config and ocr_config.rectangles:
+        rectangles = ocr_config.rectangles
+        last_oneocr_results = [""] * len(rectangles) if rectangles else [""]
+        oneocr_threads = []
+        run.init_config(False)
+        if rectangles:
+            for i, rectangle in enumerate(rectangles):
+                thread = threading.Thread(target=run_oneocr, args=(ocr_config, i,), daemon=True)
+                oneocr_threads.append(thread)
+                thread.start()
+        else:
+            single_ocr_thread = threading.Thread(target=run_oneocr, args=(ocr_config, 0,), daemon=True)
+            oneocr_threads.append(single_ocr_thread)
+            single_ocr_thread.start()
+        websocket_server_thread = WebsocketServerThread(read=True)
+        websocket_server_thread.start()
+        try:
+            while not done:
+                time.sleep(1)
+        except KeyboardInterrupt as e:
+            pass
+        for thread in oneocr_threads:
+            thread.join()
+        # asyncio.run(websocket_client())
     else:
-        single_ocr_thread = threading.Thread(target=run_oneocr, args=(ocr_config, 0,), daemon=True)
-        oneocr_threads.append(single_ocr_thread)
-        single_ocr_thread.start()
-
-    websocket_server_thread = WebsocketServerThread(read=True)
-    websocket_server_thread.start()
-
-    try:
-        while not done:
-            time.sleep(1)
-    except KeyboardInterrupt as e:
-        pass
-
-    for thread in oneocr_threads:
-        thread.join()
-
-    # asyncio.run(websocket_client())
+        print("Failed to load OCR configuration. Please check the logs.")

GameSentenceMiner/owocr/owocr/run.py

@@ -571,7 +571,7 @@ def process_and_write_results(img_or_path, write_to, notifications, last_result,
         elif write_to == 'clipboard':
             pyperclipfix.copy(text)
         elif write_to == "callback":
-            txt_callback(text, rectangle, start_time)
+            txt_callback(text, rectangle, start_time, img_or_path)
         elif write_to:
             with Path(write_to).open('a', encoding='utf-8') as f:
                 f.write(text + '\n')
@@ -1026,6 +1026,7 @@ def run(read_from=None,
                     else:
                         try:
                             coord_left, coord_top, right, bottom = win32gui.GetWindowRect(window_handle)
+
                             coord_width = right - coord_left
                             coord_height = bottom - coord_top
 
@@ -1045,12 +1046,18 @@ def run(read_from=None,
                             on_window_closed(False)
                             break
 
-                        rand = random.randint(1, 10)
+                        # rand = random.randint(1, 10)
 
                         img = Image.frombuffer('RGB', (bmpinfo['bmWidth'], bmpinfo['bmHeight']), bmpstr, 'raw', 'BGRX', 0, 1)
 
+                        # if rand == 1:
+                        #     img.show()
+
                         if custom_left:
-                            img = img.crop((custom_left, custom_top, custom_width, custom_height))
+                            img = img.crop((custom_left, custom_top, custom_left + custom_width, custom_top + custom_height))
+
+                        # if rand == 1:
+                        #     img.show()
 
                         win32gui.DeleteObject(save_bitmap.GetHandle())
                         save_dc.DeleteDC()
@@ -1064,8 +1071,8 @@ def run(read_from=None,
                     img = img.convert("RGBA")
                     draw = ImageDraw.Draw(img)
                     for exclusion in screen_capture_exclusions:
-                        left, top, right, bottom = exclusion
-                        draw.rectangle((left, top, right, bottom), fill=(0, 0, 0, 0))
+                        left, top, width, height = exclusion
+                        draw.rectangle((left, top, left + width, top + height), fill=(0, 0, 0, 0))
                         # draw.rectangle((left, top, right, bottom), fill=(0, 0, 0))
                 # img.save(os.path.join(get_temporary_directory(), 'screencapture.png'), 'png')
                 res, _ = process_and_write_results(img, write_to, notifications, last_result, filtering, rectangle=rectangle, start_time=start_time)

GameSentenceMiner/owocr/owocr/screen_coordinate_picker.py

@@ -55,12 +55,12 @@ class ScreenSelector:
         def on_release(event):
             nonlocal start_x, start_y
             end_x, end_y = event.x, event.y
-            
-            x1 = min(start_x, end_x) 
-            y1 = min(start_y, end_y) 
-            x2 = max(start_x, end_x) 
-            y2 = max(start_y, end_y) 
-            
+
+            x1 = min(start_x, end_x)
+            y1 = min(start_y, end_y)
+            x2 = max(start_x, end_x)
+            y2 = max(start_y, end_y)
+
             self.on_select(monitor, (x1, y1, x2 - x1, y2 - y1))
 
         canvas.bind('<ButtonPress-1>', on_click)
@@ -90,11 +90,19 @@ def get_screen_selection():
     with Manager() as manager:
         res = manager.dict()
         process = Process(target=run_screen_selector, args=(res,))
-        
-        process.start()    
+
+        process.start()
         process.join()
 
         if 'monitor' in res and 'coordinates' in res:
             return res.copy()
         else:
             return False
+
+if __name__ == "__main__":
+    selection = get_screen_selection()
+    if selection:
+        print(f"Selected monitor: {selection['monitor']}")
+        print(f"Selected coordinates: {selection['coordinates']}")
+    else:
+        print("No selection made or process was interrupted.")

{gamesentenceminer-2.7.7.dist-info → gamesentenceminer-2.7.9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: GameSentenceMiner
-Version: 2.7.7
+Version: 2.7.9
 Summary: A tool for mining sentences from games. Update: Multi-Line Mining! Fixed!
 Author-email: Beangate <bpwhelan95@gmail.com>
 License: MIT License

{gamesentenceminer-2.7.7.dist-info → gamesentenceminer-2.7.9.dist-info}/RECORD

@@ -8,7 +8,7 @@ GameSentenceMiner/gametext.py,sha256=AAke4swwmN16da0IpyL5xMhU23nTz_c6z2kMfXPYv-8
 GameSentenceMiner/gsm.py,sha256=fcczDPDcC0vDLAPZtIY64mU3Di3RZjR40tuLIiwB5lE,24827
 GameSentenceMiner/model.py,sha256=JdnkT4VoPOXmOpRgFdvERZ09c9wLN6tUJxdrKlGZcqo,5305
 GameSentenceMiner/notification.py,sha256=FY39ChSRK0Y8TQ6lBGsLnpZUFPtFpSy2tweeXVoV7kc,2809
-GameSentenceMiner/obs.py,sha256=Zh3B9m86CCTSw15eVmZLPI8vxqXVAJ93EvaU1ycO33A,9121
+GameSentenceMiner/obs.py,sha256=3h1hh868zdXQFGXJ7_mQZs5kcudEMa3yBOrbCVckhCs,9139
 GameSentenceMiner/package.py,sha256=YlS6QRMuVlm6mdXx0rlXv9_3erTGS21jaP3PNNWfAH0,1250
 GameSentenceMiner/util.py,sha256=W49gqYlhbzZe-17zHMFcAjNeeteXrv_USHT7aBDKSqM,6825
 GameSentenceMiner/utility_gui.py,sha256=H4aOddlsrVR768RwbMzYScCziuOz1JeySUigNrPlaac,7692
@@ -21,23 +21,24 @@ GameSentenceMiner/downloader/Untitled_json.py,sha256=RUUl2bbbCpUDUUS0fP0tdvf5Fng
 GameSentenceMiner/downloader/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 GameSentenceMiner/downloader/download_tools.py,sha256=mI1u_FGBmBqDIpCH3jOv8DOoZ3obgP5pIf9o9SVfX2Q,8131
 GameSentenceMiner/ocr/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+GameSentenceMiner/ocr/gsm_ocr_config.py,sha256=UnkAqn_9EoJlzElHLjKYjNsDBM_MnTlsSshqbRAlXIg,890
 GameSentenceMiner/ocr/ocrconfig.py,sha256=hTROOZ3On2HngXKxwQFZvnr5AxlmlMV0mPxv-F3NbMg,6476
-GameSentenceMiner/ocr/owocr_area_selector.py,sha256=6MQPCSAhuyOSEDEgc-w6jVdsELjxstzI2Zhz0JBkG8g,11703
-GameSentenceMiner/ocr/owocr_helper.py,sha256=yR_W_tK6w7c_zDj48d1B6-9f61fBD3PPnt_FSSPleLs,11840
+GameSentenceMiner/ocr/owocr_area_selector.py,sha256=fpPE6FOFSSfgc2feur8Czve91Jl1zBG_nwUSRY6lTbg,11934
+GameSentenceMiner/ocr/owocr_helper.py,sha256=_mcjF9TA9GrselOzJQdtXhImj8nlLGih9TIiuXsaEdo,14089
 GameSentenceMiner/owocr/owocr/__init__.py,sha256=opjBOyGGyEqZCE6YdZPnyt7nVfiwyELHsXA0jAsjm14,25
 GameSentenceMiner/owocr/owocr/__main__.py,sha256=r8MI6RAmbkTWqOJ59uvXoDS7CSw5jX5war9ULGWELrA,128
 GameSentenceMiner/owocr/owocr/config.py,sha256=738QCJHEWpFhMh966plOcXYWwcshSiRsxjjIwldeTtI,7461
 GameSentenceMiner/owocr/owocr/lens_betterproto.py,sha256=oNoISsPilVVRBBPVDtb4-roJtAhp8ZAuFTci3TGXtMc,39141
 GameSentenceMiner/owocr/owocr/ocr.py,sha256=t0kU2GQyW0gf0NGqaYiOO7SjYgX8mQXLaNKJ8Eup6mg,39704
-GameSentenceMiner/owocr/owocr/run.py,sha256=HE5plzuX9297q16b6ivSeGn1wZ4A3-hR-XfoSuM6PQs,47272
-GameSentenceMiner/owocr/owocr/screen_coordinate_picker.py,sha256=f_YIV4-2OEZ21CAEZ_pbqeTb5D28PS82Tig4ZSnkY4Q,3096
+GameSentenceMiner/owocr/owocr/run.py,sha256=0MGrhO6HoLNF1JpYcl-tS6SnXNM5zu9y0oSZDrAcw5k,47499
+GameSentenceMiner/owocr/owocr/screen_coordinate_picker.py,sha256=fjJ3CSXLti3WboGPpmsa7MWOwIXsfpHC8N4zKahGGY0,3346
 GameSentenceMiner/vad/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 GameSentenceMiner/vad/silero_trim.py,sha256=ULf3zwS-JMsY82cKF7gZxREHw8L6lgpWF2U1YqgE9Oc,1681
 GameSentenceMiner/vad/vosk_helper.py,sha256=125X8C9NxFPlWWpoNsbOnEqKx8RCjXN109zNx_QXhyg,6070
 GameSentenceMiner/vad/whisper_helper.py,sha256=JJ-iltCh813XdjyEw0Wn5DaErf6PDqfH0Efu1Md8cIY,3543
-gamesentenceminer-2.7.7.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-gamesentenceminer-2.7.7.dist-info/METADATA,sha256=F81ngxg6OKtxse6IqeUFPIsAODdFwBH5D8vI1cdBcek,5839
-gamesentenceminer-2.7.7.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-gamesentenceminer-2.7.7.dist-info/entry_points.txt,sha256=2APEP25DbfjSxGeHtwBstMH8mulVhLkqF_b9bqzU6vQ,65
-gamesentenceminer-2.7.7.dist-info/top_level.txt,sha256=V1hUY6xVSyUEohb0uDoN4UIE6rUZ_JYx8yMyPGX4PgQ,18
-gamesentenceminer-2.7.7.dist-info/RECORD,,
+gamesentenceminer-2.7.9.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+gamesentenceminer-2.7.9.dist-info/METADATA,sha256=hFDJEaZNflRL93x_WRMZwDxjGSnO3ylogfdij2ZwVhs,5839
+gamesentenceminer-2.7.9.dist-info/WHEEL,sha256=pxyMxgL8-pra_rKaQ4drOZAegBVuX-G_4nRHjjgWbmo,91
+gamesentenceminer-2.7.9.dist-info/entry_points.txt,sha256=2APEP25DbfjSxGeHtwBstMH8mulVhLkqF_b9bqzU6vQ,65
+gamesentenceminer-2.7.9.dist-info/top_level.txt,sha256=V1hUY6xVSyUEohb0uDoN4UIE6rUZ_JYx8yMyPGX4PgQ,18
+gamesentenceminer-2.7.9.dist-info/RECORD,,

{gamesentenceminer-2.7.7.dist-info → gamesentenceminer-2.7.9.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (78.1.0)
+Generator: setuptools (79.0.0)
 Root-Is-Purelib: true
 Tag: py3-none-any