GameSentenceMiner 2.7.7__tar.gz → 2.7.9__tar.gz

{gamesentenceminer-2.7.7 → gamesentenceminer-2.7.9}/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-2.7.9/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-2.7.9/GameSentenceMiner/ocr/owocr_area_selector.py

@@ -0,0 +1,294 @@
+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
+import json
+from pathlib import Path
+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.canvas_windows = {}  # Dictionary to store canvas per monitor
+        self.load_existing_rectangles()
+        self.image_mode = True
+        self.monitor_windows = {}
+        self.redo_stack = []
+
+    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 load_existing_rectangles(self):
+        config_path = self.get_scene_ocr_config()
+        try:
+            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 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, event=None):
+        try:
+            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.result['rectangles'] = self.rectangles.copy()
+            self.root.destroy()
+        except Exception as e:
+            print(f"Failed to save rectangles: {e}")
+
+    def undo_last_rect(self, event=None):
+        if self.rectangles and self.drawn_rect_ids:
+            last_rect = self.rectangles.pop()
+            last_rect_id = self.drawn_rect_ids.pop()
+
+            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:
+            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.root.destroy()
+
+
+def run_screen_selector(result, window_name):
+    selector = ScreenSelector(result, window_name)
+    selector.start()
+
+
+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:]
+    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-2.7.9/GameSentenceMiner/ocr/owocr_helper.py

@@ -0,0 +1,336 @@
+import asyncio
+import difflib
+import json
+import logging
+import os
+import queue
+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
+
+from GameSentenceMiner import obs, util
+from GameSentenceMiner.configuration import get_config, get_app_directory
+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 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 = []
+    with mss.mss() as sct:
+        monitors = sct.monitors
+        monitor_map = {i: mon for i, mon in enumerate(monitors)}
+        while True:
+            selected_monitor_index, cords = screen_coordinate_picker.get_screen_selection_with_monitor(monitor_map)
+            selected_monitor = monitor_map[selected_monitor_index]
+            coords_list.append({"monitor": {"left": selected_monitor["left"], "top": selected_monitor["top"],
+                                            "width": selected_monitor["width"], "height": selected_monitor["height"],
+                                            "index": selected_monitor_index}, "coordinates": cords,
+                                "is_excluded": False})
+            if messagebox.askyesno("Add Another Region", "Do you want to add another region?"):
+                continue
+            else:
+                break
+    app_dir = Path.home() / "AppData" / "Roaming" / "GameSentenceMiner"
+    ocr_config_dir = app_dir / "ocr_config"
+    ocr_config_dir.mkdir(parents=True, exist_ok=True)
+    obs.connect_to_obs()
+    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({"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 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()
+    scene = util.sanitize_filename(obs.get_current_scene())
+    config_path = ocr_config_dir / f"{scene}.json"
+    if not config_path.exists():
+        raise Exception(f"No config file found at {config_path}.")
+    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
+websocket_queue = queue.Queue()
+paused = False
+
+
+class WebsocketServerThread(threading.Thread):
+    def __init__(self, read):
+        super().__init__(daemon=True)
+        self._loop = None
+        self.read = read
+        self.clients = set()
+        self._event = threading.Event()
+
+    @property
+    def loop(self):
+        self._event.wait()
+        return self._loop
+
+    async def send_text_coroutine(self, message):
+        for client in self.clients:
+            await client.send(message)
+
+    async def server_handler(self, websocket):
+        self.clients.add(websocket)
+        try:
+            async for message in websocket:
+                if self.read and not paused:
+                    websocket_queue.put(message)
+                    try:
+                        await websocket.send('True')
+                    except websockets.exceptions.ConnectionClosedOK:
+                        pass
+                else:
+                    try:
+                        await websocket.send('False')
+                    except websockets.exceptions.ConnectionClosedOK:
+                        pass
+        except websockets.exceptions.ConnectionClosedError:
+            pass
+        finally:
+            self.clients.remove(websocket)
+
+    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)
+
+    def stop_server(self):
+        self.loop.call_soon_threadsafe(self._stop_event.set)
+
+    def run(self):
+        async def main():
+            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)
+            async with start_server:
+                await stop_event.wait()
+
+        asyncio.run(main())
+
+
+all_cords = None
+rectangles = None
+
+
+def text_callback(text, rectangle_index, time, img=None):
+    global twopassocr, ocr2, last_oneocr_results
+    if not text:
+        return
+    if not twopassocr or not ocr2:
+        websocket_server_thread.send_text(text, time if time else datetime.now())
+        return
+    with mss.mss() as sct:
+        line_time = time if time else datetime.now()
+        logger.info(f"Received message: {text}, ATTEMPTING LENS OCR")
+        if rectangles:
+            rect_data: Rectangle = rectangles[rectangle_index]
+            cords = rect_data.coordinates
+            i = rectangle_index
+        else:
+            i = 0
+            mon = sct.monitors
+            cords = [mon[1]['left'], mon[1]['top'], mon[1]['width'], mon[1]['height']]
+        similarity = difflib.SequenceMatcher(None, last_oneocr_results[i], text).ratio()
+        if similarity > .8:
+            return
+        logger.debug(f"Similarity for region {i}: {similarity}")
+        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)
+            # 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:
+                text = text.split(":gsm_prefix:")[1]
+            if get_config().advanced.ocr_sends_to_clipboard:
+                import pyperclip
+                pyperclip.copy(text)
+            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}")
+
+
+done = False
+
+
+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=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=exclusions,
+            rectangle=i)
+    done = True
+
+
+if __name__ == "__main__":
+    global ocr1, ocr2, twopassocr
+    import sys
+
+    args = sys.argv[1:]
+    if len(args) == 3:
+        ocr1 = args[0]
+        ocr2 = args[1]
+        twopassocr = bool(int(args[2]))
+    elif len(args) == 2:
+        ocr1 = args[0]
+        ocr2 = args[1]
+        twopassocr = True
+    elif len(args) == 1:
+        ocr1 = args[0]
+        ocr2 = None
+        twopassocr = False
+    else:
+        ocr1 = "oneocr"
+    logger.info(f"Received arguments: ocr1={ocr1}, ocr2={ocr2}, twopassocr={twopassocr}")
+    global ocr_config
+    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:
+        print("Failed to load OCR configuration. Please check the logs.")