GameSentenceMiner 2.14.7__py3-none-any.whl → 2.14.9__py3-none-any.whl

GameSentenceMiner/owocr/owocr/run.py

@@ -1,1817 +0,0 @@
-from ...ocr.gsm_ocr_config import set_dpi_awareness, get_scene_ocr_config_path, OCRConfig, get_scene_ocr_config
-from ...util.electron_config import *
-
-try:
-    import win32gui
-    import win32ui
-    import win32api
-    import win32con
-    import win32process
-    import win32clipboard
-    import pywintypes
-    import ctypes
-except ImportError:
-    pass
-
-try:
-    import objc
-    import platform
-    from AppKit import NSData, NSImage, NSBitmapImageRep, NSDeviceRGBColorSpace, NSGraphicsContext, NSZeroPoint, NSZeroRect, NSCompositingOperationCopy
-    from Quartz import CGWindowListCreateImageFromArray, kCGWindowImageBoundsIgnoreFraming, CGRectMake, CGRectNull, CGMainDisplayID, CGWindowListCopyWindowInfo, \
-        CGWindowListCreateDescriptionFromArray, kCGWindowListOptionOnScreenOnly, kCGWindowListExcludeDesktopElements, kCGWindowName, kCGNullWindowID, \
-        CGImageGetWidth, CGImageGetHeight, CGDataProviderCopyData, CGImageGetDataProvider, CGImageGetBytesPerRow
-    from ScreenCaptureKit import SCContentFilter, SCScreenshotManager, SCShareableContent, SCStreamConfiguration, SCCaptureResolutionBest
-except ImportError:
-    pass
-
-import signal
-import threading
-from pathlib import Path
-import queue
-import io
-import re
-import logging
-import inspect
-import time
-
-import pyperclipfix
-import mss
-import asyncio
-import websockets
-import socketserver
-import queue
-
-from datetime import datetime, timedelta
-from PIL import Image, ImageDraw, UnidentifiedImageError
-from loguru import logger
-from desktop_notifier import DesktopNotifierSync
-import psutil
-
-import inspect
-from .ocr import *
-try:
-    from .secret import *
-except ImportError:
-    pass
-from .config import Config
-from .screen_coordinate_picker import get_screen_selection
-from GameSentenceMiner.util.configuration import get_temporary_directory, get_config
-
-config = None
-last_image = None
-
-
-class ClipboardThread(threading.Thread):
-    def __init__(self):
-        super().__init__(daemon=True)
-        self.ignore_flag = config.get_general('ignore_flag')
-        self.delay_secs = config.get_general('delay_secs')
-        self.last_update = time.time()
-
-    def are_images_identical(self, img1, img2):
-        if None in (img1, img2):
-            return img1 == img2
-
-        img1 = np.array(img1)
-        img2 = np.array(img2)
-
-        return (img1.shape == img2.shape) and (img1 == img2).all()
-
-    def normalize_macos_clipboard(self, img):
-        ns_data = NSData.dataWithBytes_length_(img, len(img))
-        ns_image = NSImage.alloc().initWithData_(ns_data)
-
-        new_image = NSBitmapImageRep.alloc().initWithBitmapDataPlanes_pixelsWide_pixelsHigh_bitsPerSample_samplesPerPixel_hasAlpha_isPlanar_colorSpaceName_bytesPerRow_bitsPerPixel_(
-            None,  # Set to None to create a new bitmap
-            int(ns_image.size().width),
-            int(ns_image.size().height),
-            8,  # Bits per sample
-            4,  # Samples per pixel (R, G, B, A)
-            True,  # Has alpha
-            False,  # Is not planar
-            NSDeviceRGBColorSpace,
-            0,  # Automatically compute bytes per row
-            32  # Bits per pixel (8 bits per sample * 4 samples per pixel)
-        )
-
-        context = NSGraphicsContext.graphicsContextWithBitmapImageRep_(
-            new_image)
-        NSGraphicsContext.setCurrentContext_(context)
-
-        ns_image.drawAtPoint_fromRect_operation_fraction_(
-            NSZeroPoint,
-            NSZeroRect,
-            NSCompositingOperationCopy,
-            1.0
-        )
-
-        return bytes(new_image.TIFFRepresentation())
-
-    def process_message(self, hwnd: int, msg: int, wparam: int, lparam: int):
-        WM_CLIPBOARDUPDATE = 0x031D
-        timestamp = time.time()
-        if msg == WM_CLIPBOARDUPDATE and timestamp - self.last_update > 1 and not paused:
-            self.last_update = timestamp
-            while True:
-                try:
-                    win32clipboard.OpenClipboard()
-                    break
-                except pywintypes.error:
-                    pass
-                time.sleep(0.1)
-            try:
-                if win32clipboard.IsClipboardFormatAvailable(win32con.CF_BITMAP) and win32clipboard.IsClipboardFormatAvailable(win32clipboard.CF_DIB):
-                    clipboard_text = ''
-                    if win32clipboard.IsClipboardFormatAvailable(win32clipboard.CF_UNICODETEXT):
-                        clipboard_text = win32clipboard.GetClipboardData(
-                            win32clipboard.CF_UNICODETEXT)
-                    if self.ignore_flag or clipboard_text != '*ocr_ignore*':
-                        img = win32clipboard.GetClipboardData(
-                            win32clipboard.CF_DIB)
-                        image_queue.put((img, False))
-                win32clipboard.CloseClipboard()
-            except pywintypes.error:
-                pass
-        return 0
-
-    def create_window(self):
-        className = 'ClipboardHook'
-        wc = win32gui.WNDCLASS()
-        wc.lpfnWndProc = self.process_message
-        wc.lpszClassName = className
-        wc.hInstance = win32api.GetModuleHandle(None)
-        class_atom = win32gui.RegisterClass(wc)
-        return win32gui.CreateWindow(class_atom, className, 0, 0, 0, 0, 0, 0, 0, wc.hInstance, None)
-
-    def run(self):
-        if sys.platform == 'win32':
-            hwnd = self.create_window()
-            self.thread_id = win32api.GetCurrentThreadId()
-            ctypes.windll.user32.AddClipboardFormatListener(hwnd)
-            win32gui.PumpMessages()
-        else:
-            is_macos = sys.platform == 'darwin'
-            if is_macos:
-                from AppKit import NSPasteboard, NSPasteboardTypeTIFF, NSPasteboardTypeString
-                pasteboard = NSPasteboard.generalPasteboard()
-                count = pasteboard.changeCount()
-            else:
-                from PIL import ImageGrab
-            process_clipboard = False
-            img = None
-
-            while not terminated:
-                if paused:
-                    sleep_time = 0.5
-                    process_clipboard = False
-                else:
-                    sleep_time = self.delay_secs
-                    if is_macos:
-                        with objc.autorelease_pool():
-                            old_count = count
-                            count = pasteboard.changeCount()
-                            if process_clipboard and count != old_count:
-                                while len(pasteboard.types()) == 0:
-                                    time.sleep(0.1)
-                                if NSPasteboardTypeTIFF in pasteboard.types():
-                                    clipboard_text = ''
-                                    if NSPasteboardTypeString in pasteboard.types():
-                                        clipboard_text = pasteboard.stringForType_(
-                                            NSPasteboardTypeString)
-                                    if self.ignore_flag or clipboard_text != '*ocr_ignore*':
-                                        img = self.normalize_macos_clipboard(
-                                            pasteboard.dataForType_(NSPasteboardTypeTIFF))
-                                        image_queue.put((img, False))
-                    else:
-                        old_img = img
-                        try:
-                            img = ImageGrab.grabclipboard()
-                        except Exception:
-                            pass
-                        else:
-                            if (process_clipboard and isinstance(img, Image.Image) and
-                                    (self.ignore_flag or pyperclipfix.paste() != '*ocr_ignore*') and
-                                    (not self.are_images_identical(img, old_img))):
-                                image_queue.put((img, False))
-
-                    process_clipboard = True
-
-                if not terminated:
-                    time.sleep(sleep_time)
-
-
-class DirectoryWatcher(threading.Thread):
-    def __init__(self, path):
-        super().__init__(daemon=True)
-        self.path = path
-        self.delay_secs = config.get_general('delay_secs')
-        self.last_update = time.time()
-        self.allowed_extensions = (
-            '.png', '.jpg', '.jpeg', '.bmp', '.gif', '.webp')
-
-    def get_path_key(self, path):
-        return path, path.lstat().st_mtime
-
-    def run(self):
-        old_paths = set()
-        for path in self.path.iterdir():
-            if path.suffix.lower() in self.allowed_extensions:
-                old_paths.add(get_path_key(path))
-
-        while not terminated:
-            if paused:
-                sleep_time = 0.5
-            else:
-                sleep_time = self.delay_secs
-                for path in self.path.iterdir():
-                    if path.suffix.lower() in self.allowed_extensions:
-                        path_key = self.get_path_key(path)
-                        if path_key not in old_paths:
-                            old_paths.add(path_key)
-
-                            if not paused:
-                                image_queue.put((path, False))
-
-            if not terminated:
-                time.sleep(sleep_time)
-
-
-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, text):
-        for client in self.clients:
-            await client.send(text)
-
-    async def server_handler(self, websocket):
-        self.clients.add(websocket)
-        try:
-            async for message in websocket:
-                if self.read and not paused:
-                    image_queue.put((message, False))
-                    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):
-        return asyncio.run_coroutine_threadsafe(self.send_text_coroutine(text), 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, '0.0.0.0', config.get_general('websocket_port'), max_size=1000000000)
-            async with start_server:
-                await stop_event.wait()
-        asyncio.run(main())
-
-
-class RequestHandler(socketserver.BaseRequestHandler):
-    def handle(self):
-        conn = self.request
-        conn.settimeout(3)
-        data = conn.recv(4)
-        img_size = int.from_bytes(data)
-        img = bytearray()
-        try:
-            while len(img) < img_size:
-                data = conn.recv(4096)
-                if not data:
-                    break
-                img.extend(data)
-        except TimeoutError:
-            pass
-
-        if not paused:
-            image_queue.put((img, False))
-            conn.sendall(b'True')
-        else:
-            conn.sendall(b'False')
-
-
-class TextFiltering:
-    accurate_filtering = False
-
-    def __init__(self, lang='ja'):
-        from pysbd import Segmenter
-        self.initial_lang = get_ocr_language() or lang
-        self.segmenter = Segmenter(language=get_ocr_language(), clean=True)
-        self.kana_kanji_regex = re.compile(
-            r'[\u3041-\u3096\u30A1-\u30FA\u4E00-\u9FFF]')
-        self.chinese_common_regex = re.compile(r'[\u4E00-\u9FFF]')
-        self.english_regex = re.compile(r'[a-zA-Z0-9.,!?;:"\'()\[\]{}]')
-        self.chinese_common_regex = re.compile(r'[\u4E00-\u9FFF]')
-        self.english_regex = re.compile(r'[a-zA-Z0-9.,!?;:"\'()\[\]{}]')
-        self.korean_regex = re.compile(r'[\uAC00-\uD7AF]')
-        self.arabic_regex = re.compile(
-            r'[\u0600-\u06FF\u0750-\u077F\u08A0-\u08FF\uFB50-\uFDFF\uFE70-\uFEFF]')
-        self.russian_regex = re.compile(
-            r'[\u0400-\u04FF\u0500-\u052F\u2DE0-\u2DFF\uA640-\uA69F\u1C80-\u1C8F]')
-        self.greek_regex = re.compile(r'[\u0370-\u03FF\u1F00-\u1FFF]')
-        self.hebrew_regex = re.compile(r'[\u0590-\u05FF\uFB1D-\uFB4F]')
-        self.thai_regex = re.compile(r'[\u0E00-\u0E7F]')
-        self.latin_extended_regex = re.compile(
-            r'[a-zA-Z\u00C0-\u00FF\u0100-\u017F\u0180-\u024F\u0250-\u02AF\u1D00-\u1D7F\u1D80-\u1DBF\u1E00-\u1EFF\u2C60-\u2C7F\uA720-\uA7FF\uAB30-\uAB6F]')
-        try:
-            from transformers import pipeline, AutoTokenizer
-            import torch
-            logging.getLogger('transformers').setLevel(logging.ERROR)
-
-            model_ckpt = 'papluca/xlm-roberta-base-language-detection'
-            tokenizer = AutoTokenizer.from_pretrained(
-                model_ckpt,
-                use_fast=False
-            )
-
-            if torch.cuda.is_available():
-                device = 0
-            elif torch.backends.mps.is_available():
-                device = 'mps'
-            else:
-                device = -1
-            self.pipe = pipeline(
-                'text-classification', model=model_ckpt, tokenizer=tokenizer, device=device)
-            self.accurate_filtering = True
-        except:
-            import langid
-            self.classify = langid.classify
-
-    def __call__(self, text, last_result):
-        lang = get_ocr_language()
-        if self.initial_lang != lang:
-            from pysbd import Segmenter
-            self.segmenter = Segmenter(language=get_ocr_language(), clean=True)
-            self.initial_lang = get_ocr_language()
-
-        orig_text = self.segmenter.segment(text)
-        orig_text_filtered = []
-        for block in orig_text:
-            if "BLANK_LINE" in block:
-                block_filtered = ["\n"]
-            elif lang == "ja":
-                block_filtered = self.kana_kanji_regex.findall(block)
-            elif lang == "zh":
-                block_filtered = self.chinese_common_regex.findall(block)
-            elif lang == "ko":
-                block_filtered = self.korean_regex.findall(block)
-            elif lang == "ar":
-                block_filtered = self.arabic_regex.findall(block)
-            elif lang == "ru":
-                block_filtered = self.russian_regex.findall(block)
-            elif lang == "el":
-                block_filtered = self.greek_regex.findall(block)
-            elif lang == "he":
-                block_filtered = self.hebrew_regex.findall(block)
-            elif lang == "th":
-                block_filtered = self.thai_regex.findall(block)
-            elif lang in ["en", "fr", "de", "es", "it", "pt", "nl", "sv", "da", "no",
-                          "fi"]:  # Many European languages use extended Latin
-                block_filtered = self.latin_extended_regex.findall(block)
-            else:
-                block_filtered = self.latin_extended_regex.findall(block)
-
-            if block_filtered:
-                orig_text_filtered.append(''.join(block_filtered))
-            else:
-                orig_text_filtered.append(None)
-
-        try:
-            if isinstance(last_result, list):
-                last_text = last_result
-            elif last_result and last_result[1] == engine_index:
-                last_text = last_result[0]
-            else:
-                last_text = []
-        except Exception as e:
-            logger.error(f"Error processing last_result {last_result}: {e}")
-            last_text = []
-
-        new_blocks = []
-        for idx, block in enumerate(orig_text):
-            if orig_text_filtered[idx] and (orig_text_filtered[idx] not in last_text):
-                new_blocks.append(
-                    str(block).strip().replace("BLANK_LINE", "\n"))
-
-        final_blocks = []
-        if self.accurate_filtering:
-            detection_results = self.pipe(new_blocks, top_k=3, truncation=True)
-            for idx, block in enumerate(new_blocks):
-                for result in detection_results[idx]:
-                    if result['label'] == lang:
-                        final_blocks.append(block)
-                        break
-        else:
-            for block in new_blocks:
-                # This only filters out NON JA/ZH from text when lang is JA/ZH
-                if lang not in ["ja", "zh"] or self.classify(block)[0] in ['ja', 'zh'] or block == "\n":
-                    final_blocks.append(block)
-
-        text = '\n'.join(final_blocks)
-        return text, orig_text_filtered
-
-
-class ScreenshotThread(threading.Thread):
-    def __init__(self, screen_capture_area, screen_capture_window, ocr_config, screen_capture_on_combo):
-        super().__init__(daemon=True)
-        self.macos_window_tracker_instance = None
-        self.windows_window_tracker_instance = None
-        self.screencapture_window_active = True
-        self.screencapture_window_visible = True
-        self.custom_left = None
-        self.screen_capture_window = screen_capture_window
-        self.areas = []
-        self.use_periodic_queue = not screen_capture_on_combo
-        self.ocr_config = ocr_config
-        if screen_capture_area == '':
-            self.screencapture_mode = 0
-        elif screen_capture_area.startswith('screen_'):
-            parts = screen_capture_area.split('_')
-            if len(parts) != 2 or not parts[1].isdigit():
-                raise ValueError('Invalid screen_capture_area')
-            screen_capture_monitor = int(parts[1])
-            self.screencapture_mode = 1
-        elif len(screen_capture_area.split(',')) == 4:
-            self.screencapture_mode = 3
-        else:
-            self.screencapture_mode = 2
-            self.screen_capture_window = screen_capture_area
-        if self.screen_capture_window:
-            self.screencapture_mode = 2
-
-        if self.screencapture_mode != 2:
-            sct = mss.mss()
-
-            if self.screencapture_mode == 1:
-                mon = sct.monitors
-                if len(mon) <= screen_capture_monitor:
-                    raise ValueError(
-                        'Invalid monitor number in screen_capture_area')
-                coord_left = mon[screen_capture_monitor]['left']
-                coord_top = mon[screen_capture_monitor]['top']
-                coord_width = mon[screen_capture_monitor]['width']
-                coord_height = mon[screen_capture_monitor]['height']
-            elif self.screencapture_mode == 3:
-                coord_left, coord_top, coord_width, coord_height = [
-                    int(c.strip()) for c in screen_capture_area.split(',')]
-            else:
-                logger.opt(ansi=True).info(
-                    'Launching screen coordinate picker')
-                screen_selection = get_screen_selection()
-                if not screen_selection:
-                    raise ValueError(
-                        'Picker window was closed or an error occurred')
-                screen_capture_monitor = screen_selection['monitor']
-                x, y, coord_width, coord_height = screen_selection['coordinates']
-                if coord_width > 0 and coord_height > 0:
-                    coord_top = screen_capture_monitor['top'] + y
-                    coord_left = screen_capture_monitor['left'] + x
-                else:
-                    logger.opt(ansi=True).info(
-                        'Selection is empty, selecting whole screen')
-                    coord_left = screen_capture_monitor['left']
-                    coord_top = screen_capture_monitor['top']
-                    coord_width = screen_capture_monitor['width']
-                    coord_height = screen_capture_monitor['height']
-
-            self.sct_params = {'top': coord_top, 'left': coord_left,
-                               'width': coord_width, 'height': coord_height}
-            logger.opt(ansi=True).info(
-                f'Selected coordinates: {coord_left},{coord_top},{coord_width},{coord_height}')
-        else:
-            if len(screen_capture_area.split(',')) == 4:
-                self.areas.append(([int(c.strip())
-                                  for c in screen_capture_area.split(',')]))
-
-        self.areas.sort(key=lambda rect: (rect[1], rect[0]))
-
-        if self.screencapture_mode == 2 or self.screen_capture_window:
-            area_invalid_error = '"screen_capture_area" must be empty, "screen_N" where N is a screen number starting from 1, a valid set of coordinates, or a valid window name'
-            if sys.platform == 'darwin':
-                if config.get_general('screen_capture_old_macos_api') or int(platform.mac_ver()[0].split('.')[0]) < 14:
-                    self.old_macos_screenshot_api = True
-                else:
-                    self.old_macos_screenshot_api = False
-                    self.screencapturekit_queue = queue.Queue()
-                    CGMainDisplayID()
-                window_list = CGWindowListCopyWindowInfo(
-                    kCGWindowListExcludeDesktopElements, kCGNullWindowID)
-                window_titles = []
-                window_ids = []
-                window_index = None
-                for i, window in enumerate(window_list):
-                    window_title = window.get(kCGWindowName, '')
-                    if psutil.Process(window['kCGWindowOwnerPID']).name() not in ('Terminal', 'iTerm2'):
-                        window_titles.append(window_title)
-                        window_ids.append(window['kCGWindowNumber'])
-
-                if screen_capture_window in window_titles:
-                    window_index = window_titles.index(screen_capture_window)
-                else:
-                    for t in window_titles:
-                        if screen_capture_window in t:
-                            window_index = window_titles.index(t)
-                            break
-
-                if not window_index:
-                    raise ValueError(area_invalid_error)
-
-                self.window_id = window_ids[window_index]
-                window_title = window_titles[window_index]
-
-                if get_ocr_requires_open_window():
-                    self.macos_window_tracker_instance = threading.Thread(
-                        target=self.macos_window_tracker)
-                    self.macos_window_tracker_instance.start()
-                logger.opt(ansi=True).info(f'Selected window: {window_title}')
-            elif sys.platform == 'win32':
-                self.window_handle, window_title = self.get_windows_window_handle(
-                    screen_capture_window)
-
-                if not self.window_handle:
-                    raise ValueError(area_invalid_error)
-
-                set_dpi_awareness()
-
-                self.windows_window_tracker_instance = threading.Thread(
-                    target=self.windows_window_tracker)
-                self.windows_window_tracker_instance.start()
-                logger.opt(ansi=True).info(f'Selected window: {window_title}')
-            else:
-                raise ValueError(
-                    'Window capture is only currently supported on Windows and macOS')
-
-    def get_windows_window_handle(self, window_title):
-        def callback(hwnd, window_title_part):
-            window_title = win32gui.GetWindowText(hwnd)
-            if window_title_part in window_title:
-                handles.append((hwnd, window_title))
-            return True
-
-        handle = win32gui.FindWindow(None, window_title)
-        if handle:
-            return (handle, window_title)
-
-        handles = []
-        win32gui.EnumWindows(callback, window_title)
-        for handle in handles:
-            _, pid = win32process.GetWindowThreadProcessId(handle[0])
-            if psutil.Process(pid).name().lower() not in ('cmd.exe', 'powershell.exe', 'windowsterminal.exe'):
-                return handle
-
-        return (None, None)
-
-    def windows_window_tracker(self):
-        found = True
-        while not terminated:
-            found = win32gui.IsWindow(self.window_handle)
-            if not found:
-                break
-            if get_ocr_requires_open_window():
-                self.screencapture_window_active = self.window_handle == win32gui.GetForegroundWindow()
-            else:
-                self.screencapture_window_visible = not win32gui.IsIconic(
-                    self.window_handle)
-            time.sleep(0.2)
-        if not found:
-            on_window_closed(False)
-
-    def capture_macos_window_screenshot(self, window_id):
-        def shareable_content_completion_handler(shareable_content, error):
-            if error:
-                self.screencapturekit_queue.put(None)
-                return
-
-            target_window = None
-            for window in shareable_content.windows():
-                if window.windowID() == window_id:
-                    target_window = window
-                    break
-
-            if not target_window:
-                self.screencapturekit_queue.put(None)
-                return
-
-            with objc.autorelease_pool():
-                content_filter = SCContentFilter.alloc(
-                ).initWithDesktopIndependentWindow_(target_window)
-
-                frame = content_filter.contentRect()
-                scale = content_filter.pointPixelScale()
-                width = frame.size.width * scale
-                height = frame.size.height * scale
-                configuration = SCStreamConfiguration.alloc().init()
-                configuration.setSourceRect_(CGRectMake(
-                    0, 0, frame.size.width, frame.size.height))
-                configuration.setWidth_(width)
-                configuration.setHeight_(height)
-                configuration.setShowsCursor_(False)
-                configuration.setCaptureResolution_(SCCaptureResolutionBest)
-                configuration.setIgnoreGlobalClipSingleWindow_(True)
-
-                SCScreenshotManager.captureImageWithFilter_configuration_completionHandler_(
-                    content_filter, configuration, capture_image_completion_handler
-                )
-
-        def capture_image_completion_handler(image, error):
-            if error:
-                self.screencapturekit_queue.put(None)
-                return
-
-            self.screencapturekit_queue.put(image)
-
-        SCShareableContent.getShareableContentWithCompletionHandler_(
-            shareable_content_completion_handler
-        )
-
-    def macos_window_tracker(self):
-        found = True
-        while found and not terminated:
-            found = False
-            is_active = False
-            with objc.autorelease_pool():
-                window_list = CGWindowListCopyWindowInfo(
-                    kCGWindowListOptionOnScreenOnly, kCGNullWindowID)
-                for i, window in enumerate(window_list):
-                    if found and window.get(kCGWindowName, '') == 'Fullscreen Backdrop':
-                        is_active = True
-                        break
-                    if self.window_id == window['kCGWindowNumber']:
-                        found = True
-                        if i == 0 or window_list[i-1].get(kCGWindowName, '') in ('Dock', 'Color Enforcer Window'):
-                            is_active = True
-                            break
-                if not found:
-                    window_list = CGWindowListCreateDescriptionFromArray(
-                        [self.window_id])
-                    if len(window_list) > 0:
-                        found = True
-            if found:
-                self.screencapture_window_active = is_active
-            time.sleep(0.2)
-        if not found:
-            on_window_closed(False)
-
-    def write_result(self, result):
-        if self.use_periodic_queue:
-            periodic_screenshot_queue.put(result)
-        else:
-            image_queue.put((result, True))
-
-    def run(self):
-        if self.screencapture_mode != 2:
-            sct = mss.mss()
-        start = time.time()
-        while not terminated:
-            if time.time() - start > 1:
-                start = time.time()
-                section_changed = has_ocr_config_changed()
-                if section_changed:
-                    reload_electron_config()
-
-            if not screenshot_event.wait(timeout=0.1):
-                continue
-            if self.screencapture_mode == 2 or self.screen_capture_window:
-                if sys.platform == 'darwin':
-                    with objc.autorelease_pool():
-                        if self.old_macos_screenshot_api:
-                            cg_image = CGWindowListCreateImageFromArray(CGRectNull, [self.window_id],
-                                                                        kCGWindowImageBoundsIgnoreFraming)
-                        else:
-                            self.capture_macos_window_screenshot(
-                                self.window_id)
-                            try:
-                                cg_image = self.screencapturekit_queue.get(
-                                    timeout=0.5)
-                            except queue.Empty:
-                                cg_image = None
-                        if not cg_image:
-                            return 0
-                        width = CGImageGetWidth(cg_image)
-                        height = CGImageGetHeight(cg_image)
-                        raw_data = CGDataProviderCopyData(
-                            CGImageGetDataProvider(cg_image))
-                        bpr = CGImageGetBytesPerRow(cg_image)
-                    img = Image.frombuffer(
-                        'RGBA', (width, height), raw_data, 'raw', 'BGRA', bpr, 1)
-                else:
-                    try:
-                        coord_left, coord_top, right, bottom = win32gui.GetWindowRect(
-                            self.window_handle)
-                        coord_width = right - coord_left
-                        coord_height = bottom - coord_top
-
-                        hwnd_dc = win32gui.GetWindowDC(self.window_handle)
-                        mfc_dc = win32ui.CreateDCFromHandle(hwnd_dc)
-                        save_dc = mfc_dc.CreateCompatibleDC()
-
-                        save_bitmap = win32ui.CreateBitmap()
-                        save_bitmap.CreateCompatibleBitmap(
-                            mfc_dc, coord_width, coord_height)
-                        save_dc.SelectObject(save_bitmap)
-
-                        result = ctypes.windll.user32.PrintWindow(
-                            self.window_handle, save_dc.GetSafeHdc(), 2)
-
-                        bmpinfo = save_bitmap.GetInfo()
-                        bmpstr = save_bitmap.GetBitmapBits(True)
-                    except pywintypes.error:
-                        return 0
-                    img = Image.frombuffer('RGB', (bmpinfo['bmWidth'], bmpinfo['bmHeight']), bmpstr, 'raw', 'BGRX', 0,
-                                           1)
-                    try:
-                        win32gui.DeleteObject(save_bitmap.GetHandle())
-                    except:
-                        pass
-                    try:
-                        save_dc.DeleteDC()
-                    except:
-                        pass
-                    try:
-                        mfc_dc.DeleteDC()
-                    except:
-                        pass
-                    try:
-                        win32gui.ReleaseDC(self.window_handle, hwnd_dc)
-                    except:
-                        pass
-            else:
-                sct_img = sct.grab(self.sct_params)
-                img = Image.frombytes(
-                    'RGB', sct_img.size, sct_img.bgra, 'raw', 'BGRX')
-
-            if not img.getbbox():
-                logger.info(
-                    "Screen Capture Didn't get Capturing anything, sleeping.")
-                time.sleep(1)
-                continue
-
-            import random  # Ensure this is imported at the top of the file if not already
-            # Executes only once out of 10 times
-            rand_int = random.randint(1, 20)
-
-            if rand_int == 1:  # Executes only once out of 10 times
-                img.save(os.path.join(get_temporary_directory(),
-                         'before_crop.png'), 'PNG')
-
-            img = apply_ocr_config_to_image(img, self.ocr_config)
-
-            if rand_int == 1:
-                img.save(os.path.join(
-                    get_temporary_directory(), 'after_crop.png'), 'PNG')
-
-            if last_image and are_images_identical(img, last_image):
-                logger.debug(
-                    "Captured screenshot is identical to the last one, sleeping.")
-                time.sleep(max(.5, get_ocr_scan_rate()))
-            else:
-                self.write_result(img)
-                screenshot_event.clear()
-
-        if self.macos_window_tracker_instance:
-            self.macos_window_tracker_instance.join()
-        elif self.windows_window_tracker_instance:
-            self.windows_window_tracker_instance.join()
-
-
-import cv2
-import numpy as np
-    
-def apply_adaptive_threshold_filter(img):
-    img = cv2.cvtColor(np.array(img), cv2.COLOR_RGB2BGR)
-    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
-    inverted = cv2.bitwise_not(gray)
-    blur = cv2.GaussianBlur(inverted, (3, 3), 0)
-    thresh = cv2.adaptiveThreshold(
-        blur, 255, 
-        cv2.ADAPTIVE_THRESH_GAUSSIAN_C, 
-        cv2.THRESH_BINARY, 
-        11, 2
-    )
-    result = cv2.bitwise_not(thresh)
-
-    return Image.fromarray(result)
-
-
-def set_last_image(image):
-    global last_image
-    if image is None:
-        last_image = None
-    try:
-        if image == last_image:
-            return
-    except Exception:
-        last_image = None
-        return
-    try:
-        if last_image is not None and hasattr(last_image, "close"):
-            last_image.close()
-    except Exception:
-        pass
-    # last_image = image
-    last_image = apply_adaptive_threshold_filter(image)
-
-
-def are_images_identical(img1, img2):
-    if None in (img1, img2):
-        return False
-
-    try:
-        img1 = np.array(img1)
-        img2 = np.array(img2)
-    except Exception:
-        logger.warning(
-            "Failed to convert images to numpy arrays for comparison.")
-        # If conversion to numpy array fails, consider them not identical
-        return False
-
-    return (img1.shape == img2.shape) and np.array_equal(img1, img2)
-
-
-import cv2
-import numpy as np
-from skimage.metrics import structural_similarity as ssim
-from typing import Union
-
-ImageType = Union[np.ndarray, Image.Image]
-
-def _prepare_image(image: ImageType) -> np.ndarray:
-    """
-    Standardizes an image (PIL or NumPy) into an OpenCV-compatible NumPy array (BGR).
-    """
-    # If the image is a PIL Image, convert it to a NumPy array
-    if isinstance(image, Image.Image):
-        # Convert PIL Image (which is RGB) to a NumPy array, then convert RGB to BGR for OpenCV
-        prepared_image = cv2.cvtColor(np.array(image), cv2.COLOR_RGB2BGR)
-    # If it's already a NumPy array, assume it's in a compatible format (like BGR)
-    elif isinstance(image, np.ndarray):
-        prepared_image = image
-    else:
-        raise TypeError(f"Unsupported image type: {type(image)}. Must be a PIL Image or NumPy array.")
-
-    return prepared_image
-
-i = 1
-
-def calculate_ssim_score(imageA: ImageType, imageB: ImageType) -> float:
-    global i
-    """
-    Calculates the structural similarity index (SSIM) between two images.
-
-    Args:
-        imageA: The first image as a NumPy array.
-        imageB: The second image as a NumPy array.
-
-    Returns:
-        The SSIM score between the two images (between -1 and 1).
-    """
-    
-    if isinstance(imageA, Image.Image):
-        imageA = apply_adaptive_threshold_filter(imageA)
-        
-    # Save Images to temp for debugging on a random 1/20 chance
-    # if np.random.rand() < 0.05:
-    # if i < 600:
-    #     # Save as image_000
-    #     imageA.save(os.path.join(get_temporary_directory(), f'frame_{i:03d}.png'), 'PNG')
-    #     i += 1
-        # imageB.save(os.path.join(get_temporary_directory(), f'ssim_imageB_{i:03d}.png'), 'PNG')
-
-    imageA = _prepare_image(imageA)
-    imageB = _prepare_image(imageB)
-
-    # Images must have the same dimensions
-    if imageA.shape != imageB.shape:
-        raise ValueError("Input images must have the same dimensions.")
-
-    # Convert images to grayscale for a more robust SSIM comparison
-    # This is less sensitive to minor color changes and lighting.
-    # grayA = cv2.cvtColor(imageA, cv2.COLOR_BGR2GRAY)
-    # grayB = cv2.cvtColor(imageB, cv2.COLOR_BGR2GRAY)
-
-    # Calculate the SSIM. The `score` is the main value.
-    # The `win_size` parameter must be an odd number and less than the image dimensions.
-    # We choose a value that is likely to be safe for a variety of image sizes.
-    win_size = min(3, imageA.shape[0] // 2, imageA.shape[1] // 2)
-    if win_size % 2 == 0:
-        win_size -= 1 # ensure it's odd
-
-    score, _ = ssim(imageA, imageB, full=True, win_size=win_size)
-
-    return score
-
-
-
-def are_images_similar(imageA: Image.Image, imageB: Image.Image, threshold: float = 0.98) -> bool:
-    """
-    Compares two images and returns True if their similarity score is above a threshold.
-
-    Args:
-        imageA: The first image as a NumPy array.
-        imageB: The second image as a NumPy array.
-        threshold: The minimum SSIM score to be considered "similar".
-                   Defaults to 0.98 (very high similarity). Your original `90` would
-                   be equivalent to a threshold of `0.90` here.
-
-    Returns:
-        True if the images are similar, False otherwise.
-    """
-    if None in (imageA, imageB):
-        logger.info("One of the images is None, cannot compare.")
-        return False
-    try:
-        score = calculate_ssim_score(imageA, imageB)
-    except Exception as e:
-        logger.info(e)
-        return False
-    return score > threshold
-
-
-def quick_text_detection(pil_image, threshold_ratio=0.01):
-    """
-    Quick check if image likely contains text using edge detection.
-    
-    Args:
-        pil_image (PIL.Image): Input image
-        threshold_ratio (float): Minimum ratio of edge pixels to consider text present
-    
-    Returns:
-        bool: True if text is likely present
-    """
-    # Convert to grayscale
-    gray = np.array(pil_image.convert('L'))
-    
-    # Apply Canny edge detection
-    edges = cv2.Canny(gray, 50, 150)
-    
-    # Calculate ratio of edge pixels
-    edge_ratio = np.sum(edges > 0) / edges.size
-    
-    return edge_ratio > threshold_ratio
-
-
-# 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.websocket = None
-        self.current_source = None
-        self.current_source_name = None
-        self.current_scene = 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))
-        screenshot_event.clear()
-
-    def connect_obs(self):
-        import GameSentenceMiner.obs as obs
-        obs.connect_to_obs_sync()
-
-    def scale_down_width_height(self, width, height):
-        if width == 0 or height == 0:
-            return self.width, self.height
-        # return width, height
-        aspect_ratio = width / height
-        logger.info(
-            f"Scaling down OBS source dimensions: {width}x{height} (Aspect Ratio: {aspect_ratio})")
-        if aspect_ratio > 2.66:
-            # Ultra-wide (32:9) - use 1920x540
-            logger.info("Using ultra-wide aspect ratio scaling (32:9).")
-            return 1920, 540
-        elif aspect_ratio > 2.33:
-            # 21:9 - use 1920x800
-            logger.info("Using ultra-wide aspect ratio scaling (21:9).")
-            return 1920, 800
-        elif aspect_ratio > 1.77:
-            # 16:9 - use 1280x720
-            logger.info("Using standard aspect ratio scaling (16:9).")
-            return 1280, 720
-        elif aspect_ratio > 1.6:
-            # 16:10 - use 1280x800
-            logger.info("Using standard aspect ratio scaling (16:10).")
-            return 1280, 800
-        elif aspect_ratio > 1.33:
-            # 4:3 - use 960x720
-            logger.info("Using standard aspect ratio scaling (4:3).")
-            return 960, 720
-        elif aspect_ratio > 1.25:
-            # 5:4 - use 900x720
-            logger.info("Using standard aspect ratio scaling (5:4).")
-            return 900, 720
-        elif aspect_ratio > 1.5:
-            # 3:2 - use 1080x720
-            logger.info("Using standard aspect ratio scaling (3:2).")
-            return 1080, 720
-        else:
-            # Default fallback - use original resolution
-            logger.info(
-                "Using default aspect ratio scaling (original resolution).")
-            return width, height
-        
-    def init_config(self, source=None, scene=None):
-        import GameSentenceMiner.obs as obs
-        obs.update_current_game()
-        self.current_source = source if source else obs.get_active_source()
-        logger.info(f"Current OBS source: {self.current_source}")
-        self.source_width = self.current_source.get(
-            "sceneItemTransform").get("sourceWidth") or self.width
-        self.source_height = self.current_source.get(
-            "sceneItemTransform").get("sourceHeight") or self.height
-        if self.source_width and self.source_height:
-            self.width, self.height = self.scale_down_width_height(
-                self.source_width, self.source_height)
-            logger.info(
-                f"Using OBS source dimensions: {self.width}x{self.height}")
-        self.current_source_name = self.current_source.get(
-            "sourceName") or None
-        self.current_scene = scene if scene else obs.get_current_game()
-        self.ocr_config = get_scene_ocr_config(refresh=True)
-        if not self.ocr_config:
-            logger.error("No OCR config found for the current scene.")
-            return
-        self.ocr_config.scale_to_custom_size(self.width, self.height)
-
-    def run(self):
-        global last_image
-        from PIL import Image
-        import GameSentenceMiner.obs as obs
-
-        # Register a scene switch callback in obsws
-        def on_scene_switch(scene):
-            logger.info(f"Scene switched to: {scene}. Loading new OCR config.")
-            self.init_config(scene=scene)
-
-        asyncio.run(obs.register_scene_change_callback(on_scene_switch))
-
-        self.connect_obs()
-        self.init_config()
-        while not terminated:
-            if not screenshot_event.wait(timeout=0.1):
-                continue
-
-            if not self.ocr_config:
-                logger.info(
-                    "No OCR config found for the current scene. Waiting for scene switch.")
-                time.sleep(1)
-                continue
-
-            if not self.current_source_name:
-                obs.update_current_game()
-                self.current_source = obs.get_active_source()
-                self.current_source_name = self.current_source.get(
-                    "sourceName") or None
-
-            try:
-                if not self.current_source_name:
-                    logger.error(
-                        "No active source found in the current scene.")
-                    self.write_result(1)
-                    continue
-                img = obs.get_screenshot_PIL(source_name=self.current_source_name,
-                                             width=self.width, height=self.height, img_format='jpg', compression=80)
-                
-                img = apply_ocr_config_to_image(img, self.ocr_config)
-
-                if img is not None:
-                    self.write_result(img)
-                else:
-                    logger.error("Failed to get screenshot data from OBS.")
-
-            except Exception as e:
-                print(e)
-                logger.info(
-                    f"An unexpected error occurred during OBS Capture : {e}", exc_info=True)
-                continue
-
-
-def apply_ocr_config_to_image(img, ocr_config, is_secondary=False):
-    for rectangle in 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))
-            
-    rectangles = [r for r in ocr_config.rectangles if not r.is_excluded and r.is_secondary == is_secondary]
-    
-    # Sort top to bottom
-    if rectangles:
-        rectangles.sort(key=lambda r: r.coordinates[1])
-
-    cropped_sections = []
-    for rectangle in rectangles:
-        area = rectangle.coordinates
-        # Ensure crop coordinates are within image bounds
-        left = max(0, area[0])
-        top = max(0, area[1])
-        right = min(img.width, area[0] + area[2])
-        bottom = min(img.height, area[1] + area[3])
-        crop = img.crop((left, top, right, bottom))
-        cropped_sections.append(crop)
-
-    if len(cropped_sections) > 1:
-        # Width is the max width of all sections, height is the sum of all sections + gaps
-        # Gaps are 50 pixels between sections
-        combined_width = max(section.width for section in cropped_sections)
-        combined_height = sum(section.height for section in cropped_sections) + (
-            len(cropped_sections) - 1) * 50
-        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]
-    return img
-
-
-class AutopauseTimer:
-    def __init__(self, timeout):
-        self.stop_event = threading.Event()
-        self.timeout = timeout
-        self.timer_thread = None
-
-    def __del__(self):
-        self.stop()
-
-    def start(self):
-        self.stop()
-        self.stop_event.clear()
-        self.timer_thread = threading.Thread(target=self._countdown)
-        self.timer_thread.start()
-
-    def stop(self):
-        if not self.stop_event.is_set() and self.timer_thread and self.timer_thread.is_alive():
-            self.stop_event.set()
-            self.timer_thread.join()
-
-    def _countdown(self):
-        seconds = self.timeout
-        while seconds > 0 and not self.stop_event.is_set() and not terminated:
-            time.sleep(1)
-            seconds -= 1
-        if not self.stop_event.is_set():
-            self.stop_event.set()
-            if not (paused or terminated):
-                pause_handler(True)
-
-
-def pause_handler(is_combo=True):
-    global paused
-    message = 'Unpaused!' if paused else 'Paused!'
-
-    if auto_pause_handler:
-        auto_pause_handler.stop()
-    if is_combo:
-        notifier.send(title='owocr', message=message)
-    logger.info(message)
-    paused = not paused
-
-
-def engine_change_handler(user_input='s', is_combo=True):
-    global engine_index
-    old_engine_index = engine_index
-
-    if user_input.lower() == 's':
-        if engine_index == len(engine_keys) - 1:
-            engine_index = 0
-        else:
-            engine_index += 1
-    elif user_input.lower() != '' and user_input.lower() in engine_keys:
-        engine_index = engine_keys.index(user_input.lower())
-    if engine_index != old_engine_index:
-        new_engine_name = engine_instances[engine_index].readable_name
-        if is_combo:
-            notifier.send(
-                title='owocr', message=f'Switched to {new_engine_name}')
-        engine_color = config.get_general('engine_color')
-        logger.opt(ansi=True).info(
-            f'Switched to <{engine_color}>{new_engine_name}</{engine_color}>!')
-
-
-def engine_change_handler_name(engine):
-    global engine_index
-    old_engine_index = engine_index
-
-    for i, instance in enumerate(engine_instances):
-        if instance.name.lower() in engine.lower():
-            engine_index = i
-            break
-
-    if engine_index != old_engine_index:
-        new_engine_name = engine_instances[engine_index].readable_name
-        notifier.send(title='owocr', message=f'Switched to {new_engine_name}')
-        engine_color = config.get_general('engine_color')
-        logger.opt(ansi=True).info(
-            f'Switched to <{engine_color}>{new_engine_name}</{engine_color}>!')
-
-
-def user_input_thread_run():
-    def _terminate_handler():
-        global terminated
-        logger.info('Terminated!')
-        terminated = True
-    import sys
-
-    if sys.platform == 'win32':
-        import msvcrt
-        while not terminated:
-            user_input = None
-            if msvcrt.kbhit():  # Check if a key is pressed
-                user_input_bytes = msvcrt.getch()
-                try:
-                    user_input = user_input_bytes.decode()
-                except UnicodeDecodeError:
-                    pass
-            if not user_input:  # If no input from msvcrt, check stdin
-                import sys
-                user_input = sys.stdin.read(1)
-
-                if user_input.lower() in 'tq':
-                    _terminate_handler()
-                elif user_input.lower() == 'p':
-                    pause_handler(False)
-                else:
-                    engine_change_handler(user_input, False)
-    else:
-        import tty
-        import termios
-        fd = sys.stdin.fileno()
-        old_settings = termios.tcgetattr(fd)
-        try:
-            tty.setcbreak(sys.stdin.fileno())
-            while not terminated:
-                user_input = sys.stdin.read(1)
-                if user_input.lower() in 'tq':
-                    _terminate_handler()
-                elif user_input.lower() == 'p':
-                    pause_handler(False)
-                else:
-                    engine_change_handler(user_input, False)
-        finally:
-            termios.tcsetattr(fd, termios.TCSADRAIN, old_settings)
-
-
-def signal_handler(sig, frame):
-    global terminated
-    logger.info('Terminated!')
-    terminated = True
-
-
-def on_window_closed(alive):
-    global terminated
-    if not (alive or terminated):
-        logger.info('Window closed or error occurred, terminated!')
-        terminated = True
-
-
-def on_screenshot_combo():
-    if not paused:
-        screenshot_event.set()
-
-
-def on_window_minimized(minimized):
-    global screencapture_window_visible
-    screencapture_window_visible = not minimized
-
-
-def process_and_write_results(img_or_path, write_to=None, last_result=None, filtering=None, notify=None, engine=None, ocr_start_time=None, furigana_filter_sensitivity=0):
-    global engine_index
-    if auto_pause_handler:
-        auto_pause_handler.stop()
-    if engine:
-        for i, instance in enumerate(engine_instances):
-            if instance.name.lower() in engine.lower():
-                engine_instance = instance
-                break
-    else:
-        engine_instance = engine_instances[engine_index]
-
-    engine_color = config.get_general('engine_color')
-
-    start_time = time.time()
-    result = engine_instance(img_or_path, furigana_filter_sensitivity)
-    res, text, crop_coords = (*result, None)[:3]
-
-    if not res and ocr_2 == engine:
-        logger.opt(ansi=True).info(
-            f"<{engine_color}>{engine_instance.readable_name}</{engine_color}> failed with message: {text}, trying <{engine_color}>{ocr_1}</{engine_color}>")
-        for i, instance in enumerate(engine_instances):
-            if instance.name.lower() in ocr_1.lower():
-                engine_instance = instance
-                if last_result:
-                    last_result = []
-                break
-        start_time = time.time()
-        result = engine_instance(img_or_path, furigana_filter_sensitivity)
-        res, text, crop_coords = (*result, None)[:3]
-
-    end_time = time.time()
-
-    orig_text = []
-    # print(filtering)
-    #
-    #
-    # print(lang)
-
-    # print(last_result)
-    # print(engine_index)
-
-    if res:
-        if filtering:
-            text, orig_text = filtering(text, last_result)
-        if get_ocr_language() == "ja" or get_ocr_language() == "zh":
-            text = post_process(text, keep_blank_lines=get_ocr_keep_newline())
-        logger.opt(ansi=True).info(
-            f'Text recognized in {end_time - start_time:0.03f}s using <{engine_color}>{engine_instance.readable_name}</{engine_color}>: {text}')
-        if notify and config.get_general('notifications'):
-            notifier.send(title='owocr', message='Text recognized: ' + text)
-
-        if write_to == 'websocket':
-            websocket_server_thread.send_text(text)
-        elif write_to == 'clipboard':
-            pyperclipfix.copy(text)
-        elif write_to == "callback":
-            txt_callback(text, orig_text, ocr_start_time,
-                         img_or_path, bool(engine), filtering, crop_coords)
-        elif write_to:
-            with Path(write_to).open('a', encoding='utf-8') as f:
-                f.write(text + '\n')
-
-        if auto_pause_handler and not paused:
-            auto_pause_handler.start()
-    else:
-        logger.opt(ansi=True).info(
-            f'<{engine_color}>{engine_instance.readable_name}</{engine_color}> reported an error after {end_time - start_time:0.03f}s: {text}')
-
-    # print(orig_text)
-    # print(text)
-
-    return orig_text, text
-
-
-def get_path_key(path):
-    return path, path.lstat().st_mtime
-
-
-def init_config(parse_args=True):
-    global config
-    config = Config(parse_args)
-
-
-def run(read_from=None,
-        read_from_secondary=None,
-        write_to=None,
-        engine=None,
-        pause_at_startup=None,
-        ignore_flag=None,
-        delete_images=None,
-        notifications=None,
-        auto_pause=0,
-        combo_pause=None,
-        combo_engine_switch=None,
-        screen_capture_area=None,
-        screen_capture_areas=None,
-        screen_capture_exclusions=None,
-        screen_capture_window=None,
-        screen_capture_delay_secs=None,
-        screen_capture_combo=None,
-        stop_running_flag=None,
-        screen_capture_event_bus=None,
-        text_callback=None,
-        monitor_index=None,
-        ocr1=None,
-        ocr2=None,
-        gsm_ocr_config=None,
-        furigana_filter_sensitivity=None,
-        config_check_thread=None
-        ):
-    """
-    Japanese OCR client
-
-    Runs OCR in the background.
-    It can read images copied to the system clipboard or placed in a directory, images sent via a websocket or a Unix domain socket, or directly capture a screen (or a portion of it) or a window.
-    Recognized texts can be either saved to system clipboard, appended to a text file or sent via a websocket.
-
-    :param read_from: Specifies where to read input images from. Can be either "clipboard", "websocket", "unixsocket" (on macOS/Linux), "screencapture", or a path to a directory.
-    :param write_to: Specifies where to save recognized texts to. Can be either "clipboard", "websocket", or a path to a text file.
-    :param delay_secs: How often to check for new images, in seconds.
-    :param engine: OCR engine to use. Available: "mangaocr", "glens", "glensweb", "bing", "gvision", "avision", "alivetext", "azure", "winrtocr", "oneocr", "easyocr", "rapidocr", "ocrspace".
-    :param pause_at_startup: Pause at startup.
-    :param ignore_flag: Process flagged clipboard images (images that are copied to the clipboard with the *ocr_ignore* string).
-    :param delete_images: Delete image files after processing when reading from a directory.
-    :param notifications: Show an operating system notification with the detected text.
-    :param auto_pause: Automatically pause the program after the specified amount of seconds since the last successful text recognition. Will be ignored when reading with screen capture. 0 to disable.
-    :param combo_pause: Specifies a combo to wait on for pausing the program. As an example: "<ctrl>+<shift>+p". The list of keys can be found here: https://pynput.readthedocs.io/en/latest/keyboard.html#pynput.keyboard.Key
-    :param combo_engine_switch: Specifies a combo to wait on for switching the OCR engine. As an example: "<ctrl>+<shift>+a". To be used with combo_pause. The list of keys can be found here: https://pynput.readthedocs.io/en/latest/keyboard.html#pynput.keyboard.Key
-    :param screen_capture_area: Specifies area to target when reading with screen capture. Can be either empty (automatic selector), a set of coordinates (x,y,width,height), "screen_N" (captures a whole screen, where N is the screen number starting from 1) or a window name (the first matching window title will be used).
-    :param screen_capture_delay_secs: Specifies the delay (in seconds) between screenshots when reading with screen capture.
-    :param screen_capture_only_active_windows: When reading with screen capture and screen_capture_area is a window name, specifies whether to only target the window while it's active.
-    :param screen_capture_combo: When reading with screen capture, specifies a combo to wait on for taking a screenshot instead of using the delay. As an example: "<ctrl>+<shift>+s". The list of keys can be found here: https://pynput.readthedocs.io/en/latest/keyboard.html#pynput.keyboard.Key
-    """
-
-    if read_from is None:
-        read_from = config.get_general('read_from')
-
-    if read_from_secondary is None:
-        read_from_secondary = config.get_general('read_from_secondary')
-
-    if screen_capture_area is None:
-        screen_capture_area = config.get_general('screen_capture_area')
-
-    # if screen_capture_only_active_windows is None:
-    #     screen_capture_only_active_windows = config.get_general('screen_capture_only_active_windows')
-
-    if screen_capture_exclusions is None:
-        screen_capture_exclusions = config.get_general(
-            'screen_capture_exclusions')
-
-    if screen_capture_window is None:
-        screen_capture_window = config.get_general('screen_capture_window')
-
-    if screen_capture_delay_secs is None:
-        screen_capture_delay_secs = config.get_general(
-            'screen_capture_delay_secs')
-
-    if screen_capture_combo is None:
-        screen_capture_combo = config.get_general('screen_capture_combo')
-
-    if stop_running_flag is None:
-        stop_running_flag = config.get_general('stop_running_flag')
-
-    if screen_capture_event_bus is None:
-        screen_capture_event_bus = config.get_general(
-            'screen_capture_event_bus')
-
-    if text_callback is None:
-        text_callback = config.get_general('text_callback')
-
-    if write_to is None:
-        write_to = config.get_general('write_to')
-
-    logger.configure(
-        handlers=[{'sink': sys.stderr, 'format': config.get_general('logger_format')}])
-
-    if config.has_config:
-        logger.info('Parsed config file')
-    else:
-        logger.warning('No config file, defaults will be used.')
-        if config.downloaded_config:
-            logger.info(
-                f'A default config file has been downloaded to {config.config_path}')
-
-    global engine_instances
-    global engine_keys
-    engine_instances = []
-    config_engines = []
-    engine_keys = []
-    default_engine = ''
-
-    if len(config.get_general('engines')) > 0:
-        for config_engine in config.get_general('engines').split(','):
-            config_engines.append(config_engine.strip().lower())
-
-    for _, engine_class in sorted(inspect.getmembers(sys.modules[__name__],
-                                                     lambda x: hasattr(x, '__module__') and x.__module__ and (
-        __package__ + '.ocr' in x.__module__ or __package__ + '.secret' in x.__module__) and inspect.isclass(
-                                                         x))):
-        if len(config_engines) == 0 or engine_class.name in config_engines:
-            if config.get_engine(engine_class.name) == None:
-                engine_instance = engine_class()
-            else:
-                engine_instance = engine_class(config.get_engine(
-                    engine_class.name), lang=get_ocr_language())
-
-            if engine_instance.available:
-                engine_instances.append(engine_instance)
-                engine_keys.append(engine_class.key)
-                if engine == engine_class.name:
-                    default_engine = engine_class.key
-
-    if len(engine_keys) == 0:
-        msg = 'No engines available!'
-        raise NotImplementedError(msg)
-
-    global engine_index
-    global terminated
-    global paused
-    global just_unpaused
-    global first_pressed
-    global auto_pause_handler
-    global notifier
-    global websocket_server_thread
-    global screenshot_thread
-    global obs_screenshot_thread
-    global image_queue
-    global ocr_1
-    global ocr_2
-    ocr_1 = ocr1
-    ocr_2 = ocr2
-    custom_left = None
-    terminated = False
-    paused = pause_at_startup
-    just_unpaused = True
-    first_pressed = None
-    auto_pause_handler = None
-    engine_index = engine_keys.index(
-        default_engine) if default_engine != '' else 0
-    engine_color = config.get_general('engine_color')
-    prefix_to_use = ""
-    delay_secs = config.get_general('delay_secs')
-
-    non_path_inputs = ('screencapture', 'clipboard',
-                       'websocket', 'unixsocket', 'obs')
-    read_from_path = None
-    read_from_readable = []
-    terminated = False
-    paused = config.get_general('pause_at_startup')
-    auto_pause = config.get_general('auto_pause')
-    clipboard_thread = None
-    websocket_server_thread = None
-    screenshot_thread = None
-    directory_watcher_thread = None
-    unix_socket_server = None
-    key_combo_listener = None
-    filtering = None
-    auto_pause_handler = None
-    engine_index = engine_keys.index(
-        default_engine) if default_engine != '' else 0
-    engine_color = config.get_general('engine_color')
-    combo_pause = config.get_general('combo_pause')
-    combo_engine_switch = config.get_general('combo_engine_switch')
-    screen_capture_on_combo = False
-    notifier = DesktopNotifierSync()
-    image_queue = queue.Queue()
-    key_combos = {}
-
-    if combo_pause != '':
-        key_combos[combo_pause] = pause_handler
-    if combo_engine_switch:
-        if combo_pause:
-            key_combos[combo_engine_switch] = engine_change_handler
-        else:
-            raise ValueError('combo_pause must also be specified')
-
-    if 'websocket' in (read_from, read_from_secondary) or write_to == 'websocket':
-        websocket_server_thread = WebsocketServerThread(
-            'websocket' in (read_from, read_from_secondary))
-        websocket_server_thread.start()
-
-    if write_to == "callback" and text_callback:
-        global txt_callback
-        txt_callback = text_callback
-
-    if any(x in ('screencapture', 'obs') for x in (read_from, read_from_secondary)):
-        global screenshot_event
-        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,
-                                                gsm_ocr_config, 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):
-        if sys.platform == 'win32':
-            raise ValueError(
-                '"unixsocket" is not currently supported on Windows')
-        socket_path = Path('/tmp/owocr.sock')
-        if socket_path.exists():
-            socket_path.unlink()
-        unix_socket_server = socketserver.ThreadingUnixStreamServer(
-            str(socket_path), RequestHandler)
-        unix_socket_server_thread = threading.Thread(
-            target=unix_socket_server.serve_forever, daemon=True)
-        unix_socket_server_thread.start()
-        read_from_readable.append('unix socket')
-    if 'clipboard' in (read_from, read_from_secondary):
-        clipboard_thread = ClipboardThread()
-        clipboard_thread.start()
-        read_from_readable.append('clipboard')
-    if any(i and i not in non_path_inputs for i in (read_from, read_from_secondary)):
-        if all(i and i not in non_path_inputs for i in (read_from, read_from_secondary)):
-            raise ValueError(
-                "read_from and read_from_secondary can't both be directory paths")
-        delete_images = config.get_general('delete_images')
-        read_from_path = Path(read_from) if read_from not in non_path_inputs else Path(
-            read_from_secondary)
-        if not read_from_path.is_dir():
-            raise ValueError(
-                'read_from and read_from_secondary must be either "websocket", "unixsocket", "clipboard", "screencapture", or a path to a directory')
-        directory_watcher_thread = DirectoryWatcher(read_from_path)
-        directory_watcher_thread.start()
-        read_from_readable.append(f'directory {read_from_path}')
-
-    if len(key_combos) > 0:
-        try:
-            from pynput import keyboard
-            key_combo_listener = keyboard.GlobalHotKeys(key_combos)
-            key_combo_listener.start()
-        except ImportError:
-            pass
-
-    if write_to in ('clipboard', 'websocket', 'callback'):
-        write_to_readable = write_to
-    else:
-        if Path(write_to).suffix.lower() != '.txt':
-            raise ValueError(
-                'write_to must be either "websocket", "clipboard" or a path to a text file')
-        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 = 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:
-        auto_pause_handler = AutopauseTimer(auto_pause)
-    user_input_thread = threading.Thread(
-        target=user_input_thread_run, daemon=True)
-    user_input_thread.start()
-    logger.opt(ansi=True).info(
-        f"Reading from {' and '.join(read_from_readable)}, writing to {write_to_readable} using <{engine_color}>{engine_instances[engine_index].readable_name}</{engine_color}>{' (paused)' if paused else ''}")
-    if screen_capture_combo:
-        logger.opt(ansi=True).info(
-            f'Manual OCR Running... Press <{engine_color}>{screen_capture_combo.replace("<", "").replace(">", "")}</{engine_color}> to run OCR')
-
-    def handle_config_changes(changes):
-        nonlocal last_result
-        if any(c in changes for c in ('ocr1', 'ocr2', 'language', 'furigana_filter_sensitivity')):
-            last_result = ([], engine_index)
-            engine_change_handler_name(get_ocr_ocr1())
-            
-    def handle_area_config_changes(changes):
-        if screenshot_thread:
-            screenshot_thread.ocr_config = get_scene_ocr_config()
-        if obs_screenshot_thread:
-            obs_screenshot_thread.init_config()
-                
-    config_check_thread.add_config_callback(handle_config_changes)
-    config_check_thread.add_area_callback(handle_area_config_changes)
-    previous_text = "Placeholder"
-    sleep_time_to_add = 0
-    last_result_time = time.time()
-    while not terminated:
-        ocr_start_time = datetime.now()
-        start_time = time.time()
-        img = None
-        filter_img = False
-
-        if process_queue:
-            try:
-                img, filter_img = image_queue.get(timeout=0.1)
-                notify = True
-            except queue.Empty:
-                pass
-            
-        if get_ocr_scan_rate() < .5:
-            adjusted_scan_rate = min(get_ocr_scan_rate() + sleep_time_to_add, .5)
-        else:
-            adjusted_scan_rate = get_ocr_scan_rate()
-            
-        if (not img) and process_screenshots:
-            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) > adjusted_scan_rate:
-                screenshot_event.set()
-                img = periodic_screenshot_queue.get()
-                filter_img = True
-                notify = False
-                last_screenshot_time = time.time()
-                ocr_start_time = datetime.now()
-                if adjusted_scan_rate > get_ocr_scan_rate():
-                    ocr_start_time = ocr_start_time - timedelta(seconds=adjusted_scan_rate - get_ocr_scan_rate())
-
-        if img == 0:
-            on_window_closed(False)
-            terminated = True
-            break
-        elif img:
-            if filter_img:
-                ocr_config = get_scene_ocr_config()
-                # Check if the image is completely empty (all white or all black)
-                try:
-                    extrema = img.getextrema()
-                    # For RGB or RGBA images, extrema is a tuple of (min, max) for each channel
-                    if isinstance(extrema[0], tuple):
-                        is_empty = all(e[0] == e[1] for e in extrema)
-                    else:
-                        is_empty = extrema[0] == extrema[1]
-                    if is_empty:
-                        logger.info("Image is totally empty (all pixels the same), sleeping.")
-                        sleep_time_to_add = .5
-                        continue
-                except Exception as e:
-                    logger.debug(f"Could not determine if image is empty: {e}")
-                    
-                # Compare images, but only if it's one box, multiple boxes skews results way too much and produces false positives
-                if ocr_config and len(ocr_config.rectangles) < 2:
-                    if are_images_similar(img, last_image):
-                        logger.info("Captured screenshot is similar to the last one, sleeping.")
-                        if time.time() - last_result_time > 10:
-                            sleep_time_to_add += .005
-                        continue
-                else:
-                    if are_images_identical(img, last_image):
-                        logger.info("Captured screenshot is identical to the last one, sleeping.")
-                        if time.time() - last_result_time > 10:
-                            sleep_time_to_add += .005
-                        continue
-
-                res, text = process_and_write_results(img, write_to, last_result, filtering, notify,
-                                                   ocr_start_time=ocr_start_time, furigana_filter_sensitivity=get_ocr_furigana_filter_sensitivity())
-                if not text and not previous_text and time.time() - last_result_time > 10:
-                    sleep_time_to_add += .005
-                    logger.info(f"No text detected again, sleeping.")
-                else:
-                    sleep_time_to_add = 0
-                    
-                # If image was stabilized, and now there is no text, reset sleep time
-                if not previous_text and not res:
-                    sleep_time_to_add = 0
-                previous_text = text
-                if res:
-                    last_result = (res, engine_index)
-                    last_result_time = time.time()
-            else:
-                process_and_write_results(
-                    img, write_to, None, notify=notify, ocr_start_time=ocr_start_time, engine=ocr2)
-            if isinstance(img, Path):
-                if delete_images:
-                    Path.unlink(img)
-
-        elapsed_time = time.time() - start_time
-        if (not terminated) and elapsed_time < 0.1:
-            time.sleep(0.1 - elapsed_time)
-
-    if websocket_server_thread:
-        websocket_server_thread.stop_server()
-        websocket_server_thread.join()
-    if clipboard_thread:
-        if sys.platform == 'win32':
-            win32api.PostThreadMessage(
-                clipboard_thread.thread_id, win32con.WM_QUIT, 0, 0)
-        clipboard_thread.join()
-    if directory_watcher_thread:
-        directory_watcher_thread.join()
-    if unix_socket_server:
-        unix_socket_server.shutdown()
-        unix_socket_server.join()
-    if screenshot_thread:
-        screenshot_thread.join()
-    if key_combo_listener:
-        key_combo_listener.stop()
-    if config_check_thread:
-        config_check_thread.join()