GameSentenceMiner 2.11.8__tar.gz → 2.12.0.dev1__tar.gz

{gamesentenceminer-2.11.8 → gamesentenceminer-2.12.0.dev1}/GameSentenceMiner/gametext.py

@@ -2,6 +2,7 @@ import asyncio
 import re
 
 import pyperclip
+import requests
 import websockets
 from websockets import InvalidStatus
 
@@ -9,6 +10,7 @@ from GameSentenceMiner.util.gsm_utils import do_text_replacements, TEXT_REPLACEM
 from GameSentenceMiner.util.configuration import *
 from GameSentenceMiner.util.text_log import *
 from GameSentenceMiner.web.texthooking_page import add_event_to_texthooker
+from GameSentenceMiner.wip import get_overlay_coords
 
 current_line = ''
 current_line_after_regex = ''
@@ -121,8 +123,21 @@ async def handle_new_text_event(current_clipboard, line_time=None):
     current_line_time = line_time if line_time else datetime.now()
     gsm_status.last_line_received = current_line_time.strftime("%Y-%m-%d %H:%M:%S")
     add_line(current_line_after_regex, line_time)
+    boxes = await find_box_for_sentence(current_line)
     if len(get_text_log().values) > 0:
-        await add_event_to_texthooker(get_text_log()[-1])
+        await add_event_to_texthooker(get_text_log()[-1], boxes=boxes)
+
+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}")
+    # if boxes:
+        # x1, y1, x2, y2 = box
+        # boxes.append({'sentence': sentence, 'x1': x1, 'y1': y1, 'x2': x2, 'y2': y2, 'fontSize': font_size})
+        # x1, y1, x2, y2 = box
+        # requests.post("http://localhost:3000/open-overlay", json={"sentence": sentence, "x1": x1, "y1": y1, "x2": x2, "y2": y2, "fontSize": font_size})
+    return boxes
 
 def reset_line_hotkey_pressed():
     global current_line_time

{gamesentenceminer-2.11.8 → gamesentenceminer-2.12.0.dev1}/GameSentenceMiner/obs.py

@@ -3,6 +3,8 @@ import os.path
 import subprocess
 import threading
 import time
+from pprint import pprint
+
 import psutil
 
 import obsws_python as obs
@@ -356,9 +358,9 @@ def get_screenshot(compression=-1):
         logger.error(f"Error getting screenshot: {e}")
         return None
 
-def get_screenshot_base64(compression=0, width=None, height=None):
+def get_screenshot_base64(compression=75, width=None, height=None):
     try:
-        # update_current_game()
+        update_current_game()
         current_game = get_current_game()
         if not current_game:
             logger.error("No active game scene found.")
@@ -368,7 +370,11 @@ def get_screenshot_base64(compression=0, width=None, height=None):
         if not current_source_name:
             logger.error("No active source found in the current scene.")
             return None
+        # version = client.send("GetVersion", raw=True)
+        # pprint(version)
+        # responseraw = client.send("GetSourceScreenshot", {"sourceName": current_source_name, "imageFormat": "png", "imageWidth": width, "imageHeight": height, "compressionQuality": compression}, raw=True)
         response = client.get_source_screenshot(name=current_source_name, img_format='png', quality=compression, width=width, height=height)
+        # print(responseraw)
         if response and response.image_data:
             return response.image_data.split(',', 1)[-1]  # Remove data:image/png;base64, prefix if present
         else:
@@ -428,5 +434,7 @@ def main():
 
 if __name__ == '__main__':
     logging.basicConfig(level=logging.INFO)
-    main()
+    # main()
+    connect_to_obs_sync()
+    print(get_screenshot_base64(compression=75, width=1280, height=720))
 

{gamesentenceminer-2.11.8 → gamesentenceminer-2.12.0.dev1}/GameSentenceMiner/owocr/owocr/ocr.py

@@ -6,13 +6,14 @@ from pathlib import Path
 import sys
 import platform
 import logging
-from math import sqrt
+from math import sqrt, floor
 import json
 import base64
 from urllib.parse import urlparse, parse_qs
 
 import jaconv
 import numpy as np
+import rapidfuzz.fuzz
 from PIL import Image
 from loguru import logger
 import requests
@@ -164,6 +165,28 @@ def limit_image_size(img, max_size):
     return False, ''
 
 
+def get_regex(lang):
+    if lang == "ja":
+        return re.compile(r'[\u3041-\u3096\u30A1-\u30FA\u4E00-\u9FFF]')
+    elif lang == "zh":
+        return re.compile(r'[\u4E00-\u9FFF]')
+    elif lang == "ko":
+        return re.compile(r'[\uAC00-\uD7AF]')
+    elif lang == "ar":
+        return re.compile(r'[\u0600-\u06FF\u0750-\u077F\u08A0-\u08FF\uFB50-\uFDFF\uFE70-\uFEFF]')
+    elif lang == "ru":
+        return re.compile(r'[\u0400-\u04FF\u0500-\u052F\u2DE0-\u2DFF\uA640-\uA69F\u1C80-\u1C8F]')
+    elif lang == "el":
+        return re.compile(r'[\u0370-\u03FF\u1F00-\u1FFF]')
+    elif lang == "he":
+        return re.compile(r'[\u0590-\u05FF\uFB1D-\uFB4F]')
+    elif lang == "th":
+        return re.compile(r'[\u0E00-\u0E7F]')
+    else:
+        return 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]')
+
+
 class MangaOcr:
     name = 'mangaocr'
     readable_name = 'Manga OCR'
@@ -243,15 +266,20 @@ class GoogleLens:
     available = False
 
     def __init__(self, lang='ja'):
-        self.kana_kanji_regex = re.compile(r'[\u3041-\u3096\u30A1-\u30FA\u4E00-\u9FFF]')
+        self.regex = get_regex(lang)
+        self.initial_lang = lang
         if 'betterproto' not in sys.modules:
             logger.warning('betterproto not available, Google Lens will not work!')
         else:
             self.available = True
             logger.info('Google Lens ready')
 
-    def __call__(self, img, furigana_filter_sensitivity=0):
+    def __call__(self, img, furigana_filter_sensitivity=0, return_coords=False):
+        lang = get_ocr_language()
         img, is_path = input_to_pil_image(img)
+        if lang != self.initial_lang:
+            self.initial_lang = lang
+            self.regex = get_regex(lang)
         if not img:
             return (False, 'Invalid image provided')
 
@@ -309,12 +337,14 @@ class GoogleLens:
         response_proto = LensOverlayServerResponse().FromString(res.content)
         response_dict = response_proto.to_dict(betterproto.Casing.SNAKE)
 
-        # with open(os.path.join(r"C:\Users\Beangate\GSM\Electron App\test", 'glens_response.json'), 'w', encoding='utf-8') as f:
-        #     json.dump(response_dict, f, indent=4, ensure_ascii=False)
+        if os.path.exists(r"C:\Users\Beangate\GSM\Electron App\test"):
+            with open(os.path.join(r"C:\Users\Beangate\GSM\Electron App\test", 'glens_response.json'), 'w', encoding='utf-8') as f:
+                json.dump(response_dict, f, indent=4, ensure_ascii=False)
         res = ''
         text = response_dict['objects_response']['text']
         skipped = []
         previous_line = None
+        lines = []
         if 'text_layout' in text:
             for paragraph in text['text_layout']['paragraphs']:
                 if previous_line:
@@ -330,18 +360,38 @@ class GoogleLens:
                     if vertical_space > avg_height * 2:
                         res += 'BLANK_LINE'
                 for line in paragraph['lines']:
+                    # Build a list of word boxes for this line
+                    words_info = []
+                    for word in line['words']:
+                        word_info = {
+                            "word": word['plain_text'],
+                            "x1": int(word['geometry']['bounding_box']['center_x'] * img.width - (word['geometry']['bounding_box']['width'] * img.width) / 2),
+                            "y1": int(word['geometry']['bounding_box']['center_y'] * img.height - (word['geometry']['bounding_box']['height'] * img.height) / 2),
+                            "x2": int(word['geometry']['bounding_box']['center_x'] * img.width + (word['geometry']['bounding_box']['width'] * img.width) / 2),
+                            "y2": int(word['geometry']['bounding_box']['center_y'] * img.height + (word['geometry']['bounding_box']['height'] * img.height) / 2)
+                        }
+                        words_info.append(word_info)
+
+                    line_text = ''.join([w['word'] for w in words_info])
+                    line_box = {
+                        "sentence": line_text,
+                        "words": words_info
+                    }
+
+                    # Optionally apply furigana filter
                     if furigana_filter_sensitivity:
-                        if furigana_filter_sensitivity < line['geometry']['bounding_box']['width'] * img.width and furigana_filter_sensitivity < line['geometry']['bounding_box']['height'] * img.height:
-                            for word in line['words']:
-                                res += word['plain_text'] + word['text_separator']
+                        line_width = line['geometry']['bounding_box']['width'] * img.width
+                        line_height = line['geometry']['bounding_box']['height'] * img.height
+                        if furigana_filter_sensitivity < line_width and furigana_filter_sensitivity < line_height and self.regex.search(line_text):
+                            for w in words_info:
+                                res += w['word']
                         else:
-                            skipped.append(word['plain_text'] for word in line['words'])
+                            skipped.extend([w['word'] for w in words_info])
                             continue
                     else:
-                        for word in line['words']:
-                                res += word['plain_text'] + word['text_separator']
-                        else:
-                            continue
+                        for w in words_info:
+                            res += w['word']
+                    lines.append(line_box)
                 previous_line = paragraph
                 res += '\n'
             # logger.info(
@@ -384,8 +434,11 @@ class GoogleLens:
         #                 else:
         #                     continue
         #             res += '\n'
-
-        x = (True, res)
+        
+        if return_coords:
+            x = (True, res, lines)
+        else:
+            x = (True, res)
 
         # img.close()
         return x
@@ -812,7 +865,7 @@ class OneOCR:
 
     def __init__(self, config={}, lang='ja'):
         self.initial_lang = lang
-        self.get_regex(lang)
+        self.regex = get_regex(lang)
         if sys.platform == 'win32':
             if int(platform.release()) < 10:
                 logger.warning('OneOCR is not supported on Windows older than 10!')
@@ -834,32 +887,11 @@ class OneOCR:
             except:
                 logger.warning('Error reading URL from config, OneOCR will not work!')
 
-    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):
+    def __call__(self, img, furigana_filter_sensitivity=0, sentence_to_check=None):
         lang = get_ocr_language()
         if lang != self.initial_lang:
             self.initial_lang = lang
-            self.get_regex(lang)
+            self.regex = get_regex(lang)
         img, is_path = input_to_pil_image(img)
         if img.width < 51 or img.height < 51:
             new_width = max(img.width, 51)
@@ -879,7 +911,6 @@ class OneOCR:
                 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)
-
                 # with open(os.path.join(get_temporary_directory(), 'oneocr_response.json'), 'w',
                 #           encoding='utf-8') as f:
                 #     json.dump(ocr_resp, f, indent=4, ensure_ascii=False)
@@ -934,8 +965,37 @@ 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)
                 else:
+                    x_coords = [line['bounding_rect'][f'x{i}'] for line in ocr_resp['lines'] for i in range(1, 5)]
+                    y_coords = [line['bounding_rect'][f'y{i}'] for line in ocr_resp['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:
                 return (False, e)
         else:
@@ -950,10 +1010,9 @@ class OneOCR:
                 return (False, 'Unknown error!')
 
             res = res.json()['text']
-
         x = (True, res, crop_coords)
-
-        # img.close()
+        if is_path:
+            img.close()
         return x
 
     def _preprocess(self, img):

{gamesentenceminer-2.11.8 → gamesentenceminer-2.12.0.dev1}/GameSentenceMiner/owocr/owocr/run.py

@@ -384,7 +384,6 @@ 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:
@@ -548,6 +547,39 @@ 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)
@@ -570,7 +602,7 @@ class ScreenshotThread(threading.Thread):
 
     def windows_window_tracker(self):
         found = True
-        while not terminated:
+        while not terminated or window_open:
             found = win32gui.IsWindow(self.window_handle)
             if not found:
                 break
@@ -1086,10 +1118,11 @@ def signal_handler(sig, frame):
 
 
 def on_window_closed(alive):
-    global terminated
+    global terminated, window_open
     if not (alive or terminated):
         logger.info('Window closed or error occurred, terminated!')
-        terminated = True
+        window_open = False
+        # terminated = True
 
 
 def on_screenshot_combo():

{gamesentenceminer-2.11.8 → gamesentenceminer-2.12.0.dev1}/GameSentenceMiner/util/configuration.py

@@ -253,7 +253,6 @@ class Advanced:
     multi_line_sentence_storage_field: str = ''
     ocr_websocket_port: int = 9002
     texthooker_communication_websocket_port: int = 55001
-    use_anki_note_creation_time: bool = True
 
     def __post_init__(self):
         if self.plaintext_websocket_port == -1:

{gamesentenceminer-2.11.8 → gamesentenceminer-2.12.0.dev1}/GameSentenceMiner/vad.py

@@ -136,7 +136,7 @@ class VADProcessor(ABC):
         if get_config().vad.cut_and_splice_segments:
             self.extract_audio_and_combine_segments(input_audio, voice_activity, output_audio, padding=get_config().vad.splice_padding)
         else:
-            ffmpeg.trim_audio(input_audio, start_time + get_config().vad.beginning_offset, end_time + get_config().audio.end_offset, output_audio, trim_beginning=get_config().vad.trim_beginning, fade_in_duration=0.05, fade_out_duration=00)
+            ffmpeg.trim_audio(input_audio, start_time + get_config().vad.beginning_offset, end_time + get_config().audio.end_offset, output_audio, trim_beginning=get_config().vad.trim_beginning, fade_in_duration=0.05, fade_out_duration=0)
         return VADResult(True, start_time + get_config().vad.beginning_offset, end_time + get_config().audio.end_offset, self.vad_system_name, voice_activity, output_audio)
 
 class SileroVADProcessor(VADProcessor):

{gamesentenceminer-2.11.8 → gamesentenceminer-2.12.0.dev1}/GameSentenceMiner/web/texthooking_page.py

@@ -259,7 +259,7 @@ def clear_history():
     return jsonify({'message': 'History cleared successfully'}), 200
 
 
-async def add_event_to_texthooker(line: GameLine):
+async def add_event_to_texthooker(line: GameLine, boxes=None):
     new_event = event_manager.add_gameline(line)
     await websocket_server_thread.send_text({
         'event': 'text_received',
@@ -268,6 +268,8 @@ async def add_event_to_texthooker(line: GameLine):
     })
     if get_config().advanced.plaintext_websocket_port:
         await plaintext_websocket_server_thread.send_text(line.text)
+    if boxes and len(boxes) > 0 and overlay_server_thread:
+        await overlay_server_thread.send_text(boxes)
 
 
 @app.route('/update_checkbox', methods=['POST'])
@@ -437,7 +439,7 @@ class WebsocketServerThread(threading.Thread):
 
     async def send_text(self, text):
         if text:
-            if isinstance(text, dict):
+            if isinstance(text, dict) or isinstance(text, list):
                 text = json.dumps(text)
             return asyncio.run_coroutine_threadsafe(
                 self.send_text_coroutine(text), self.loop)
@@ -471,7 +473,7 @@ def handle_exit_signal(loop):
         task.cancel()
 
 async def texthooker_page_coro():
-    global websocket_server_thread, plaintext_websocket_server_thread
+    global websocket_server_thread, plaintext_websocket_server_thread, overlay_server_thread
     # Run the WebSocket server in the asyncio event loop
     flask_thread = threading.Thread(target=start_web_server)
     flask_thread.daemon = True
@@ -483,6 +485,9 @@ async def texthooker_page_coro():
     if get_config().advanced.plaintext_websocket_port:
         plaintext_websocket_server_thread = WebsocketServerThread(read=False, ws_port=get_config().advanced.plaintext_websocket_port)
         plaintext_websocket_server_thread.start()
+        
+    overlay_server_thread = WebsocketServerThread(read=False, ws_port=49999)
+    overlay_server_thread.start()
 
     # Keep the main asyncio event loop running (for the WebSocket server)
 

{gamesentenceminer-2.11.8 → gamesentenceminer-2.12.0.dev1}/GameSentenceMiner.egg-info/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: GameSentenceMiner
-Version: 2.11.8
-Summary: A tool for mining sentences from games. Update: Full UI Re-design
+Version: 2.12.0.dev1
+Summary: A tool for mining sentences from games. Update: Overlay?
 Author-email: Beangate <bpwhelan95@gmail.com>
 License: MIT License
 Project-URL: Homepage, https://github.com/bpwhelan/GameSentenceMiner

{gamesentenceminer-2.11.8 → gamesentenceminer-2.12.0.dev1}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: GameSentenceMiner
-Version: 2.11.8
-Summary: A tool for mining sentences from games. Update: Full UI Re-design
+Version: 2.12.0.dev1
+Summary: A tool for mining sentences from games. Update: Overlay?
 Author-email: Beangate <bpwhelan95@gmail.com>
 License: MIT License
 Project-URL: Homepage, https://github.com/bpwhelan/GameSentenceMiner

{gamesentenceminer-2.11.8 → gamesentenceminer-2.12.0.dev1}/pyproject.toml

@@ -7,8 +7,8 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "GameSentenceMiner"
-version = "2.11.8"
-description = "A tool for mining sentences from games. Update: Full UI Re-design"
+version = "2.12.0-dev1"
+description = "A tool for mining sentences from games. Update: Overlay?"
 readme = "README.md"
 requires-python = ">=3.10"
 license = { text = "MIT License" }