GameSentenceMiner 2.13.9__py3-none-any.whl → 2.13.11__py3-none-any.whl

GameSentenceMiner/gsm.py

@@ -53,7 +53,7 @@ try:
     from GameSentenceMiner.util.text_log import GameLine, get_text_event, get_mined_line, get_all_lines, game_log
     from GameSentenceMiner.util import *
     from GameSentenceMiner.web import texthooking_page
-    from GameSentenceMiner.web.service import handle_texthooker_button
+    from GameSentenceMiner.web.service import handle_texthooker_button, set_get_audio_from_video_callback
     from GameSentenceMiner.web.texthooking_page import run_text_hooker_page
 except Exception as e:
     from GameSentenceMiner.util.configuration import logger, is_linux, is_windows
@@ -91,10 +91,8 @@ class VideoToAudioHandler(FileSystemEventHandler):
         selected_lines = []
         anki_card_creation_time = None
         mined_line = None
-        gsm_state.previous_replay = video_path
         if gsm_state.line_for_audio or gsm_state.line_for_screenshot:
-            handle_texthooker_button(
-                video_path, get_audio_from_video=VideoToAudioHandler.get_audio)
+            handle_texthooker_button(video_path)
             return
         try:
             if anki.card_queue and len(anki.card_queue) > 0:
@@ -201,16 +199,14 @@ class VideoToAudioHandler(FileSystemEventHandler):
             logger.debug(
                 f"Some error was hit catching to allow further work to be done: {e}", exc_info=True)
             notification.send_error_no_anki_update()
-        finally:
-            if get_config().paths.remove_video and video_path and not skip_delete:
-                try:
-                    if os.path.exists(video_path):
-                        logger.debug(f"Removing video: {video_path}")
-                        os.remove(video_path)
-                except Exception as e:
-                    logger.error(
-                        f"Error removing video file {video_path}: {e}", exc_info=True)
-            pass
+        if get_config().paths.remove_video and video_path and not skip_delete:
+            try:
+                if os.path.exists(video_path):
+                    logger.debug(f"Removing video: {video_path}")
+                    os.remove(video_path)
+            except Exception as e:
+                logger.error(
+                    f"Error removing video file {video_path}: {e}", exc_info=True)
 
     @staticmethod
     def get_audio(game_line, next_line_time, video_path, anki_card_creation_time=None, temporary=False, timing_only=False, mined_line=None):
@@ -525,6 +521,7 @@ def handle_exit():
 def initialize(reloading=False):
     global obs_process
     if not reloading:
+        get_temporary_directory(delete=True)
         if is_windows():
             download_obs_if_needed()
             download_ffmpeg_if_needed()
@@ -538,6 +535,7 @@ def initialize(reloading=False):
         # gametext.start_text_monitor()
         os.makedirs(get_config().paths.folder_to_watch, exist_ok=True)
         os.makedirs(get_config().paths.output_folder, exist_ok=True)
+        set_get_audio_from_video_callback(VideoToAudioHandler.get_audio)
     initial_checks()
     register_websocket_message_handler(handle_websocket_message)
     # if get_config().vad.do_vad_postprocessing:

GameSentenceMiner/ocr/gsm_ocr_config.py

@@ -33,6 +33,7 @@ class Rectangle:
     monitor: Monitor
     coordinates: List[Union[float, int]]
     is_excluded: bool
+    is_secondary: bool = False
 
 @dataclass_json
 @dataclass
@@ -41,7 +42,8 @@ class WindowGeometry:
     top: int
     width: int
     height: int
-
+    
+    
 @dataclass_json
 @dataclass
 class OCRConfig:

GameSentenceMiner/ocr/owocr_area_selector.py

@@ -34,7 +34,7 @@ class ScreenSelector:
     def __init__(self, result, window_name, use_window_as_config, use_obs_screenshot=False):
         if not selector_available:
             raise RuntimeError("tkinter is not available.")
-        if not window_name:
+        if not window_name and not use_obs_screenshot:
             raise ValueError("A target window name is required for configuration.")
 
         obs.connect_to_obs_sync()
@@ -185,7 +185,7 @@ class ScreenSelector:
                     monitor_index = rect_data["monitor"]['index']
                     target_monitor = next((m for m in self.monitors if m['index'] == monitor_index), None)
                     if target_monitor:
-                        self.rectangles.append((target_monitor, abs_coords, rect_data["is_excluded"]))
+                        self.rectangles.append((target_monitor, abs_coords, rect_data["is_excluded"], rect_data.get("is_secondary", False)))
                         loaded_count += 1
                 except (KeyError, ValueError, TypeError) as e:
                     print(f"Skipping malformed rectangle data: {rect_data}, Error: {e}")
@@ -204,7 +204,7 @@ class ScreenSelector:
         print(f"Saving rectangles to: {config_path} relative to window: {win_geom}")
 
         serializable_rects = []
-        for monitor_dict, abs_coords, is_excluded in self.rectangles:
+        for monitor_dict, abs_coords, is_excluded, is_secondary in self.rectangles:
             x_abs, y_abs, w_abs, h_abs = abs_coords
 
             # Convert absolute pixel coordinates to percentages
@@ -217,7 +217,8 @@ class ScreenSelector:
             serializable_rects.append({
                 "monitor": {'index': monitor_dict['index']},
                 "coordinates": coords_to_save,
-                "is_excluded": is_excluded
+                "is_excluded": is_excluded,
+                "is_secondary": is_secondary
             })
 
         save_data = {
@@ -254,13 +255,14 @@ class ScreenSelector:
 
     def redo_last_rect(self, event=None):
         if not self.redo_stack: return
-        monitor, abs_coords, is_excluded, old_rect_id = self.redo_stack.pop()
+        monitor, abs_coords, is_excluded, is_secondary, old_rect_id = self.redo_stack.pop()
         canvas = event.widget.winfo_toplevel().winfo_children()[0]
         x_abs, y_abs, w_abs, h_abs = abs_coords
         canvas_x, canvas_y = x_abs - self.bounding_box['left'], y_abs - self.bounding_box['top']
+        outline_color = 'purple' if is_secondary else ('orange' if is_excluded else 'green')
         new_rect_id = canvas.create_rectangle(canvas_x, canvas_y, canvas_x + w_abs, canvas_y + h_abs,
-                                              outline='orange' if is_excluded else 'green', width=2)
-        self.rectangles.append((monitor, abs_coords, is_excluded))
+                                              outline=outline_color, width=2)
+        self.rectangles.append((monitor, abs_coords, is_excluded, is_secondary))
         self.drawn_rect_ids.append(new_rect_id)
         print("Redo: Restored rectangle.")
 
@@ -291,6 +293,7 @@ class ScreenSelector:
             "How to Use:\n"
             "• Left Click + Drag: Create a capture area (green).\n"
             "• Shift + Left Click + Drag: Create an exclusion area (orange).\n"
+            "• Ctrl + Left Click + Drag: Create a secondary (menu) area (purple).\n"
             "• Right-Click on a box: Delete it."
         )
         tk.Label(main_frame, text=instructions_text, justify=tk.LEFT, anchor="w").pack(pady=(0, 10), fill=tk.X)
@@ -426,17 +429,25 @@ class ScreenSelector:
         # --- END MODIFICATION ---
 
         # Draw existing rectangles (which were converted to absolute pixels on load)
-        for _, abs_coords, is_excluded in self.rectangles:
+        for _, abs_coords, is_excluded, is_secondary in self.rectangles:
             x_abs, y_abs, w_abs, h_abs = abs_coords
             canvas_x = x_abs - self.bounding_box['left']
             canvas_y = y_abs - self.bounding_box['top']
+            outline_color = 'purple' if is_secondary else ('orange' if is_excluded else 'green')
             rect_id = self.canvas.create_rectangle(canvas_x, canvas_y, canvas_x + w_abs, canvas_y + h_abs,
-                                              outline='orange' if is_excluded else 'green', width=2)
+                                              outline=outline_color, width=2)
             self.drawn_rect_ids.append(rect_id)
 
         def on_click(event):
             self.start_x, self.start_y = event.x, event.y
-            outline = 'purple' if bool(event.state & 0x0001) else 'red'
+            ctrl_held = bool(event.state & 0x0004)
+            shift_held = bool(event.state & 0x0001)
+            if ctrl_held:
+                outline = 'purple'
+            elif shift_held:
+                outline = 'orange'
+            else:
+                outline = 'green'
             self.current_rect_id = self.canvas.create_rectangle(self.start_x, self.start_y, self.start_x, self.start_y,
                                                            outline=outline, width=2)
 
@@ -451,8 +462,12 @@ class ScreenSelector:
             w, h = int(abs(coords[2] - coords[0])), int(abs(coords[3] - coords[1]))
 
             if w >= MIN_RECT_WIDTH and h >= MIN_RECT_HEIGHT:
-                is_excl = bool(event.state & 0x0001)
-                self.canvas.itemconfig(self.current_rect_id, outline='orange' if is_excl else 'green')
+                ctrl_held = bool(event.state & 0x0004)
+                shift_held = bool(event.state & 0x0001)
+                is_excl = shift_held
+                is_secondary = ctrl_held
+                outline_color = 'purple' if is_secondary else ('orange' if is_excl else 'green')
+                self.canvas.itemconfig(self.current_rect_id, outline=outline_color)
 
                 center_x, center_y = x_abs + w / 2, y_abs + h / 2
                 target_mon = self.monitors[0]
@@ -462,7 +477,7 @@ class ScreenSelector:
                         target_mon = mon
                         break
 
-                self.rectangles.append((target_mon, (x_abs, y_abs, w, h), is_excl))
+                self.rectangles.append((target_mon, (x_abs, y_abs, w, h), is_excl, is_secondary))
                 self.drawn_rect_ids.append(self.current_rect_id)
                 self.redo_stack.clear()
             else:
@@ -472,7 +487,7 @@ class ScreenSelector:
         def on_right_click(event):
             # Iterate through our rectangles in reverse to find the topmost one.
             for i in range(len(self.rectangles) - 1, -1, -1):
-                _monitor, abs_coords, _is_excluded = self.rectangles[i]
+                _monitor, abs_coords, _is_excluded, _is_secondary = self.rectangles[i]
                 x_abs, y_abs, w_abs, h_abs = abs_coords
                 canvas_x1 = x_abs - self.bounding_box['left']
                 canvas_y1 = y_abs - self.bounding_box['top']
@@ -540,7 +555,7 @@ def run_screen_selector(result_dict, window_name, use_window_as_config, use_obs_
 
 def get_screen_selection(window_name, use_window_as_config=False, use_obs_screenshot=False):
     if not selector_available: return None
-    if not window_name:
+    if not window_name and not use_obs_screenshot:
         print("Error: A target window name must be provided.", file=sys.stderr)
         return None
 
@@ -567,7 +582,7 @@ if __name__ == "__main__":
 
     parser = argparse.ArgumentParser(description="Screen Selector Arguments")
     parser.add_argument("window_title", nargs="?", default="", help="Target window title")
-    parser.add_argument("--obs_ocr", action="store_true", help="Use OBS screenshot")
+    parser.add_argument("--obs_ocr", action="store_true", default=True, help="Use OBS screenshot")
     parser.add_argument("--use_window_for_config", action="store_true", help="Use window for config")
     args = parser.parse_args()
 

GameSentenceMiner/ocr/owocr_helper.py

@@ -52,7 +52,6 @@ logger.addHandler(console_handler)
 def get_ocr_config(window=None, use_window_for_config=False) -> OCRConfig:
     """Loads and updates screen capture areas from the corresponding JSON file."""
     ocr_config_dir = get_ocr_config_path()
-    obs.connect_to_obs_sync(retry=0)
     obs.update_current_game()
     if use_window_for_config and window:
         scene = sanitize_filename(window)
@@ -202,7 +201,7 @@ def do_second_ocr(ocr1_text, time, img, filtering, pre_crop_image=None, ignore_f
     try:
         orig_text, text = run.process_and_write_results(img, None, last_ocr2_result if not ignore_previous_result else None, filtering, None,
                                                         engine=get_ocr_ocr2(), furigana_filter_sensitivity=furigana_filter_sensitivity if not ignore_furigana_filter else 0)
-
+        
         if compare_ocr_results(last_sent_result, text, threshold=80):
             if text:
                 logger.info("Seems like Text we already sent, not doing anything.")
@@ -447,6 +446,17 @@ def run_oneocr(ocr_config: OCRConfig, rectangles, config_check_thread):
 
 def add_ss_hotkey(ss_hotkey="ctrl+shift+g"):
     import keyboard
+
+    def ocr_secondary_rectangles():
+        logger.info("Running secondary OCR rectangles...")
+        ocr_config = get_ocr_config()
+        img = obs.get_screenshot_PIL(compression=80, img_format="jpg")
+        ocr_config.scale_to_custom_size(img.width, img.height)
+        img = run.apply_ocr_config_to_image(img, ocr_config, is_secondary=True)
+        do_second_ocr("", datetime.now(), img, TextFiltering(lang=get_ocr_language()), ignore_furigana_filter=True, ignore_previous_result=True)
+        
+    if not manual:
+        keyboard.add_hotkey(get_ocr_manual_ocr_hotkey().lower(), ocr_secondary_rectangles)
     secret_ss_hotkey = "F14"
     filtering = TextFiltering(lang=get_ocr_language())
     cropper = ScreenCropper()
@@ -544,6 +554,8 @@ if __name__ == "__main__":
         use_window_for_config = args.use_window_for_config
         keep_newline = args.keep_newline
         obs_ocr = args.obs_ocr
+        
+        obs.connect_to_obs_sync(retry=0)
     
         # Start config change checker thread
         config_check_thread = ConfigChangeCheckThread()

GameSentenceMiner/owocr/owocr/run.py

@@ -832,7 +832,6 @@ class OBSScreenshotThread(threading.Thread):
         super().__init__(daemon=True)
         self.ocr_config = ocr_config
         self.interval = interval
-        self.obs_client = None
         self.websocket = None
         self.current_source = None
         self.current_source_name = None
@@ -930,16 +929,6 @@ class OBSScreenshotThread(threading.Thread):
         init_config()
         start = time.time()
         while not terminated:
-            if time.time() - start > 5:
-                if not self.obs_client:
-                    self.connect_obs()
-                else:
-                    try:
-                        self.obs_client.get_version()
-                    except Exception as e:
-                        logger.error(f"Lost connection to OBS: {e}")
-                        self.obs_client = None
-                        self.connect_obs()
             if not screenshot_event.wait(timeout=0.1):
                 continue
 
@@ -990,15 +979,14 @@ class OBSScreenshotThread(threading.Thread):
                 continue
 
 
-def apply_ocr_config_to_image(img, ocr_config):
+def apply_ocr_config_to_image(img, ocr_config, is_secondary=False):
     for rectangle in ocr_config.rectangles:
         if rectangle.is_excluded:
             left, top, width, height = rectangle.coordinates
             draw = ImageDraw.Draw(img)
-            draw.rectangle((left, top, left + width, top +
-                           height), fill=(0, 0, 0, 0))
+            draw.rectangle((left, top, left + width, top + height), fill=(0, 0, 0, 0))
             
-    rectangles = [r for r in ocr_config.rectangles if not r.is_excluded]
+    rectangles = [r for r in ocr_config.rectangles if not r.is_excluded and r.is_secondary == is_secondary]
     
     # Sort top to bottom
     if rectangles:

GameSentenceMiner/util/configuration.py

@@ -843,7 +843,7 @@ def get_log_path():
 
 temp_directory = ''
 
-def get_temporary_directory(delete=True):
+def get_temporary_directory(delete=False):
     global temp_directory
     if not temp_directory:
         temp_directory = os.path.join(get_app_directory(), 'temp')

GameSentenceMiner/util/ffmpeg.py

@@ -117,7 +117,7 @@ def get_screenshot(video_file, screenshot_timing, try_selector=False):
             get_temporary_directory(),
             f"{obs.get_current_game(sanitize=True)}.png"))
         ffmpeg_command = ffmpeg_base_command_list + [
-            "-ss", f"{screenshot_timing}",  # Default to 1 second
+            "-ss", f"{screenshot_timing}",
             "-i", video_file,
             "-vframes", "1",
             output_image
@@ -222,7 +222,7 @@ def process_image(image_file):
                 break
     except Exception as e:
         logger.error(f"Error re-encoding screenshot: {e}. Defaulting to standard PNG.")
-        output_image = make_unique_file_name(get_temporary_directory(), f"{obs.get_current_game(sanitize=True)}.png")
+        output_image = make_unique_file_name(os.path.join(get_temporary_directory(), f"{obs.get_current_game(sanitize=True)}.png"))
         shutil.move(image_file, output_image)
 
     logger.info(f"Processed image saved to: {output_image}")
@@ -303,21 +303,21 @@ def trim_audio_based_on_last_line(untrimmed_audio, video_path, game_line, next_l
                                                 suffix=f".{get_config().audio.extension}").name
     start_trim_time, total_seconds, total_seconds_after_offset, file_length = get_video_timings(video_path, game_line, anki_card_creation_time)
     end_trim_time = 0
+    end_trim_seconds = 0
 
     ffmpeg_command = ffmpeg_base_command_list + [
         "-i", untrimmed_audio,
         "-ss", str(start_trim_time)]
     if next_line and next_line > game_line.time:
-        end_total_seconds = total_seconds + (next_line - game_line.time).total_seconds() + get_config().audio.pre_vad_end_offset
-        end_trim_time = f"{end_total_seconds:.3f}"
+        end_trim_seconds = total_seconds + (next_line - game_line.time).total_seconds() + get_config().audio.pre_vad_end_offset
+        end_trim_time = f"{end_trim_seconds:.3f}"
         ffmpeg_command.extend(['-to', end_trim_time])
         logger.debug(
             f"Looks Like this is mining from History, or Multiple Lines were selected Trimming end of audio to {end_trim_time} seconds")
     elif get_config().audio.pre_vad_end_offset and get_config().audio.pre_vad_end_offset < 0:
-        end_total_seconds = file_length + get_config().audio.pre_vad_end_offset
-        end_trim_time = f"{end_total_seconds:.3f}"
-        ffmpeg_command.extend(['-to', end_trim_time])
-        logger.debug(f"Trimming end of audio to {end_trim_time} seconds due to pre-vad end offset")
+        end_trim_seconds = file_length + get_config().audio.pre_vad_end_offset
+        ffmpeg_command.extend(['-to', str(end_trim_seconds)])
+        logger.debug(f"Trimming end of audio to {end_trim_seconds} seconds due to pre-vad end offset")
 
     ffmpeg_command.extend([
         "-c", "copy",  # Using copy to avoid re-encoding, adjust if needed
@@ -326,18 +326,18 @@ def trim_audio_based_on_last_line(untrimmed_audio, video_path, game_line, next_l
 
     logger.debug(" ".join(ffmpeg_command))
     subprocess.run(ffmpeg_command)
-    gsm_state.previous_trim_args = (untrimmed_audio, start_trim_time, end_trim_time)
+    gsm_state.previous_trim_args = (untrimmed_audio, start_trim_time, end_trim_seconds)
 
     logger.debug(f"{total_seconds_after_offset} trimmed off of beginning")
 
-    if end_trim_time:
-        logger.info(f"Audio Extracted and trimmed to {start_trim_time} seconds with end time {end_trim_time}")
+    if end_trim_seconds:
+        logger.info(f"Audio Extracted and trimmed to {start_trim_time} seconds with end time {end_trim_seconds} seconds")
     else:
         logger.info(f"Audio Extracted and trimmed to {start_trim_time} seconds")
         
     
     logger.debug(f"Audio trimmed and saved to {trimmed_audio}")
-    return trimmed_audio, start_trim_time, end_trim_time
+    return trimmed_audio, start_trim_time, end_trim_seconds
 
 def get_video_timings(video_path, game_line, anki_card_creation_time=None):
     if anki_card_creation_time:

GameSentenceMiner/web/service.py

@@ -11,7 +11,12 @@ from GameSentenceMiner.util.ffmpeg import get_video_timings
 from GameSentenceMiner.util.text_log import GameLine
 
 
-def handle_texthooker_button(video_path='', get_audio_from_video=None):
+def set_get_audio_from_video_callback(func):
+    global get_audio_from_video
+    get_audio_from_video = func
+
+
+def handle_texthooker_button(video_path=''):
     try:
         if gsm_state.line_for_audio:
             line: GameLine = gsm_state.line_for_audio

GameSentenceMiner/web/texthooking_page.py

@@ -52,6 +52,7 @@ class EventItem:
             'history': self.history,
         }
 
+
 class EventManager:
     events: list[EventItem]
     events_dict: dict[str, EventItem] = {}
@@ -87,7 +88,8 @@ class EventManager:
             event_id, line_id, text, timestamp = row
             timestamp = datetime.datetime.fromisoformat(timestamp)
             line = GameLine(line_id, text, timestamp, None, None, 0)
-            event = EventItem(line, event_id, text, timestamp, False, timestamp < initial_time)
+            event = EventItem(line, event_id, text, timestamp,
+                              False, timestamp < initial_time)
             self.events.append(event)
             self.ids.append(event_id)
             self.events_dict[event_id] = event
@@ -99,7 +101,8 @@ class EventManager:
         self.events = new_events
 
     def add_gameline(self, line: GameLine):
-        new_event = EventItem(line, line.id, line.text, line.time, False, False)
+        new_event = EventItem(line, line.id, line.text,
+                              line.time, False, False)
         self.events_dict[line.id] = new_event
         self.ids.append(line.id)
         self.events.append(new_event)
@@ -130,12 +133,16 @@ class EventManager:
             self.conn.close()
 
     def clear_history(self):
-        self.cursor.execute("DELETE FROM events WHERE time < ?", (initial_time.isoformat(),))
+        self.cursor.execute("DELETE FROM events WHERE time < ?",
+                            (initial_time.isoformat(),))
         logger.info(f"Cleared history before {initial_time.isoformat()}")
         self.conn.commit()
         # Clear the in-memory events as well
-        event_manager.events = [event for event in event_manager if not event.history]
-        event_manager.events_dict = {event.id: event for event in event_manager.events}
+        event_manager.events = [
+            event for event in event_manager if not event.history]
+        event_manager.events_dict = {
+            event.id: event for event in event_manager.events}
+
 
 class EventProcessor(threading.Thread):
     def __init__(self, event_queue, db_path):
@@ -173,6 +180,7 @@ class EventProcessor(threading.Thread):
         if self.conn:
             self.conn.close()
 
+
 event_manager = EventManager()
 event_queue = queue.Queue()
 
@@ -185,6 +193,8 @@ server_start_time = datetime.datetime.now().timestamp()
 app = flask.Flask(__name__)
 
 # Load data from the JSON file
+
+
 def load_data_from_file():
     if os.path.exists(TEXT_REPLACEMENTS_FILE):
         with open(TEXT_REPLACEMENTS_FILE, 'r', encoding='utf-8') as file:
@@ -192,10 +202,13 @@ def load_data_from_file():
     return {"enabled": True, "args": {"replacements": {}}}
 
 # Save data to the JSON file
+
+
 def save_data_to_file(data):
     with open(TEXT_REPLACEMENTS_FILE, 'w', encoding='utf-8') as file:
         json.dump(data, file, indent=4, ensure_ascii=False)
 
+
 @app.route('/load-data', methods=['GET'])
 def load_data():
     try:
@@ -204,6 +217,7 @@ def load_data():
     except Exception as e:
         return jsonify({"error": f"Failed to load data: {str(e)}"}), 500
 
+
 @app.route('/save-data', methods=['POST'])
 def save_data():
     try:
@@ -217,40 +231,49 @@ def save_data():
     except Exception as e:
         return jsonify({"error": f"Failed to save data: {str(e)}"}), 500
 
+
 def inject_server_start_time(html_content, timestamp):
     placeholder = '<script>'
     replacement = f'<script>const serverStartTime = {timestamp};'
     return html_content.replace(placeholder, replacement)
 
+
 @app.route('/favicon.ico')
 def favicon():
     return send_from_directory(os.path.join(app.root_path, 'static'),
                                'favicon.ico', mimetype='image/vnd.microsoft.icon')
 
+
 @app.route('/<path:filename>')
 def serve_static(filename):
     return send_from_directory('pages', filename)
 
+
 @app.route('/')
 def index():
     return send_from_directory('templates', 'index.html')
 
+
 @app.route('/texthooker')
 def texthooker():
     return send_from_directory('templates', 'index.html')
 
+
 @app.route('/textreplacements')
 def textreplacements():
     return flask.render_template('text_replacements.html')
 
+
 @app.route('/data', methods=['GET'])
 def get_data():
     return jsonify([event.to_dict() for event in event_manager])
 
+
 @app.route('/get_ids', methods=['GET'])
 def get_ids():
     return jsonify(event_manager.get_ids())
 
+
 @app.route('/clear_history', methods=['POST'])
 def clear_history():
     temp_em = EventManager()
@@ -268,8 +291,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)
-        
-        
+
+
 async def send_word_coordinates_to_overlay(boxes):
     if boxes and len(boxes) > 0 and overlay_server_thread:
         await overlay_server_thread.send_text(boxes)
@@ -286,6 +309,7 @@ def update_event():
     event_manager.get(event_id).checked = not event.checked
     return jsonify({'message': 'Event updated successfully'}), 200
 
+
 @app.route('/get-screenshot', methods=['Post'])
 def get_screenshot():
     """Endpoint to get a screenshot of the current game screen."""
@@ -294,12 +318,13 @@ def get_screenshot():
     if event_id is None:
         return jsonify({'error': 'Missing id'}), 400
     gsm_state.line_for_screenshot = get_line_by_id(event_id)
-    if gsm_state.previous_line_for_screenshot and gsm_state.line_for_screenshot.id == gsm_state.previous_line_for_screenshot.id or gsm_state.previous_line_for_audio:
+    if gsm_state.previous_line_for_screenshot and gsm_state.line_for_screenshot == gsm_state.previous_line_for_screenshot or gsm_state.previous_line_for_audio and gsm_state.line_for_screenshot == gsm_state.previous_line_for_audio:
         handle_texthooker_button(gsm_state.previous_replay)
     else:
         obs.save_replay_buffer()
     return jsonify({}), 200
 
+
 @app.route('/play-audio', methods=['POST'])
 def play_audio():
     """Endpoint to play audio for a specific event."""
@@ -307,13 +332,16 @@ def play_audio():
     event_id = data.get('id')
     if event_id is None:
         return jsonify({'error': 'Missing id'}), 400
+    print(f"Playing audio for event ID: {event_id}")
     gsm_state.line_for_audio = get_line_by_id(event_id)
-    if gsm_state.previous_line_for_audio and gsm_state.line_for_audio == gsm_state.previous_line_for_audio or gsm_state.previous_line_for_screenshot:
+    print(f"gsm_state.line_for_audio: {gsm_state.line_for_audio}")
+    if gsm_state.previous_line_for_audio and gsm_state.line_for_audio == gsm_state.previous_line_for_audio or gsm_state.previous_line_for_screenshot and gsm_state.line_for_audio == gsm_state.previous_line_for_screenshot:
         handle_texthooker_button(gsm_state.previous_replay)
     else:
         obs.save_replay_buffer()
     return jsonify({}), 200
 
+
 @app.route("/translate-line", methods=['POST'])
 def translate_line():
     data = request.get_json()
@@ -362,9 +390,11 @@ def get_status():
 def get_selected_lines():
     return [item.line for item in event_manager if item.checked]
 
+
 def are_lines_selected():
     return any(item.checked for item in event_manager)
 
+
 def reset_checked_lines():
     async def send_reset_message():
         await websocket_server_thread.send_text({
@@ -373,9 +403,11 @@ def reset_checked_lines():
     event_manager.reset_checked_lines()
     asyncio.run(send_reset_message())
 
+
 def open_texthooker():
     webbrowser.open(url + '/texthooker')
 
+
 def start_web_server():
     logger.debug("Starting web server...")
     import logging
@@ -386,7 +418,8 @@ def start_web_server():
     if get_config().general.open_multimine_on_startup:
         open_texthooker()
 
-    app.run(host='0.0.0.0', port=port, debug=False) # debug=True provides helpful error messages during development
+    # debug=True provides helpful error messages during development
+    app.run(host='0.0.0.0', port=port, debug=False)
 
 
 websocket_queue = queue.Queue()
@@ -445,7 +478,7 @@ class WebsocketServerThread(threading.Thread):
                 text = json.dumps(text)
             return asyncio.run_coroutine_threadsafe(
                 self.send_text_coroutine(text), self.loop)
-            
+
     def has_clients(self):
         return len(self.clients) > 0
 
@@ -467,24 +500,30 @@ class WebsocketServerThread(threading.Thread):
                         await stop_event.wait()
                     return
                 except Exception as e:
-                    logger.warning(f"WebSocket server encountered an error: {e}. Retrying...")
+                    logger.warning(
+                        f"WebSocket server encountered an error: {e}. Retrying...")
                     await asyncio.sleep(1)
 
         asyncio.run(main())
 
+
 def handle_exit_signal(loop):
     logger.info("Received exit signal. Shutting down...")
     for task in asyncio.all_tasks(loop):
         task.cancel()
-        
-websocket_server_thread = WebsocketServerThread(read=True, get_ws_port_func=lambda : get_config().get_field_value('advanced', 'texthooker_communication_websocket_port'))
+
+
+websocket_server_thread = WebsocketServerThread(read=True, get_ws_port_func=lambda: get_config(
+).get_field_value('advanced', 'texthooker_communication_websocket_port'))
 websocket_server_thread.start()
 
 if get_config().advanced.plaintext_websocket_port:
-    plaintext_websocket_server_thread = WebsocketServerThread(read=False, get_ws_port_func=lambda : get_config().get_field_value('advanced', 'plaintext_websocket_port'))
+    plaintext_websocket_server_thread = WebsocketServerThread(
+        read=False, get_ws_port_func=lambda: get_config().get_field_value('advanced', 'plaintext_websocket_port'))
     plaintext_websocket_server_thread.start()
-    
-overlay_server_thread = WebsocketServerThread(read=False, get_ws_port_func=lambda : get_config().get_field_value('wip', 'overlay_websocket_port'))
+
+overlay_server_thread = WebsocketServerThread(
+    read=False, get_ws_port_func=lambda: get_config().get_field_value('wip', 'overlay_websocket_port'))
 overlay_server_thread.start()
 
 websocket_server_threads = [
@@ -493,6 +532,7 @@ websocket_server_threads = [
     overlay_server_thread
 ]
 
+
 async def texthooker_page_coro():
     global websocket_server_thread, plaintext_websocket_server_thread, overlay_server_thread
     # Run the WebSocket server in the asyncio event loop
@@ -502,11 +542,13 @@ async def texthooker_page_coro():
 
     # Keep the main asyncio event loop running (for the WebSocket server)
 
+
 def run_text_hooker_page():
     try:
         asyncio.run(texthooker_page_coro())
     except KeyboardInterrupt:
         logger.info("Shutting down due to KeyboardInterrupt.")
 
+
 if __name__ == '__main__':
-    asyncio.run(texthooker_page_coro())
+    asyncio.run(texthooker_page_coro())

{gamesentenceminer-2.13.9.dist-info → gamesentenceminer-2.13.11.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: GameSentenceMiner
-Version: 2.13.9
+Version: 2.13.11
 Summary: A tool for mining sentences from games. Update: Overlay?
 Author-email: Beangate <bpwhelan95@gmail.com>
 License: MIT License

{gamesentenceminer-2.13.9.dist-info → gamesentenceminer-2.13.11.dist-info}/RECORD

@@ -2,7 +2,7 @@ GameSentenceMiner/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU
 GameSentenceMiner/anki.py,sha256=zBvKvu-LBaUmG1bUNLq9QXmVoPidqZCxJn4UPw6pUug,21041
 GameSentenceMiner/config_gui.py,sha256=BeI5Mz9CqDsW08fn1BNzZNUegEmHZsxkDmST8rY2jqU,125738
 GameSentenceMiner/gametext.py,sha256=h6IOGesK79X8IlvqqMmSzRkSVtkPAXDMHrkQsBwEV1E,10879
-GameSentenceMiner/gsm.py,sha256=EKt7WFPWLWdf2C8VOELakpgU7y0GXlqdRXtXQmN3Jok,28283
+GameSentenceMiner/gsm.py,sha256=MTopfkJB_URJOenXeX_ZAtOoMsM7GFazawNA2QdUc_Q,28254
 GameSentenceMiner/obs.py,sha256=smlP_BFuuMkASVDEPG3DjxJ6p617kZXuNTeQ0edtH64,18703
 GameSentenceMiner/vad.py,sha256=zFReBMvNEEaQ_YEozCTCaMdV-o40FwtlxYRb17cYZio,19125
 GameSentenceMiner/ai/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -19,23 +19,23 @@ GameSentenceMiner/locales/en_us.json,sha256=9aFJw4vls269_ufnVx03uRLXG8-E-hdG9hJ9
 GameSentenceMiner/locales/ja_jp.json,sha256=zx5R_DLsdUw9Szg7RrOkRprMcnumM5Bnl4QhsfOj-qM,27190
 GameSentenceMiner/locales/zh_cn.json,sha256=fwP5GQh0WkftdpXuyyt9IiaEIPK_ZXtEa_3kmoeQMAk,24198
 GameSentenceMiner/ocr/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-GameSentenceMiner/ocr/gsm_ocr_config.py,sha256=Ezj-0k6Wo-una91FvYhMp6KGkRhWYihXzLAoh_Wu2xY,5329
+GameSentenceMiner/ocr/gsm_ocr_config.py,sha256=7h_nfC7TRQQXW-zkYT0YLvupGBCxlIp62NDOwAASxiI,5369
 GameSentenceMiner/ocr/ocrconfig.py,sha256=_tY8mjnzHMJrLS8E5pHqYXZjMuLoGKYgJwdhYgN-ny4,6466
-GameSentenceMiner/ocr/owocr_area_selector.py,sha256=tlzQp0uVT-OdM99IqycA58hBbVb4c8LdTAope2hUXWg,27319
-GameSentenceMiner/ocr/owocr_helper.py,sha256=EDKDhmZ0kF1xNmw2obZwAdXj-L-zDK09JGZPTJBja-c,26523
+GameSentenceMiner/ocr/owocr_area_selector.py,sha256=Y505tm7KT18flaIyFUe5DfBcBo99e9P3nQDgF4NTmbI,28209
+GameSentenceMiner/ocr/owocr_helper.py,sha256=_FHwiSNsKvRGWwu9huAepbr2Hpij1ewNxSQC4Gwrd7o,27156
 GameSentenceMiner/ocr/ss_picker.py,sha256=0IhxUdaKruFpZyBL-8SpxWg7bPrlGpy3lhTcMMZ5rwo,5224
 GameSentenceMiner/owocr/owocr/__init__.py,sha256=87hfN5u_PbL_onLfMACbc0F5j4KyIK9lKnRCj6oZgR0,49
 GameSentenceMiner/owocr/owocr/__main__.py,sha256=XQaqZY99EKoCpU-gWQjNbTs7Kg17HvBVE7JY8LqIE0o,157
 GameSentenceMiner/owocr/owocr/config.py,sha256=qM7kISHdUhuygGXOxmgU6Ef2nwBShrZtdqu4InDCViE,8103
 GameSentenceMiner/owocr/owocr/lens_betterproto.py,sha256=oNoISsPilVVRBBPVDtb4-roJtAhp8ZAuFTci3TGXtMc,39141
 GameSentenceMiner/owocr/owocr/ocr.py,sha256=L_Dhy5qoSmVNtzBGVHM8aCJtfFsgqbSdTqXd1Obh1EM,62531
-GameSentenceMiner/owocr/owocr/run.py,sha256=asd5RsYRlsN7FhnMgbjDcN_m3QtVCWzysb6P9_rplMY,68523
+GameSentenceMiner/owocr/owocr/run.py,sha256=0rsxeIlUys_bpwKDTfBwjER2FpgXKbfzM6lOxgFzzWU,68086
 GameSentenceMiner/owocr/owocr/screen_coordinate_picker.py,sha256=Na6XStbQBtpQUSdbN3QhEswtKuU1JjReFk_K8t5ezQE,3395
 GameSentenceMiner/util/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 GameSentenceMiner/util/audio_offset_selector.py,sha256=8Stk3BP-XVIuzRv9nl9Eqd2D-1yD3JrgU-CamBywJmY,8542
-GameSentenceMiner/util/configuration.py,sha256=U87lD-e28b_0Rn15y6sLRY0NoHf0_mukyFCIucJyBb8,37183
+GameSentenceMiner/util/configuration.py,sha256=p0ZnrPa0UTFzj59y__pNy0aWOxjlHz1fURZI33qWu74,37184
 GameSentenceMiner/util/electron_config.py,sha256=9CA27nzEFlxezzDqOPHxeD4BdJ093AnSJ9DJTcwWPsM,8762
-GameSentenceMiner/util/ffmpeg.py,sha256=fQakPhT4ZtUojwPVLGFcly1VNRfoth8STdtJLy_9X2g,23527
+GameSentenceMiner/util/ffmpeg.py,sha256=HI2H_prbiZtLtLQgYOj1QNu0Ik_8Du_7gtoHftaz1g4,23520
 GameSentenceMiner/util/gsm_utils.py,sha256=Piwv88Q9av2LBeN7M6QDi0Mp0_R2lNbkcI6ekK5hd2o,11851
 GameSentenceMiner/util/model.py,sha256=hmA_seopP2bK40v9T4ulua9TrAeWtbkdCv-sTBPBQDk,6660
 GameSentenceMiner/util/notification.py,sha256=-qk3kTKEERzmMxx5XMh084HCyFmbfqz0XjY1hTKhCeQ,4202
@@ -51,8 +51,8 @@ GameSentenceMiner/util/downloader/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeR
 GameSentenceMiner/util/downloader/download_tools.py,sha256=zR-aEHiFVkyo-9oPoSx6nQ2K-_J8WBHLZyLoOhypsW4,8458
 GameSentenceMiner/util/downloader/oneocr_dl.py,sha256=l3s9Z-x1b57GX048o5h-MVv0UTZo4H-Q-zb-JREkMLI,10439
 GameSentenceMiner/web/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-GameSentenceMiner/web/service.py,sha256=S7bYf2kSk08u-8R9Qpv7piM-pxfFjYZUvU825xupmuI,5279
-GameSentenceMiner/web/texthooking_page.py,sha256=Mled45nQBh_Eb1vH4bLEqseMtrBmS2Vw9G9XxiPaSEQ,17525
+GameSentenceMiner/web/service.py,sha256=YZchmScTn7AX_GkwV1ULEK6qjdOnJcpc3qfMwDf7cUE,5363
+GameSentenceMiner/web/texthooking_page.py,sha256=qCNtWtWZAiC91uPrHD2LUWdHOufVuzDhTyTH8Z4oXXk,17927
 GameSentenceMiner/web/static/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 GameSentenceMiner/web/static/apple-touch-icon.png,sha256=OcMI8af_68DA_tweOsQ5LytTyMwm7-hPW07IfrOVgEs,46132
 GameSentenceMiner/web/static/favicon-96x96.png,sha256=lOePzjiKl1JY2J1kT_PMdyEnrlJmi5GWbmXJunM12B4,16502
@@ -67,9 +67,9 @@ GameSentenceMiner/web/templates/index.html,sha256=Gv3CJvNnhAzIVV_QxhNq4OD-pXDt1v
 GameSentenceMiner/web/templates/text_replacements.html,sha256=tV5c8mCaWSt_vKuUpbdbLAzXZ3ATZeDvQ9PnnAfqY0M,8598
 GameSentenceMiner/web/templates/utility.html,sha256=3flZinKNqUJ7pvrZk6xu__v67z44rXnaK7UTZ303R-8,16946
 GameSentenceMiner/wip/get_overlay_coords.py,sha256=nJRytHJwUBToXeAIkf45HP7Yv42YO-ILbP5h8GVeE2Q,19791
-gamesentenceminer-2.13.9.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-gamesentenceminer-2.13.9.dist-info/METADATA,sha256=XDe-B_AOtfP-Kno8LypRFVvCfU80qZZylxnB1N9eWKM,1463
-gamesentenceminer-2.13.9.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-gamesentenceminer-2.13.9.dist-info/entry_points.txt,sha256=2APEP25DbfjSxGeHtwBstMH8mulVhLkqF_b9bqzU6vQ,65
-gamesentenceminer-2.13.9.dist-info/top_level.txt,sha256=V1hUY6xVSyUEohb0uDoN4UIE6rUZ_JYx8yMyPGX4PgQ,18
-gamesentenceminer-2.13.9.dist-info/RECORD,,
+gamesentenceminer-2.13.11.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+gamesentenceminer-2.13.11.dist-info/METADATA,sha256=Vie4cbRkyravU04SbKb0ra2P-2t2-QZTrmnCdrtMQ8g,1464
+gamesentenceminer-2.13.11.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+gamesentenceminer-2.13.11.dist-info/entry_points.txt,sha256=2APEP25DbfjSxGeHtwBstMH8mulVhLkqF_b9bqzU6vQ,65
+gamesentenceminer-2.13.11.dist-info/top_level.txt,sha256=V1hUY6xVSyUEohb0uDoN4UIE6rUZ_JYx8yMyPGX4PgQ,18
+gamesentenceminer-2.13.11.dist-info/RECORD,,