GameSentenceMiner 2.12.2__tar.gz → 2.12.4__tar.gz

{gamesentenceminer-2.12.2 → gamesentenceminer-2.12.4}/GameSentenceMiner/config_gui.py

@@ -139,6 +139,16 @@ class ConfigApp:
         self.ai_tab = None
         self.advanced_tab = None
         self.wip_tab = None
+        self.monitors = []
+        
+        try:
+            import mss as mss
+            self.monitors = [f"Monitor {i}: width: {monitor['width']}, height: {monitor['height']}" for i, monitor in enumerate(mss.mss().monitors[1:], start=1)]
+            print(self.monitors)
+            if len(self.monitors) == 0:
+                self.monitors = [1]
+        except ImportError:
+            self.monitors = []
 
         self.create_tabs()
 
@@ -375,7 +385,8 @@ class ConfigApp:
             ),
             wip=WIP(
                 overlay_websocket_port=int(self.overlay_websocket_port.get()),
-                overlay_websocket_send=self.overlay_websocket_send.get()
+                overlay_websocket_send=self.overlay_websocket_send.get(),
+                monitor_to_capture=self.monitor_to_capture.current()
             )
         )
 
@@ -1743,6 +1754,19 @@ class ConfigApp:
             row=self.current_row, column=1, sticky='W', pady=2)
         self.current_row += 1
 
+        HoverInfoLabelWidget(wip_frame, text="Monitor to Capture:",
+                             tooltip="Select the monitor to capture (1-based index).",
+                             row=self.current_row, column=0)
+        self.monitor_to_capture = ttk.Combobox(wip_frame, values=self.monitors, state="readonly")
+        
+        # set index of monitor to capture, not the string
+        if self.monitors:
+            self.monitor_to_capture.current(self.settings.wip.monitor_to_capture)
+        else:
+            self.monitor_to_capture.set("OwOCR Not Detected")
+        self.monitor_to_capture.grid(row=self.current_row, column=1, sticky='EW', pady=2)
+        self.current_row += 1
+
         self.add_reset_button(wip_frame, "wip", self.current_row, 0, self.create_wip_tab)
 
         for col in range(2):

{gamesentenceminer-2.12.2 → gamesentenceminer-2.12.4}/GameSentenceMiner/gametext.py

@@ -137,7 +137,7 @@ async def find_box_for_sentence(sentence):
     boxes = []
     logger.info(f"Finding Box for Sentence: {sentence}")
     boxes, font_size = await get_overlay_coords.find_box_for_sentence(sentence)
-    logger.info(f"Found Boxes: {boxes}, Font Size: {font_size}")
+    # logger.info(f"Found Boxes: {boxes}, Font Size: {font_size}")
     # if boxes:
         # x1, y1, x2, y2 = box
         # boxes.append({'sentence': sentence, 'x1': x1, 'y1': y1, 'x2': x2, 'y2': y2, 'fontSize': font_size})

{gamesentenceminer-2.12.2 → gamesentenceminer-2.12.4}/GameSentenceMiner/obs.py

@@ -383,7 +383,38 @@ def get_screenshot_base64(compression=75, width=None, height=None):
     except Exception as e:
         logger.error(f"Error getting screenshot: {e}")
         return None
+    
+
+def get_screenshot_PIL(source_name=None, compression=75, img_format='png', width=None, height=None, retry=3):
+    import io
+    import base64
+    from PIL import Image
+    if not source_name:
+        source_name = get_active_source().get('sourceName', None)
+    if not source_name:
+        logger.error("No active source found in the current scene.")
+        return None
+    while True:
+        response = client.get_source_screenshot(name=source_name, img_format=img_format, quality=compression, width=width, height=height)
+        try:
+            response.image_data = response.image_data.split(',', 1)[-1]  # Remove data:image/png;base64, prefix if present
+        except AttributeError:
+            retry -= 1
+            if retry <= 0:
+                logger.error(f"Error getting screenshot: {response}")
+                return None
+            continue
+        if response and response.image_data:
+            image_data = response.image_data.split(',', 1)[-1]  # Remove data:image/png;base64, prefix if present
+            image_data = base64.b64decode(image_data)
+            img = Image.open(io.BytesIO(image_data)).convert("RGBA")
+        # if width and height:
+            # img = img.resize((width, height), Image.Resampling.LANCZOS)
+            return img
+    return None
 
+    
+    
 
 def update_current_game():
     gsm_state.current_game = get_current_scene()
@@ -433,8 +464,47 @@ def main():
     disconnect_from_obs()
 
 if __name__ == '__main__':
+    from mss import mss
     logging.basicConfig(level=logging.INFO)
     # main()
     connect_to_obs_sync()
-    print(get_screenshot_base64(compression=75, width=1280, height=720))
+    # i = 100
+    # for i in range(1, 100):
+    #     print(f"Getting screenshot {i}")
+    #     start = time.time()
+    # # get_screenshot(compression=95)
+    # # get_screenshot_base64(compression=95, width=1280, height=720)
+    
+    #     img = get_screenshot_PIL(compression=i, img_format='jpg', width=1280, height=720)
+    #     end = time.time()
+    #     print(f"Time taken to get screenshot with compression {i}: {end - start} seconds")
+        
+    # for i in range(1, 100):
+    #     print(f"Getting screenshot {i}")
+    #     start = time.time()
+    # # get_screenshot(compression=95)
+    # # get_screenshot_base64(compression=95, width=1280, height=720)
+    
+    #     img = get_screenshot_PIL(compression=i, img_format='jpg', width=2560, height=1440)
+    #     end = time.time()
+    #     print(f"Time taken to get screenshot full sized jpg with compression {i}: {end - start} seconds")
+
+    # png_img = get_screenshot_PIL(compression=75, img_format='png', width=1280, height=720)
+
+    # jpg_img = get_screenshot_PIL(compression=100, img_format='jpg', width=2560, height=1440)
+
+    # png_img.show()
+    # jpg_img.show()
+    
+    # start = time.time()
+    # with mss() as sct:
+    #     monitor = sct.monitors[1]
+    #     sct_img = sct.grab(monitor)
+    #     img = Image.frombytes('RGB', sct_img.size, sct_img.bgra, 'raw', 'BGRX')
+    #     img.show()
+    # end = time.time()
+    # print(f"Time taken to get screenshot with mss: {end - start} seconds")
+
+    
+    # print(get_screenshot_base64(compression=75, width=1280, height=720))
 

{gamesentenceminer-2.12.2 → gamesentenceminer-2.12.4}/GameSentenceMiner/owocr/owocr/ocr.py

@@ -436,7 +436,7 @@ class GoogleLens:
         #             res += '\n'
         
         if return_coords:
-            x = (True, res, lines)
+            x = (True, res, response_dict)
         else:
             x = (True, res)
 
@@ -887,7 +887,28 @@ class OneOCR:
             except:
                 logger.warning('Error reading URL from config, OneOCR will not work!')
 
-    def __call__(self, img, furigana_filter_sensitivity=0, sentence_to_check=None, return_coords=False):
+    def get_regex(self, lang):
+        if lang == "ja":
+            self.regex = re.compile(r'[\u3041-\u3096\u30A1-\u30FA\u4E00-\u9FFF]')
+        elif lang == "zh":
+            self.regex = re.compile(r'[\u4E00-\u9FFF]')
+        elif lang == "ko":
+            self.regex = re.compile(r'[\uAC00-\uD7AF]')
+        elif lang == "ar":
+            self.regex = re.compile(r'[\u0600-\u06FF\u0750-\u077F\u08A0-\u08FF\uFB50-\uFDFF\uFE70-\uFEFF]')
+        elif lang == "ru":
+            self.regex = re.compile(r'[\u0400-\u04FF\u0500-\u052F\u2DE0-\u2DFF\uA640-\uA69F\u1C80-\u1C8F]')
+        elif lang == "el":
+            self.regex = re.compile(r'[\u0370-\u03FF\u1F00-\u1FFF]')
+        elif lang == "he":
+            self.regex = re.compile(r'[\u0590-\u05FF\uFB1D-\uFB4F]')
+        elif lang == "th":
+            self.regex = re.compile(r'[\u0E00-\u0E7F]')
+        else:
+            self.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]')
+
+    def __call__(self, img, furigana_filter_sensitivity=0, return_coords=False):
         lang = get_ocr_language()
         if lang != self.initial_lang:
             self.initial_lang = lang
@@ -911,6 +932,10 @@ class OneOCR:
                         json.dump(ocr_resp, f, indent=4, ensure_ascii=False)
                 # print(json.dumps(ocr_resp))
                 filtered_lines = [line for line in ocr_resp['lines'] if self.regex.search(line['text'])]
+                x_coords = [line['bounding_rect'][f'x{i}'] for line in filtered_lines for i in range(1, 5)]
+                y_coords = [line['bounding_rect'][f'y{i}'] for line in filtered_lines for i in range(1, 5)]
+                if x_coords and y_coords:
+                    crop_coords = (min(x_coords) - 5, min(y_coords) - 5, max(x_coords) + 5, max(y_coords) + 5)
                 # logger.info(filtered_lines)
                 res = ''
                 skipped = []
@@ -964,30 +989,6 @@ class OneOCR:
                     #         else:
                     #             continue
                     #     res += '\n'
-                elif sentence_to_check:
-                    lines_to_build_area = []
-                    widths = []
-                    heights = []
-                    for line in ocr_resp['lines']:
-                        print(line['text'])
-                        if sentence_to_check in line['text'] or line['text'] in sentence_to_check or rapidfuzz.fuzz.partial_ratio(sentence_to_check, line['text']) > 50:
-                            lines_to_build_area.append(line)
-                            res += line['text']
-                            for word in line['words']:
-                                widths.append(word['bounding_rect']['x2'] - word['bounding_rect']['x1'])
-                                heights.append(word['bounding_rect']['y3'] - word['bounding_rect']['y1'])
-
-                    x_coords = [line['bounding_rect'][f'x{i}'] for line in lines_to_build_area for i in
-                                range(1, 5)]
-                    y_coords = [line['bounding_rect'][f'y{i}'] for line in lines_to_build_area for i in
-                                range(1, 5)]
-                    if widths:
-                        avg_width = sum(widths) / len(widths)
-                    if heights:
-                        avg_height = sum(heights) / len(heights)
-                    if x_coords and y_coords:
-                        crop_coords = (
-                            min(x_coords) - 5, min(y_coords) - 5, max(x_coords) + 5, max(y_coords) + 5)
                 elif return_coords:
                     for line in filtered_lines:
                         for word in line['words']:
@@ -998,10 +999,6 @@ class OneOCR:
                             boxes.append(box)
                     res = ocr_resp['text']
                 else:
-                    x_coords = [line['bounding_rect'][f'x{i}'] for line in filtered_lines for i in range(1, 5)]
-                    y_coords = [line['bounding_rect'][f'y{i}'] for line in filtered_lines for i in range(1, 5)]
-                    if x_coords and y_coords:
-                        crop_coords = (min(x_coords) - 5, min(y_coords) - 5, max(x_coords) + 5, max(y_coords) + 5)
                     res = ocr_resp['text']
 
             except RuntimeError as e:
@@ -1019,7 +1016,7 @@ class OneOCR:
 
             res = res.json()['text']
         if return_coords:
-            x = (True, res, boxes)
+            x = (True, res, filtered_lines)
         else:
             x = (True, res, crop_coords)
         if is_path:

{gamesentenceminer-2.12.2 → gamesentenceminer-2.12.4}/GameSentenceMiner/owocr/owocr/run.py

@@ -44,7 +44,6 @@ import queue
 from datetime import datetime
 from PIL import Image, ImageDraw, UnidentifiedImageError
 from loguru import logger
-from pynput import keyboard
 from desktop_notifier import DesktopNotifierSync
 import psutil
 
@@ -384,6 +383,7 @@ class TextFiltering:
                 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:
@@ -547,39 +547,6 @@ class ScreenshotThread(threading.Thread):
             else:
                 raise ValueError('Window capture is only currently supported on Windows and macOS')
 
-    def __del__(self):
-        if self.macos_window_tracker_instance:
-            self.macos_window_tracker_instance.join()
-        elif self.windows_window_tracker_instance:
-            self.windows_window_tracker_instance.join()
-
-    def setup_persistent_windows_window_tracker(self):
-        global window_open
-        window_open = False
-        def setup_tracker():
-            global window_open
-            self.window_handle, window_title = self.get_windows_window_handle(self.screen_capture_window)
-
-            if not self.window_handle:
-                # print(f"Window '{screen_capture_window}' not found.")
-                return
-
-            set_dpi_awareness()
-            window_open = True
-            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}')
-
-        while not terminated:
-            if not window_open:
-                try:
-                    setup_tracker()
-                except ValueError as e:
-                    logger.error(f"Error setting up persistent windows window tracker: {e}")
-                    break
-            time.sleep(5)
-
-
     def get_windows_window_handle(self, window_title):
         def callback(hwnd, window_title_part):
             window_title = win32gui.GetWindowText(hwnd)
@@ -602,7 +569,7 @@ class ScreenshotThread(threading.Thread):
 
     def windows_window_tracker(self):
         found = True
-        while not terminated or window_open:
+        while not terminated:
             found = win32gui.IsWindow(self.window_handle)
             if not found:
                 break
@@ -872,18 +839,9 @@ class OBSScreenshotThread(threading.Thread):
             image_queue.put((result, True))
 
     def connect_obs(self):
-        try:
-            import obsws_python as obs
-            self.obs_client = obs.ReqClient(
-                host=get_config().obs.host,
-                port=get_config().obs.port,
-                password=get_config().obs.password,
-                timeout=10
-            )
-            logger.info("Connected to OBS WebSocket.")
-        except Exception as e:
-            logger.error(f"Failed to connect to OBS: {e}")
-            self.obs_client = None
+        import GameSentenceMiner.obs as obs
+        obs.connect_to_obs_sync()
+
 
     def run(self):
         global last_image
@@ -895,7 +853,7 @@ class OBSScreenshotThread(threading.Thread):
         def init_config(source=None, scene=None):
             obs.update_current_game()
             self.current_source = source if source else obs.get_active_source()
-            self.current_source_name = self.current_source.get('sourceName') if isinstance(self.current_source, dict) else None
+            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()
             self.ocr_config.scale_to_custom_size(self.width, self.height)
@@ -927,20 +885,20 @@ class OBSScreenshotThread(threading.Thread):
             if not self.ocr_config:
                 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:
-                response = self.obs_client.get_source_screenshot(
-                    name=self.current_source_name,
-                    img_format='png',
-                    quality=75,
-                    width=self.width,
-                    height=self.height,
-                )
+                if not self.current_source_name:
+                    logger.error("No active source found in the current scene.")
+                    time.sleep(1)
+                    continue
+                img = obs.get_screenshot_PIL(source_name=self.current_source_name, width=self.width, height=self.height, img_format='jpg', compression=90)
 
-                if response.image_data:
-                    image_data = base64.b64decode(response.image_data.split(",")[1])
-                    img = Image.open(io.BytesIO(image_data)).convert("RGBA")
-                    
+                if img is not None:
                     if not img.getbbox():
                         logger.info("OBS Not Capturing anything, sleeping.")
                         time.sleep(1)
@@ -1118,11 +1076,10 @@ def signal_handler(sig, frame):
 
 
 def on_window_closed(alive):
-    global terminated, window_open
+    global terminated
     if not (alive or terminated):
         logger.info('Window closed or error occurred, terminated!')
-        window_open = False
-        # terminated = True
+        terminated = True
 
 
 def on_screenshot_combo():
@@ -1464,8 +1421,12 @@ def run(read_from=None,
         read_from_readable.append(f'directory {read_from_path}')
 
     if len(key_combos) > 0:
-        key_combo_listener = keyboard.GlobalHotKeys(key_combos)
-        key_combo_listener.start()
+        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

{gamesentenceminer-2.12.2 → gamesentenceminer-2.12.4}/GameSentenceMiner/util/configuration.py

@@ -529,6 +529,7 @@ class Ai:
 class WIP:
     overlay_websocket_port: int = 55499
     overlay_websocket_send: bool = False
+    monitor_to_capture: int = 0
                     
 
 

{gamesentenceminer-2.12.2 → gamesentenceminer-2.12.4}/GameSentenceMiner/util/downloader/oneocr_dl.py

@@ -239,11 +239,12 @@ class Downloader:
 # Example usage:
 if __name__ == "__main__":
     downloader = Downloader()
-    if downloader.download_and_extract():
-        print("SnippingTool files are ready.")
-        print("Press Ctrl+C or X on window to exit.")
-        input()
-    else:
-        print("Failed to download and extract SnippingTool files. You may need to follow instructions at https://github.com/AuroraWright/oneocr")
-        print("Press Ctrl+C or X on window to exit.")
-        input()
+    downloader.download_and_extract()
+    # if downloader.download_and_extract():
+    #     print("SnippingTool files are ready.")
+    #     print("Press Ctrl+C or X on window to exit.")
+    #     # input()
+    # else:
+    #     # print("Failed to download and extract SnippingTool files. You may need to follow instructions at https://github.com/AuroraWright/oneocr")
+    #     print("Press Ctrl+C or X on window to exit.")
+    #     input()