GameSentenceMiner 2.14.4__py3-none-any.whl → 2.14.6__py3-none-any.whl

GameSentenceMiner/ai/ai_prompting.py

@@ -24,13 +24,13 @@ TRANSLATION_PROMPT = f"""
 **Professional Game Localization Task**
 
 **Task Directive:**
-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.
+Translate ONLY the provided 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 source.
 
 **Output Requirements:**
 - 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.
 - Carryover all HTML tags present in the original text to HTML tags surrounding their corresponding words in the translation. DO NOT CONVERT TO MARKDOWN.
-- Maintain New Line Characters.
+- If there are no HTML tags present in the original text, do not add any in the translation whatsoever.
 - Do not include notes, alternatives, explanations, or any other surrounding text. Absolutely nothing but the translated line.
 
 **Line to Translate:**
@@ -78,11 +78,11 @@ class AIManager(ABC):
         self.logger = logger
 
     @abstractmethod
-    def process(self, lines: List[GameLine], sentence: str, current_line_index: int, game_title: str = "") -> str:
+    def process(self, lines: List[GameLine], sentence: str, current_line_index: int, game_title: str = "", custom_prompt=None) -> str:
         pass
 
     @abstractmethod
-    def _build_prompt(self, lines: List[GameLine], sentence: str, current_line: GameLine, game_title: str) -> str:
+    def _build_prompt(self, lines: List[GameLine], sentence: str, current_line: GameLine, game_title: str, custom_prompt=None) -> str:
         if get_config().ai.dialogue_context_length != 0:
             if get_config().ai.dialogue_context_length == -1:
                 start_index = 0
@@ -105,8 +105,9 @@ class AIManager(ABC):
             """
         else:
             dialogue_context = "No dialogue context available."
-
-        if get_config().ai.use_canned_translation_prompt:
+        if custom_prompt:
+            prompt_to_use = custom_prompt
+        elif get_config().ai.use_canned_translation_prompt:
             prompt_to_use = TRANSLATION_PROMPT
         elif get_config().ai.use_canned_context_prompt:
             prompt_to_use = CONTEXT_PROMPT
@@ -122,7 +123,7 @@ class AIManager(ABC):
 
             {sentence}
         """)
-        return full_prompt
+        return textwrap.dedent(full_prompt)
 
 
 class OpenAIManager(AIManager):
@@ -144,11 +145,11 @@ class OpenAIManager(AIManager):
             self.openai = None
             self.model_name = None
     
-    def _build_prompt(self, lines: List[GameLine], sentence: str, current_line: GameLine, game_title: str) -> str:
-        prompt = super()._build_prompt(lines, sentence, current_line, game_title)
+    def _build_prompt(self, lines: List[GameLine], sentence: str, current_line: GameLine, game_title: str, custom_prompt=None) -> str:
+        prompt = super()._build_prompt(lines, sentence, current_line, game_title, custom_prompt=custom_prompt)
         return prompt
-    
-    def process(self, lines: List[GameLine], sentence: str, current_line: GameLine, game_title: str = "") -> str:
+
+    def process(self, lines: List[GameLine], sentence: str, current_line: GameLine, game_title: str = "", custom_prompt=None) -> str:
         if self.client is None:
             return "Processing failed: OpenAI client not initialized."
 
@@ -157,7 +158,7 @@ class OpenAIManager(AIManager):
             return "Invalid input."
 
         try:
-            prompt = self._build_prompt(lines, sentence, current_line, game_title)
+            prompt = self._build_prompt(lines, sentence, current_line, game_title, custom_prompt=custom_prompt)
             self.logger.debug(f"Generated prompt:\n{prompt}")
             response = self.client.chat.completions.create(
                 model=self.model_name,
@@ -215,11 +216,11 @@ class GeminiAI(AIManager):
             self.logger.error(f"Failed to initialize Gemini API: {e}")
             self.model_name = None
 
-    def _build_prompt(self, lines: List[GameLine], sentence: str, current_line: GameLine, game_title: str) -> str:
-        prompt = super()._build_prompt(lines, sentence, current_line, game_title)
+    def _build_prompt(self, lines: List[GameLine], sentence: str, current_line: GameLine, game_title: str, custom_prompt=None) -> str:
+        prompt = super()._build_prompt(lines, sentence, current_line, game_title, custom_prompt=custom_prompt)
         return prompt
 
-    def process(self, lines: List[GameLine], sentence: str, current_line: GameLine, game_title: str = "") -> str:
+    def process(self, lines: List[GameLine], sentence: str, current_line: GameLine, game_title: str = "", custom_prompt=None) -> str:
         if self.model_name is None:
             return "Processing failed: AI model not initialized."
 
@@ -228,7 +229,7 @@ class GeminiAI(AIManager):
             return "Invalid input."
 
         try:
-            prompt = self._build_prompt(lines, sentence, current_line, game_title)
+            prompt = self._build_prompt(lines, sentence, current_line, game_title, custom_prompt=custom_prompt)
             contents = [
                 types.Content(
                     role="user",
@@ -263,11 +264,11 @@ class GroqAI(AIManager):
             self.logger.error(f"Failed to initialize Groq client: {e}")
             self.client = None
 
-    def _build_prompt(self, lines: List[GameLine], sentence: str, current_line: GameLine, game_title: str) -> str:
-        prompt = super()._build_prompt(lines, sentence, current_line, game_title)
+    def _build_prompt(self, lines: List[GameLine], sentence: str, current_line: GameLine, game_title: str, custom_prompt=None) -> str:
+        prompt = super()._build_prompt(lines, sentence, current_line, game_title, custom_prompt=custom_prompt)
         return prompt
 
-    def process(self, lines: List[GameLine], sentence: str, current_line: GameLine, game_title: str = "") -> str:
+    def process(self, lines: List[GameLine], sentence: str, current_line: GameLine, game_title: str = "", custom_prompt=None) -> str:
         if self.client is None:
             return "Processing failed: Groq client not initialized."
 
@@ -276,7 +277,7 @@ class GroqAI(AIManager):
             return "Invalid input."
 
         try:
-            prompt = self._build_prompt(lines, sentence, current_line, game_title)
+            prompt = self._build_prompt(lines, sentence, current_line, game_title, custom_prompt=custom_prompt)
             self.logger.debug(f"Generated prompt:\n{prompt}")
             completion = self.client.chat.completions.create(
                 model=self.model_name,
@@ -298,7 +299,7 @@ ai_managers: dict[str, AIManager] = {}
 ai_manager: AIManager | None = None
 current_ai_config: Ai | None = None
 
-def get_ai_prompt_result(lines: List[GameLine], sentence: str, current_line: GameLine, game_title: str = "", force_refresh: bool = False, start_index = -1, end_index = -1) -> str:
+def get_ai_prompt_result(lines: List[GameLine], sentence: str, current_line: GameLine, game_title: str = "", force_refresh: bool = False, custom_prompt=None) -> str:
     global ai_manager, current_ai_config
     try:
         is_local_provider = get_config().ai.provider == AIType.OPENAI.value
@@ -335,7 +336,7 @@ def get_ai_prompt_result(lines: List[GameLine], sentence: str, current_line: Gam
         if not ai_manager:
             logger.error("AI is enabled but the AI Manager did not initialize. Check your AI Config IN GSM.")
             return ""
-        return ai_manager.process(lines, sentence, current_line, game_title)
+        return ai_manager.process(lines, sentence, current_line, game_title, custom_prompt=custom_prompt)
     except Exception as e:
         logger.error("Error caught while trying to get AI prompt result. Check logs for more details.")
         logger.debug(e, exc_info=True)

GameSentenceMiner/anki.py

@@ -134,14 +134,11 @@ def update_anki_card(last_note: AnkiCard, note=None, audio_path='', video_path='
 
     if note and 'fields' in note and get_config().ai.enabled:
         sentence_field = note['fields'].get(get_config().anki.sentence_field, {})
-        if not selected_lines and game_line.TL:
-            logger.info("Using TL from texthooker for AI Prompt Result")
-            translation = game_line.TL
-        else:
-            sentence_to_translate = sentence_field if sentence_field else last_note.get_field(
-                get_config().anki.sentence_field)
-            translation = get_ai_prompt_result(get_all_lines(), sentence_to_translate,
-                                     game_line, get_current_game())
+        sentence_to_translate = sentence_field if sentence_field else last_note.get_field(
+            get_config().anki.sentence_field)
+        translation = get_ai_prompt_result(get_all_lines(), sentence_to_translate,
+                                    game_line, get_current_game())
+        game_line.TL = translation
         logger.info(f"AI prompt Result: {translation}")
         note['fields'][get_config().ai.anki_field] = translation
 
@@ -502,3 +499,6 @@ def start_monitoring_anki():
     obs_thread.daemon = True
     obs_thread.start()
 
+
+if __name__ == "__main__":
+    print(invoke("getIntervals", cards=["1754694986036"]))

GameSentenceMiner/config_gui.py

@@ -110,6 +110,30 @@ class HoverInfoLabelWidget:
         if self.tooltip:
             self.tooltip.destroy()
             self.tooltip = None
+            
+class HoverInfoEntryWidget:
+    def __init__(self, parent, text, row, column, padx=5, pady=2, textvariable=None):
+        self.entry = ttk.Entry(parent, textvariable=textvariable)
+        self.entry.grid(row=row, column=column, padx=padx, pady=pady)
+        self.entry.bind("<Enter>", lambda e: self.show_info_box(text))
+        self.entry.bind("<Leave>", lambda e: self.hide_info_box())
+        self.tooltip = None
+
+    def show_info_box(self, text):
+        x, y, _, _ = self.entry.bbox("insert")
+        x += self.entry.winfo_rootx() + 25
+        y += self.entry.winfo_rooty() + 20
+        self.tooltip = tk.Toplevel(self.entry)
+        self.tooltip.wm_overrideredirect(True)
+        self.tooltip.wm_geometry(f"+{x}+{y}")
+        label = ttk.Label(self.tooltip, text=text, relief="solid", borderwidth=1,
+                          font=("tahoma", "12", "normal"))
+        label.pack(ipadx=1)
+
+    def hide_info_box(self):
+        if self.tooltip:
+            self.tooltip.destroy()
+            self.tooltip = None
 
 
 class ResetToDefaultButton(ttk.Button):
@@ -673,7 +697,8 @@ class ConfigApp:
             self.profiles_tab = None
             self.ai_tab = None
             self.advanced_tab = None
-            self.wip_tab = None
+            self.overlay_tab = None
+            # self.wip_tab = None
 
             self.create_vars()
             self.create_tabs()
@@ -830,6 +855,7 @@ class ConfigApp:
 
         # --- General Settings ---
         general_i18n = self.i18n.get('tabs', {}).get('general', {})
+        
         input_frame = ttk.Frame(required_settings_frame)
         input_frame.grid(row=self.current_row, column=0, columnspan=4, sticky='W', pady=2)
         
@@ -854,7 +880,7 @@ class ConfigApp:
         HoverInfoLabelWidget(required_settings_frame, text=locale_i18n.get('label', '...'),
                              tooltip=locale_i18n.get('tooltip', '...'), row=self.current_row, column=0)
         locale_combobox_simple = ttk.Combobox(required_settings_frame, textvariable=self.locale_value, values=[Locale.English.name, Locale.日本語.name, Locale.中文.name], state="readonly")
-        locale_combobox_simple.grid(row=self.current_row, column=1, columnspan=3, sticky='EW', pady=2)
+        locale_combobox_simple.grid(row=self.current_row, column=1, columnspan=2, sticky='EW', pady=2)
         locale_combobox_simple.bind("<<ComboboxSelected>>", lambda e: self.change_locale())
         self.current_row += 1
 
@@ -878,9 +904,9 @@ class ConfigApp:
         ttk.Entry(required_settings_frame, textvariable=self.sentence_field_value).grid(row=self.current_row, column=1, columnspan=3, sticky='EW', pady=2)
         self.current_row += 1
 
-        audio_i18n = anki_i18n.get('sentence_audio_field', {})
-        HoverInfoLabelWidget(required_settings_frame, text=audio_i18n.get('label', '...'),
-                             tooltip=audio_i18n.get('tooltip', '...'), row=self.current_row, column=0)
+        sentence_audio_i18n = anki_i18n.get('sentence_audio_field', {})
+        HoverInfoLabelWidget(required_settings_frame, text=sentence_audio_i18n.get('label', '...'),
+                             tooltip=sentence_audio_i18n.get('tooltip', '...'), row=self.current_row, column=0)
         ttk.Entry(required_settings_frame, textvariable=self.sentence_audio_field_value).grid(row=self.current_row, column=1, columnspan=3, sticky='EW', pady=2)
         self.current_row += 1
 
@@ -912,6 +938,45 @@ class ConfigApp:
                              tooltip=vad_end_offset_i18n.get('tooltip', '...'), row=self.current_row, column=0)
         ttk.Entry(required_settings_frame, textvariable=self.end_offset_value).grid(row=self.current_row, column=1, columnspan=3, sticky='EW', pady=2)
         self.current_row += 1
+        
+        splice_i18n = vad_i18n.get('cut_and_splice', {})
+        HoverInfoLabelWidget(required_settings_frame, text=splice_i18n.get('label', '...'),
+                             tooltip=splice_i18n.get('tooltip', '...'),
+                             row=self.current_row, column=0)
+        ttk.Checkbutton(required_settings_frame, variable=self.cut_and_splice_segments_value, bootstyle="round-toggle").grid(
+            row=self.current_row, column=1, sticky='W', pady=2)
+        
+        padding_i18n = vad_i18n.get('splice_padding', {})
+        HoverInfoEntryWidget(required_settings_frame, text=padding_i18n.get('tooltip', '...'),
+                                              row=self.current_row, column=2, textvariable=self.splice_padding_value)
+
+        self.current_row += 1
+        
+        # Ocen Audio
+
+        ext_tool_i18n = audio_tab_i18n.get('external_tool', {})
+        HoverInfoLabelWidget(required_settings_frame, text=ext_tool_i18n.get('label', '...'),
+                             tooltip=ext_tool_i18n.get('tooltip', '...'),
+                             foreground="green", font=("Helvetica", 10, "bold"), row=self.current_row, column=0)
+        self.external_tool_entry = ttk.Entry(required_settings_frame, textvariable=self.external_tool_value)
+        self.external_tool_entry.grid(row=self.current_row, column=1, sticky='EW', pady=2)
+        
+        ttk.Button(required_settings_frame, text=audio_tab_i18n.get('install_ocenaudio_button', 'Install Ocenaudio'), command=self.download_and_install_ocen,
+            bootstyle="info").grid(row=self.current_row, column=2, pady=5)
+        self.current_row += 1
+        
+        # ext_tool_enabled_i18n = audio_tab_i18n.get('external_tool_enabled', {})
+        # ttk.Checkbutton(required_settings_frame, variable=self.external_tool_enabled_value, bootstyle="round-toggle").grid(
+        #     row=self.current_row, column=3, sticky='W', padx=10, pady=5)
+        # self.current_row += 1
+
+        # Anki Media Collection
+
+        # anki_media_collection_i18n = audio_tab_i18n.get('anki_media_collection', {})
+        # HoverInfoLabelWidget(required_settings_frame, text=anki_media_collection_i18n.get('label', '...'),
+        #                      tooltip=anki_media_collection_i18n.get('tooltip', '...'), row=self.current_row, column=0)
+        # ttk.Entry(required_settings_frame, textvariable=self.anki_media_collection_value).grid(row=self.current_row, column=1, columnspan=3, sticky='EW', pady=2)
+        # self.current_row += 1
 
         # --- Features Settings ---
         features_i18n = self.i18n.get('tabs', {}).get('features', {})
@@ -1554,9 +1619,9 @@ class ConfigApp:
 
         ttk.Button(audio_frame, text=audio_i18n.get('install_ocenaudio_button', 'Install Ocenaudio'), command=self.download_and_install_ocen,
                    bootstyle="info").grid(row=self.current_row, column=0, pady=5)
-        ttk.Button(audio_frame, text=audio_i18n.get('get_anki_media_button', 'Get Anki Media Collection'),
-                   command=self.set_default_anki_media_collection, bootstyle="info").grid(row=self.current_row,
-                                                                                          column=1, pady=5)
+        # ttk.Button(audio_frame, text=audio_i18n.get('get_anki_media_button', 'Get Anki Media Collection'),
+        #            command=self.set_default_anki_media_collection, bootstyle="info").grid(row=self.current_row,
+        #                                                                                   column=1, pady=5)
         self.current_row += 1
 
         self.add_reset_button(audio_frame, "audio", self.current_row, 0, self.create_audio_tab)
@@ -2125,48 +2190,24 @@ class ConfigApp:
         wip_frame = self.wip_tab
         wip_i18n = self.i18n.get('tabs', {}).get('wip', {})
         try:
-            ttk.Label(wip_frame, text=wip_i18n.get('warning_experimental', '...'),
-                    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=wip_i18n.get('warning_overlay_deps', '...'),
-                    foreground="red", font=("Helvetica", 10, "bold")).grid(row=self.current_row, column=0, columnspan=2,
-                                                                        sticky='W', pady=5)
-            self.current_row += 1
-
-            overlay_port_i18n = wip_i18n.get('overlay_port', {})
-            HoverInfoLabelWidget(wip_frame, text=overlay_port_i18n.get('label', '...'),
-                                tooltip=overlay_port_i18n.get('tooltip', '...'),
-                                row=self.current_row, column=0)
-            ttk.Entry(wip_frame, textvariable=self.overlay_websocket_port_value).grid(row=self.current_row, column=1, sticky='EW', pady=2)
-            self.current_row += 1
-
-            overlay_send_i18n = wip_i18n.get('overlay_send', {})
-            HoverInfoLabelWidget(wip_frame, text=overlay_send_i18n.get('label', '...'),
-                                tooltip=overlay_send_i18n.get('tooltip', '...'),
-                                row=self.current_row, column=0)
-            ttk.Checkbutton(wip_frame, variable=self.overlay_websocket_send_value, bootstyle="round-toggle").grid(
-                row=self.current_row, column=1, sticky='W', pady=2)
-            self.current_row += 1
-
-            monitor_i18n = wip_i18n.get('monitor_capture', {})
-            HoverInfoLabelWidget(wip_frame, text=monitor_i18n.get('label', '...'),
-                                tooltip=monitor_i18n.get('tooltip', '...'),
-                                row=self.current_row, column=0)
-            self.monitor_to_capture = ttk.Combobox(wip_frame, values=self.monitors, state="readonly")
+            pass
+            # from GameSentenceMiner.util.controller import ControllerInput, ControllerInputManager
+            # HoverInfoLabelWidget(wip_frame, text=wip_i18n.get('note', 'This tab is a work in progress...'),
+            #                      tooltip=wip_i18n.get('tooltip', '...'), foreground="blue", font=("Helvetica", 10, "bold"),
+            #                      row=self.current_row, column=0, columnspan=2)
+            # self.current_row += 1
+
+            # # Controller OCR Input
+            # controller_ocr_input_i18n = wip_i18n.get('controller_ocr_input', {})
+            # HoverInfoLabelWidget(wip_frame, text=controller_ocr_input_i18n.get('label', 'Controller OCR Input:'), tooltip=controller_ocr_input_i18n.get('tooltip', '...'),
+            #                      row=self.current_row, column=0)
+            # self.controller_ocr_input_value = tk.StringVar(value=getattr(self.settings.wip, 'controller_ocr_input', ''))
+            # self.controller_hotkey_entry = ttk.Entry(wip_frame, textvariable=self.controller_ocr_input_value, width=50)
+            # self.controller_hotkey_entry.grid(row=self.current_row, column=1, sticky='EW', pady=2)
             
-            if self.monitors:
-                # Ensure the index is valid
-                monitor_index = self.settings.overlay.monitor_to_capture
-                if 0 <= monitor_index < len(self.monitors):
-                    self.monitor_to_capture.current(monitor_index)
-                else:
-                    self.monitor_to_capture.current(0)
-            else:
-                self.monitor_to_capture.set(monitor_i18n.get('not_detected', "OwOCR Not Detected"))
-            self.monitor_to_capture.grid(row=self.current_row, column=1, sticky='EW', pady=2)
-            self.current_row += 1
+            # listen_for_input_button = ttk.Button(wip_frame, text="Listen for Input", command=lambda: self.listen_for_controller_input())
+            # listen_for_input_button.grid(row=self.current_row, column=2, sticky='EW', pady=2)
+            # self.current_row += 1
 
         except Exception as e:
             logger.error(f"Error setting up wip tab to capture: {e}")
@@ -2178,6 +2219,27 @@ class ConfigApp:
         for row in range(self.current_row): wip_frame.grid_rowconfigure(row, minsize=30)
 
         return wip_frame
+    
+    # def listen_for_controller_input(self):
+    #     from GameSentenceMiner.util.controller import ControllerInput, ControllerInputManager
+    #     def listen_for_controller_thread():
+    #         controller = ControllerInputManager()
+    #         controller.start()
+    #         start_time = time.time()
+    #         while time.time() - start_time < 10:
+    #             try:
+    #                 event = controller.event_queue.get(timeout=1)
+    #                 input = ''
+    #                 for key in event:
+    #                     input += key.readable_name + '+'
+    #                 input = input[:-1]  # Remove trailing '+'
+    #                 self.controller_hotkey_entry.delete(0, tk.END)
+    #                 self.controller_hotkey_entry.insert(0, input)
+    #             except Exception:
+    #                 continue
+    #         controller.stop()
+    #     listen_thread = threading.Thread(target=listen_for_controller_thread)
+    #     listen_thread.start()
 
     def on_profile_change(self, event):
         self.save_settings(profile_change=True)

GameSentenceMiner/locales/en_us.json

@@ -250,7 +250,7 @@
             "tooltip": "Beginning offset after VAD Trim, Only active if \"Trim Beginning\" is ON. Negative values = more time at the beginning"
           },
           "cut_and_splice": {
-            "label": "Cut and Splice Segments:",
+            "label": "Cut and Splice Voice Segments:",
             "tooltip": "Cut Detected Voice Segments and Paste them back together. More Padding = More Space between voicelines."
           },
           "splice_padding": {

GameSentenceMiner/obs.py

@@ -12,6 +12,8 @@ import obsws_python as obs
 from GameSentenceMiner.util import configuration
 from GameSentenceMiner.util.configuration import *
 from GameSentenceMiner.util.gsm_utils import sanitize_filename, make_unique_file_name
+import tkinter as tk
+from tkinter import messagebox
 
 client: obs.ReqClient = None
 event_client: obs.EventClient = None
@@ -26,10 +28,13 @@ class OBSConnectionManager(threading.Thread):
         super().__init__()
         self.daemon = True
         self.running = True
+        self.check_connection_interval = 1
+        self.said_no_to_replay_buffer = False
+        self.counter = 0
 
     def run(self):
         while self.running:
-            time.sleep(1)
+            time.sleep(self.check_connection_interval)
             try:
                 if not connecting:
                     client.get_version()
@@ -37,9 +42,39 @@ class OBSConnectionManager(threading.Thread):
                 logger.info(f"OBS WebSocket not connected. Attempting to reconnect... {e}")
                 gsm_status.obs_connected = False
                 asyncio.run(connect_to_obs())
+            if self.counter % 5 == 0:
+                replay_buffer_status = get_replay_buffer_status()
+                if replay_buffer_status and self.said_no_to_replay_buffer:
+                    self.said_no_to_replay_buffer = False
+                    self.counter = 0
+                if gsm_status.obs_connected and not replay_buffer_status and not self.said_no_to_replay_buffer:
+                    self.check_output()
+            self.counter += 1
 
     def stop(self):
         self.running = False
+    
+    def check_output(self):
+        img = get_screenshot_PIL(compression=100, img_format='jpg', width=1280, height=720)
+        extrema = img.getextrema()
+        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.")
+        else:
+            root = tk.Tk()
+            root.attributes('-topmost', True)
+            root.withdraw()
+            root.deiconify()
+            result = messagebox.askyesno("GSM - Replay Buffer", "The replay buffer is not running, but there seems to be output in OBS. Do you want to start it? (If you click 'No', you won't be asked until you either restart GSM or start/stop replay buffer manually.)")
+            root.destroy()
+            if not result:
+                self.said_no_to_replay_buffer = True
+                self.counter = 0
+                return
+            start_replay_buffer()
 
 def get_obs_path():
     return os.path.join(configuration.get_app_directory(), 'obs-studio/bin/64bit/obs64.exe')
@@ -248,9 +283,9 @@ def toggle_replay_buffer():
 
 def start_replay_buffer():
     try:
-        status = get_replay_buffer_status()
-        if status:
-            client.start_replay_buffer()
+        response = client.start_replay_buffer()
+        if response and response.ok:
+            logger.info("Replay buffer started.")
     except Exception as e:
         logger.error(f"Error starting replay buffer: {e}")
 
@@ -263,7 +298,9 @@ def get_replay_buffer_status():
 
 def stop_replay_buffer():
     try:
-        client.stop_replay_buffer()
+        response = client.stop_replay_buffer()
+        if response and response.ok:
+            logger.info("Replay buffer stopped.")
     except Exception as e:
         logger.warning(f"Error stopping replay buffer: {e}")
 

GameSentenceMiner/ocr/gsm_ocr_config.py

@@ -95,7 +95,7 @@ class OCRConfig:
                 ]
                 
 def has_config_changed(current_config: OCRConfig) -> bool:
-    new_config = get_scene_ocr_config(use_window_as_config=get_ocr_use_window_for_config(), window=current_config.window)
+    new_config = get_scene_ocr_config(use_window_as_config=get_ocr_use_window_for_config(), window=current_config.window, refresh=True)
     if new_config.rectangles != current_config.rectangles:
         logger.info("OCR config has changed.")
         return True
@@ -139,8 +139,13 @@ def set_dpi_awareness():
     import ctypes
     per_monitor_awareness = 2
     ctypes.windll.shcore.SetProcessDpiAwareness(per_monitor_awareness)
+    
+scene_ocr_config = None
 
-def get_scene_ocr_config(use_window_as_config=False, window=""):
+def get_scene_ocr_config(use_window_as_config=False, window="", refresh=False) -> OCRConfig | None:
+    global scene_ocr_config
+    if scene_ocr_config and not refresh:
+        return scene_ocr_config
     path = get_scene_ocr_config_path(use_window_as_config, window)
     if not os.path.exists(path):
         return None
@@ -148,6 +153,7 @@ def get_scene_ocr_config(use_window_as_config=False, window=""):
         from json import load
         data = load(f)
         ocr_config = OCRConfig.from_dict(data)
+        scene_ocr_config = ocr_config
         return ocr_config
 
 def get_scene_ocr_config_path(use_window_as_config=False, window=""):

GameSentenceMiner/ocr/owocr_helper.py

@@ -378,8 +378,16 @@ def text_callback(text, orig_text, time, img=None, came_from_ss=False, filtering
             previous_orig_text = orig_text_string
             previous_ocr1_result = previous_text
             if crop_coords and get_ocr_optimize_second_scan():
+                x1, y1, x2, y2 = crop_coords
+                x1 = max(0, min(x1, img.width))
+                y1 = max(0, min(y1, img.height))
+                x2 = max(x1, min(x2, img.width))
+                y2 = max(y1, min(y2, img.height))
                 previous_img_local.save(os.path.join(get_temporary_directory(), "pre_oneocrcrop.png"))
-                previous_img_local = previous_img_local.crop(crop_coords)
+                try:
+                    previous_img_local = previous_img_local.crop((x1, y1, x2, y2))
+                except ValueError:
+                    logger.warning("Error cropping image, using original image")
             second_ocr_queue.put((previous_text, stable_time, previous_img_local, filtering, pre_crop_image))
             # threading.Thread(target=do_second_ocr, args=(previous_text, stable_time, previous_img_local, filtering), daemon=True).start()
             previous_img = None

GameSentenceMiner/owocr/owocr/ocr.py

@@ -276,8 +276,10 @@ class GoogleLens:
     available = False
 
     def __init__(self, lang='ja'):
+        import regex
         self.regex = get_regex(lang)
         self.initial_lang = lang
+        self.punctuation_regex = regex.compile(r'[\p{P}\p{S}]')
         if 'betterproto' not in sys.modules:
             logger.warning('betterproto not available, Google Lens will not work!')
         else:
@@ -375,6 +377,8 @@ class GoogleLens:
                 for line in paragraph['lines']:
                     if furigana_filter_sensitivity:
                         for word in line['words']:
+                            if not self.punctuation_regex.findall(word):
+                                continue
                             if 'geometry' not in word:
                                 res += word['plain_text'] + word['text_separator']
                                 continue
@@ -383,7 +387,7 @@ class GoogleLens:
                             if word_width > furigana_filter_sensitivity and word_height > furigana_filter_sensitivity:
                                 res += word['plain_text'] + word['text_separator']
                             else:
-                                skipped.extend([word['plain_text'] for word in line['words']])
+                                skipped.extend(word['plain_text'])
                                 continue
                     else:
                         for word in line['words']:
@@ -935,10 +939,10 @@ 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)
+                # 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)]
@@ -1402,6 +1406,11 @@ class localLLMOCR:
 
     def __init__(self, config={}, lang='ja'):
         self.keep_llm_hot_thread = None
+        # All three config values are required: url, model, api_key
+        if not config or not (config.get('url') and config.get('model') and config.get('api_key')):
+            logger.warning('Local LLM OCR requires url, model, and api_key in config, Local LLM OCR will not work!')
+            return
+
         try:
             import openai
         except ImportError:
@@ -1409,16 +1418,20 @@ class localLLMOCR:
             return
         import openai, threading
         try:
-            self.api_url = config.get('api_url', 'http://localhost:1234/v1/chat/completions')
+            self.api_url = config.get('url', 'http://localhost:1234/v1/chat/completions')
             self.model = config.get('model', 'qwen2.5-vl-3b-instruct')
             self.api_key = config.get('api_key', 'lm-studio')
             self.keep_warm = config.get('keep_warm', True)
             self.custom_prompt = config.get('prompt', None)
             self.available = True
+            if any(x in self.api_url for x in ['localhost', '127.0.0.1']):
+                if not self.check_connection(self.api_url):
+                    logger.warning('Local LLM OCR API is not reachable')
+                    return
             self.client = openai.OpenAI(
-                    base_url=self.api_url.replace('/v1/chat/completions', '/v1'),
-                    api_key=self.api_key
-                )
+                base_url=self.api_url.replace('/v1/chat/completions', '/v1'),
+                api_key=self.api_key
+            )
             if self.client.models.retrieve(self.model):
                 self.model = self.model
             logger.info(f'Local LLM OCR (OpenAI-compatible) ready with model {self.model}')
@@ -1427,6 +1440,25 @@ class localLLMOCR:
                 self.keep_llm_hot_thread.start()
         except Exception as e:
             logger.warning(f'Error initializing Local LLM OCR, Local LLM OCR will not work!')
+            
+    def check_connection(self, url, port=None):
+        # simple connectivity check with mega low timeout
+        import http.client
+        conn = http.client.HTTPConnection(url, port or 1234, timeout=0.1)
+        try:
+            conn.request("GET", "/v1/models")
+            response = conn.getresponse()
+            if response.status == 200:
+                logger.info('Local LLM OCR API is reachable')
+                return True
+            else:
+                logger.warning('Local LLM OCR API is not reachable')
+                return False
+        except Exception as e:
+            logger.warning(f'Error connecting to Local LLM OCR API: {e}')
+            return False
+        finally:
+            conn.close()
         
     def keep_llm_warm(self):
         def ocr_blank_black_image():