GameSentenceMiner 2.11.8__tar.gz → 2.12.0__tar.gz

{gamesentenceminer-2.11.8 → gamesentenceminer-2.12.0}/GameSentenceMiner/ai/ai_prompting.py

@@ -33,10 +33,10 @@ TRANSLATION_PROMPT = f"""
 **Professional Game Localization Task**
 
 **Task Directive:**
-Translate ONLY the single line of game dialogue specified below into natural-sounding, context-aware English. The translation must preserve the original tone and intent of the character.
+Translate ONLY the single line of game dialogue specified below into natural-sounding, context-aware {get_config().general.get_native_language_name()}. The translation must preserve the original tone and intent of the character.
 
 **Output Requirements:**
-- Provide only the single, best English translation.
+- Provide only the single, best {get_config().general.get_native_language_name()} translation.
 - Use expletives if they are natural for the context and enhance the translation's impact, but do not over-exaggerate.
 - Preserve or add HTML tags (e.g., `<i>`, `<b>`) if appropriate for emphasis.
 - Do not include notes, alternatives, explanations, or any other surrounding text. Absolutely nothing but the translated line.
@@ -47,7 +47,7 @@ Translate ONLY the single line of game dialogue specified below into natural-sou
 CONTEXT_PROMPT = textwrap.dedent(f"""
 
 **Task Directive:**
-Provide a very brief summary of the scene in English based on the provided Japanese dialogue and context. Focus on the characters' actions and the immediate situation being described.
+Provide a very brief summary of the scene in {get_config().general.get_native_language_name()} based on the provided Japanese dialogue and context. Focus on the characters' actions and the immediate situation being described.
 
 Current Sentence:
 """)

{gamesentenceminer-2.11.8 → gamesentenceminer-2.12.0}/GameSentenceMiner/anki.py

@@ -19,6 +19,7 @@ from GameSentenceMiner.util.model import AnkiCard
 from GameSentenceMiner.util.text_log import get_all_lines, get_text_event, get_mined_line, lines_match
 from GameSentenceMiner.obs import get_current_game
 from GameSentenceMiner.web import texthooking_page
+import re
 
 # Global variables to track state
 previous_note_ids = set()
@@ -161,6 +162,35 @@ def get_initial_card_info(last_note: AnkiCard, selected_lines):
     game_line = get_text_event(last_note)
     sentences = []
     sentences_text = ''
+    
+    # TODO: REMOVE THIS, I DON'T THINK IT'S NEEDED
+    if get_config().wip.overlay_websocket_send:
+        sentence_in_anki = last_note.get_field(get_config().anki.sentence_field).replace("\n", "").replace("\r", "").strip()
+        if lines_match(game_line.text, remove_html_and_cloze_tags(sentence_in_anki)):
+            logger.info("Found matching line in Anki, Preserving HTML and fix spacing!")
+            if "<b>" in sentence_in_anki:
+                text_inside_bold = re.findall(r'<b>(.*?)</b>', sentence_in_anki)
+                logger.info(text_inside_bold)
+                if text_inside_bold:
+                    text = text_inside_bold[0].replace(" ", "").replace('\n', '').strip()
+                    note['fields'][get_config().anki.sentence_field] = game_line.text.replace(text_inside_bold[0], f"<b>{text}</b>")
+                    logger.info(f"Preserved bold Tag for Sentence: {note['fields'][get_config().anki.sentence_field]}")
+            if "<i>" in sentence_in_anki:
+                text_inside_italic = re.findall(r'<i>(.*?)</i>', sentence_in_anki)
+                if text_inside_italic:
+                    text = text_inside_italic[0].replace(" ", "").replace('\n', '').strip()
+                    note['fields'][get_config().anki.sentence_field] = game_line.text.replace(text_inside_italic[0], f"<i>{text}</i>")
+                    logger.info(f"Preserved italic Tag for Sentence: {note['fields'][get_config().anki.sentence_field]}")
+            if "<u>" in sentence_in_anki:
+                text_inside_underline = re.findall(r'<u>(.*?)</u>', sentence_in_anki)
+                if text_inside_underline:
+                    text = text_inside_underline[0].replace(" ", "").replace('\n', '').strip()
+                    note['fields'][get_config().anki.sentence_field] = game_line.text.replace(text_inside_underline[0], f"<u>{text}</u>")
+                    logger.info(f"Preserved underline Tag for Sentence: {note['fields'][get_config().anki.sentence_field]}")
+            
+            if get_config().anki.sentence_field not in note['fields']:
+                logger.info("No HTML tags found to preserve, just fixing spacing")
+                note['fields'][get_config().anki.sentence_field] = game_line.text
     if selected_lines:
         try:
             sentence_in_anki = last_note.get_field(get_config().anki.sentence_field)

{gamesentenceminer-2.11.8 → gamesentenceminer-2.12.0}/GameSentenceMiner/config_gui.py

@@ -113,8 +113,9 @@ class ConfigApp:
         self.window.title('GameSentenceMiner Configuration')
         self.window.protocol("WM_DELETE_WINDOW", self.hide)
         self.obs_scene_listbox_changed = False
+        self.test_func = None
 
-        self.window.geometry("800x700")
+        # self.window.geometry("800x500")
         self.current_row = 0
 
         self.master_config: Config = configuration.load_config()
@@ -137,6 +138,7 @@ class ConfigApp:
         self.profiles_tab = None
         self.ai_tab = None
         self.advanced_tab = None
+        self.wip_tab = None
 
         self.create_tabs()
 
@@ -158,7 +160,12 @@ class ConfigApp:
                             "Saves Settings and Syncs CHANGED SETTINGS to all profiles.", row=0,
                             column=2)
 
+        self.window.update_idletasks()
+        self.window.geometry("")
         self.window.withdraw()
+        
+    def set_test_func(self, func):
+        self.test_func = func
 
     def create_tabs(self):
         self.create_general_tab()
@@ -172,6 +179,7 @@ class ConfigApp:
         self.create_profiles_tab()
         self.create_ai_tab()
         self.create_advanced_tab()
+        self.create_wip_tab()
 
     def add_reset_button(self, frame, category, row, column=0, recreate_tab=None):
         """
@@ -230,6 +238,7 @@ class ConfigApp:
         if self.window is not None:
             self.window.deiconify()
             self.window.lift()
+            self.window.update_idletasks()
             return
 
     def hide(self):
@@ -250,7 +259,8 @@ class ConfigApp:
                 open_multimine_on_startup=self.open_multimine_on_startup.get(),
                 texthook_replacement_regex=self.texthook_replacement_regex.get(),
                 use_both_clipboard_and_websocket=self.use_both_clipboard_and_websocket.get(),
-                texthooker_port=int(self.texthooker_port.get())
+                texthooker_port=int(self.texthooker_port.get()),
+                native_language=CommonLanguages.from_name(self.native_language.get()) if self.native_language.get() else CommonLanguages.ENGLISH.value,
             ),
             paths=Paths(
                 folder_to_watch=self.folder_to_watch.get(),
@@ -362,6 +372,10 @@ class ConfigApp:
                 use_canned_context_prompt=self.use_canned_context_prompt.get(),
                 custom_prompt=self.custom_prompt.get("1.0", tk.END),
                 dialogue_context_length=int(self.ai_dialogue_context_length.get()),
+            ),
+            wip=WIP(
+                overlay_websocket_port=int(self.overlay_websocket_port.get()),
+                overlay_websocket_send=self.overlay_websocket_send.get()
             )
         )
 
@@ -547,6 +561,15 @@ class ConfigApp:
         self.latest_version = ttk.Label(self.general_tab, text=get_latest_version(), bootstyle="secondary")
         self.latest_version.grid(row=self.current_row, column=1, sticky='W', pady=2)
         self.current_row += 1
+        
+        # Native Language Selection
+        HoverInfoLabelWidget(self.general_tab, text="Native Language:",
+                             tooltip="Select your native language. This is used for various features, but will not change the look of GSM.",
+                                row=self.current_row, column=0)
+        self.native_language = ttk.Combobox(self.general_tab, values=CommonLanguages.get_all_names_pretty(), state="readonly")
+        self.native_language.set(CommonLanguages.from_code(self.settings.general.native_language).name.replace('_', ' ').title())
+        self.native_language.grid(row=self.current_row, column=1, sticky='EW', pady=2)
+        self.current_row += 1
 
         ttk.Label(self.general_tab, text="Indicates important/required settings.", foreground="dark orange",
                   font=("Helvetica", 10, "bold")).grid(row=self.current_row, column=0, columnspan=2, sticky='W', pady=2)
@@ -561,6 +584,12 @@ class ConfigApp:
                   text="Every Label in settings has a tooltip with more information if you hover over them.",
                   font=("Helvetica", 10, "bold")).grid(row=self.current_row, column=0, columnspan=2, sticky='W', pady=2)
         self.current_row += 1
+        
+        if is_beangate:
+            ttk.Button(self.general_tab, text="Run Function", command=self.test_func, bootstyle="info").grid(
+                row=self.current_row, column=0, pady=5
+            )
+            self.current_row += 1
 
         # Add Reset to Default button
         self.add_reset_button(self.general_tab, "general", self.current_row, column=0, recreate_tab=self.create_general_tab)
@@ -1674,6 +1703,54 @@ class ConfigApp:
     #
     #
     #     help_frame.grid_columnconfigure(0, weight=1)
+    
+    @new_tab
+    def create_wip_tab(self):
+        if self.wip_tab is None:
+            self.wip_tab = ttk.Frame(self.notebook, padding=15)
+            self.notebook.add(self.wip_tab, text='WIP')
+        else:
+            for widget in self.wip_tab.winfo_children():
+                widget.destroy()
+
+        wip_frame = self.wip_tab
+
+        ttk.Label(wip_frame, text="Warning: These features are experimental and may not work as expected.",
+                  foreground="red", font=("Helvetica", 10, "bold")).grid(row=self.current_row, column=0, columnspan=2,
+                                                                       sticky='W', pady=5)
+                  
+        self.current_row += 1
+        
+        ttk.Label(wip_frame, text="Overlay requires OwOCR dependencies to be installed, and requires an external app to be running.",
+                  foreground="red", font=("Helvetica", 10, "bold")).grid(row=self.current_row, column=0, columnspan=2,
+                                                                       sticky='W', pady=5)
+                  
+        self.current_row += 1
+
+        HoverInfoLabelWidget(wip_frame, text="Overlay WebSocket Port:",
+                             tooltip="Port for the overlay WebSocket communication. Used for experimental overlay features.",
+                             row=self.current_row, column=0)
+        self.overlay_websocket_port = ttk.Entry(wip_frame)
+        self.overlay_websocket_port.insert(0, str(self.settings.wip.overlay_websocket_port))
+        self.overlay_websocket_port.grid(row=self.current_row, column=1, sticky='EW', pady=2)
+        self.current_row += 1
+
+        HoverInfoLabelWidget(wip_frame, text="Overlay WebSocket Send:",
+                             tooltip="Enable to send overlay data via WebSocket. Experimental feature.",
+                             row=self.current_row, column=0)
+        self.overlay_websocket_send = tk.BooleanVar(value=self.settings.wip.overlay_websocket_send)
+        ttk.Checkbutton(wip_frame, variable=self.overlay_websocket_send, bootstyle="round-toggle").grid(
+            row=self.current_row, column=1, sticky='W', 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):
+            wip_frame.grid_columnconfigure(col, weight=0)
+        for row in range(self.current_row):
+            wip_frame.grid_rowconfigure(row, minsize=30)
+
+        return wip_frame
 
     def on_profile_change(self, event):
         self.save_settings(profile_change=True)

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

@@ -2,13 +2,15 @@ import asyncio
 import re
 
 import pyperclip
+import requests
 import websockets
 from websockets import InvalidStatus
 
 from GameSentenceMiner.util.gsm_utils import do_text_replacements, TEXT_REPLACEMENTS_FILE, run_new_thread
 from GameSentenceMiner.util.configuration import *
 from GameSentenceMiner.util.text_log import *
-from GameSentenceMiner.web.texthooking_page import add_event_to_texthooker
+from GameSentenceMiner.web.texthooking_page import add_event_to_texthooker, send_word_coordinates_to_overlay, overlay_server_thread
+from GameSentenceMiner.wip import get_overlay_coords
 
 current_line = ''
 current_line_after_regex = ''
@@ -123,6 +125,23 @@ async def handle_new_text_event(current_clipboard, line_time=None):
     add_line(current_line_after_regex, line_time)
     if len(get_text_log().values) > 0:
         await add_event_to_texthooker(get_text_log()[-1])
+    if get_config().wip.overlay_websocket_port and get_config().wip.overlay_websocket_send and overlay_server_thread.has_clients():
+        boxes = await find_box_for_sentence(current_line_after_regex)
+        if boxes:
+            await send_word_coordinates_to_overlay(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}/GameSentenceMiner/gsm.py

@@ -545,6 +545,8 @@ def async_loop():
             await check_obs_folder_is_correct()
         logger.info("Post-Initialization started.")
         vad_processor.init()
+        # if is_beangate:
+            # await run_test_code()
 
     asyncio.run(loop())
 
@@ -577,6 +579,13 @@ async def register_scene_switcher_callback():
             update_icon()
 
     await obs.register_scene_change_callback(scene_switcher_callback)
+    
+async def run_test_code():
+    if get_config().wip.overlay_websocket_port and get_config().wip.overlay_websocket_send:
+        boxes = await gametext.find_box_for_sentence("ちぇっ少しなの？")
+        if boxes:
+            await texthooking_page.send_word_coordinates_to_overlay(boxes)
+        await asyncio.sleep(2)
 
 async def async_main(reloading=False):
     global root, settings_window

{gamesentenceminer-2.11.8 → gamesentenceminer-2.12.0}/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}/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, return_coords=False):
         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)
@@ -873,20 +905,18 @@ class OneOCR:
         if sys.platform == 'win32':
             try:
                 ocr_resp = self.model.recognize_pil(img)
+                if os.path.exists(os.path.expanduser("~/GSM/temp")):
+                    with open(os.path.join(os.path.expanduser("~/GSM/temp"), 'oneocr_response.json'), 'w',
+                                encoding='utf-8') as f:
+                        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)
-
-                # 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)
+                # logger.info(filtered_lines)
                 res = ''
                 skipped = []
+                boxes = []
                 if furigana_filter_sensitivity > 0:
-                    for line in ocr_resp['lines']:
+                    for line in filtered_lines:
                         x1, x2, x3, x4 = line['bounding_rect']['x1'], line['bounding_rect']['x2'], \
                             line['bounding_rect']['x3'], line['bounding_rect']['x4']
                         y1, y2, y3, y4 = line['bounding_rect']['y1'], line['bounding_rect']['y2'], \
@@ -934,8 +964,46 @@ 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']:
+                            box = {
+                                "text": word['text'],
+                                "bounding_rect": word['bounding_rect']
+                            }
+                            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:
                 return (False, e)
         else:
@@ -950,10 +1018,12 @@ class OneOCR:
                 return (False, 'Unknown error!')
 
             res = res.json()['text']
-
-        x = (True, res, crop_coords)
-
-        # img.close()
+        if return_coords:
+            x = (True, res, boxes)
+        else:
+            x = (True, res, crop_coords)
+        if is_path:
+            img.close()
         return x
 
     def _preprocess(self, img):