GameSentenceMiner 2.8.41__tar.gz → 2.8.42__tar.gz

{gamesentenceminer-2.8.41 → gamesentenceminer-2.8.42}/GameSentenceMiner/anki.py

@@ -14,7 +14,7 @@ from GameSentenceMiner.configuration import get_config
 from GameSentenceMiner.model import AnkiCard
 from GameSentenceMiner.text_log import get_all_lines, get_text_event, get_mined_line
 from GameSentenceMiner.obs import get_current_game
-from GameSentenceMiner.util import remove_html_and_cloze_tags, combine_dialogue
+from GameSentenceMiner.util import remove_html_and_cloze_tags, combine_dialogue, wait_for_stable_file
 from GameSentenceMiner.web import texthooking_page
 
 audio_in_anki = None
@@ -41,11 +41,13 @@ def update_anki_card(last_note: AnkiCard, note=None, audio_path='', video_path='
             audio_in_anki = store_media_file(audio_path)
         if update_picture:
             screenshot = ffmpeg.get_screenshot(video_path, ss_time)
+            wait_for_stable_file(screenshot)
             screenshot_in_anki = store_media_file(screenshot)
             if get_config().paths.remove_screenshot:
                 os.remove(screenshot)
         if get_config().anki.previous_image_field:
             prev_screenshot = ffmpeg.get_screenshot_for_line(video_path, selected_lines[0].prev if selected_lines else game_line.prev)
+            wait_for_stable_file(prev_screenshot)
             prev_screenshot_in_anki = store_media_file(prev_screenshot)
             if get_config().paths.remove_screenshot:
                 os.remove(prev_screenshot)
@@ -178,7 +180,11 @@ def get_initial_card_info(last_note: AnkiCard, selected_lines):
 
 
 def store_media_file(path):
-    return invoke('storeMediaFile', filename=path, data=convert_to_base64(path))
+    try:
+        return invoke('storeMediaFile', filename=path, data=convert_to_base64(path))
+    except Exception as e:
+        logger.error(f"Error storing media file, check anki card for blank media fields: {e}")
+        return "None"
 
 
 def convert_to_base64(file_path):

{gamesentenceminer-2.8.41 → gamesentenceminer-2.8.42}/GameSentenceMiner/ffmpeg.py

@@ -1,3 +1,4 @@
+import shutil
 import tempfile
 
 from GameSentenceMiner import obs, util, configuration
@@ -15,13 +16,65 @@ def get_ffprobe_path():
 ffmpeg_base_command_list = [get_ffmpeg_path(), "-hide_banner", "-loglevel", "error", '-nostdin']
 
 
-def get_screenshot(video_file, screenshot_timing):
+def call_frame_extractor(video_path, timestamp):
+    """
+    Calls the video frame extractor script and captures the output.
+
+    Args:
+        video_path (str): Path to the video file.
+        timestamp (str): Timestamp string (HH:MM:SS).
+
+    Returns:
+        str: The path of the selected image, or None on error.
+    """
+    try:
+        # Get the directory of the current script
+        current_dir = os.path.dirname(os.path.abspath(__file__))
+        # Construct the path to the frame extractor script
+        script_path = os.path.join(current_dir, "ss_selector.py")  # Replace with the actual script name if different
+
+        logger.info(' '.join([sys.executable, "-m", "GameSentenceMiner.ss_selector", video_path, str(timestamp)]))
+
+        # Run the script using subprocess.run()
+        result = subprocess.run(
+            [sys.executable, "-m", "GameSentenceMiner.ss_selector", video_path, str(timestamp), get_config().screenshot.screenshot_timing_setting],  # Use sys.executable
+            capture_output=True,
+            text=True,  # Get output as text
+            check=False  # Raise an exception for non-zero exit codes
+        )
+        if result.returncode != 0:
+            logger.error(f"Script failed with return code: {result.returncode}")
+            return None
+        logger.info(result)
+        # Print the standard output
+        logger.info(f"Frame extractor script output: {result.stdout.strip()}")
+        return result.stdout.strip() # Return the output
+
+    except subprocess.CalledProcessError as e:
+        logger.error(f"Error calling script: {e}")
+        logger.error(f"Script output (stderr): {e.stderr.strip()}")
+        return None
+    except FileNotFoundError:
+        logger.error(f"Error: Script not found at {script_path}.  Make sure the script name is correct.")
+        return None
+    except Exception as e:
+        logger.error(f"An unexpected error occurred: {e}")
+        return None
+
+def get_screenshot(video_file, screenshot_timing, try_selector=False):
     screenshot_timing = screenshot_timing if screenshot_timing else 1
+    if try_selector:
+        filepath = call_frame_extractor(video_path=video_file, timestamp=screenshot_timing)
+        output = process_image(filepath)
+        if output:
+            return output
+        else:
+            logger.error("Frame extractor script failed to run or returned no output, defaulting")
     output_image = make_unique_file_name(os.path.join(
         get_config().paths.screenshot_destination, f"{obs.get_current_game(sanitize=True)}.{get_config().screenshot.extension}"))
     # FFmpeg command to extract the last frame of the video
     ffmpeg_command = ffmpeg_base_command_list + [
-        "-ss", f"{screenshot_timing}",  # Seek to 1 second after the beginning
+        "-ss", f"{screenshot_timing}",
         "-i", f"{video_file}",
         "-vframes", "1"  # Extract only one frame
     ]
@@ -39,15 +92,33 @@ def get_screenshot(video_file, screenshot_timing):
 
     logger.debug(f"FFMPEG SS Command: {ffmpeg_command}")
 
-    # Run the command
-    subprocess.run(ffmpeg_command)
+    try:
+        for i in range(3):
+            logger.debug(" ".join(ffmpeg_command))
+            result = subprocess.run(ffmpeg_command)
+            if result.returncode != 0 and i < 2:
+                raise RuntimeError(f"FFmpeg command failed with return code {result.returncode}")
+            else:
+                break
+    except Exception as e:
+        logger.error(f"Error running FFmpeg command: {e}. Defaulting to standard PNG.")
+        output_image = make_unique_file_name(os.path.join(
+            get_config().paths.screenshot_destination,
+            f"{obs.get_current_game(sanitize=True)}.png"))
+        ffmpeg_command = ffmpeg_base_command_list + [
+            "-ss", f"{screenshot_timing}",  # Default to 1 second
+            "-i", video_file,
+            "-vframes", "1",
+            output_image
+        ]
+        subprocess.run(ffmpeg_command)
 
     logger.debug(f"Screenshot saved to: {output_image}")
 
     return output_image
 
-def get_screenshot_for_line(video_file, game_line):
-    return get_screenshot(video_file, get_screenshot_time(video_file, game_line))
+def get_screenshot_for_line(video_file, game_line, try_selector=False):
+    return get_screenshot(video_file, get_screenshot_time(video_file, game_line), try_selector)
 
 
 def get_screenshot_time(video_path, game_line, default_beginning=False, vad_result=None, doing_multi_line=False, previous_line=False):
@@ -127,7 +198,18 @@ def process_image(image_file):
     logger.debug(ffmpeg_command)
     logger.debug(" ".join(ffmpeg_command))
     # Run the command
-    subprocess.run(ffmpeg_command)
+    try:
+        for i in range(3):
+            logger.debug(" ".join(ffmpeg_command))
+            result = subprocess.run(ffmpeg_command)
+            if result.returncode != 0 and i < 2:
+                raise RuntimeError(f"FFmpeg command failed with return code {result.returncode}")
+            else:
+                break
+    except Exception as e:
+        logger.error(f"Error re-encoding screenshot: {e}. Defaulting to standard PNG.")
+        output_image = make_unique_file_name(os.path.join(get_config().paths.screenshot_destination, f"{obs.get_current_game(sanitize=True)}.png"))
+        shutil.move(image_file, output_image)
 
     logger.info(f"Processed image saved to: {output_image}")
 

{gamesentenceminer-2.8.41 → gamesentenceminer-2.8.42}/GameSentenceMiner/gsm.py

@@ -82,7 +82,7 @@ class VideoToAudioHandler(FileSystemEventHandler):
             if texthooking_page.event_manager.line_for_screenshot:
                 line: GameLine = texthooking_page.event_manager.line_for_screenshot
                 texthooking_page.event_manager.line_for_screenshot = None
-                screenshot = ffmpeg.get_screenshot_for_line(video_path, line)
+                screenshot = ffmpeg.get_screenshot_for_line(video_path, line, True)
                 os.startfile(screenshot)
                 os.remove(video_path)
                 return
@@ -92,10 +92,11 @@ class VideoToAudioHandler(FileSystemEventHandler):
             os.remove(video_path)
             return
         try:
-            last_note = None
-            anki_card_creation_time = None
             if anki.card_queue and len(anki.card_queue) > 0:
                 last_note, anki_card_creation_time = anki.card_queue.pop(0)
+            else:
+                logger.info("Replay buffer initiated externally. Skipping processing.")
+                return
             with util.lock:
                 util.set_last_mined_line(anki.get_sentence(last_note))
                 if os.path.exists(video_path) and os.access(video_path, os.R_OK):

gamesentenceminer-2.8.42/GameSentenceMiner/obs_back.py

@@ -0,0 +1,309 @@
+import os.path
+import subprocess
+import threading
+import time
+import psutil
+
+from obswebsocket import obsws, requests, events
+from obswebsocket.exceptions import ConnectionFailure
+
+from GameSentenceMiner import util, configuration
+from GameSentenceMiner.configuration import *
+from GameSentenceMiner.model import *
+
+client: obsws = None
+obs_process_pid = None
+# logging.getLogger('obswebsocket').setLevel(logging.CRITICAL)
+OBS_PID_FILE = os.path.join(configuration.get_app_directory(), 'obs-studio', 'obs_pid.txt')
+
+# REFERENCE: https://github.com/obsproject/obs-websocket/blob/master/docs/generated/protocol.md
+
+
+def get_obs_path():
+    return os.path.join(configuration.get_app_directory(), 'obs-studio/bin/64bit/obs64.exe')
+
+def is_process_running(pid):
+    try:
+        process = psutil.Process(pid)
+        return 'obs' in process.exe()
+    except (psutil.NoSuchProcess, psutil.AccessDenied, OSError):
+        if os.path.exists(OBS_PID_FILE):
+            os.remove(OBS_PID_FILE)
+        return False
+
+def start_obs():
+    global obs_process_pid
+    if os.path.exists(OBS_PID_FILE):
+        with open(OBS_PID_FILE, "r") as f:
+            try:
+                obs_process_pid = int(f.read().strip())
+                if is_process_running(obs_process_pid):
+                    print(f"OBS is already running with PID: {obs_process_pid}")
+                    connect_to_obs()
+                    return obs_process_pid
+            except ValueError:
+                print("Invalid PID found in file. Launching new OBS instance.")
+            except OSError:
+                print("No process found with the stored PID. Launching new OBS instance.")
+
+    obs_path = get_obs_path()
+    if not os.path.exists(obs_path):
+        print(f"OBS not found at {obs_path}. Please install OBS.")
+        return None
+    try:
+        obs_process = subprocess.Popen([obs_path, '--disable-shutdown-check', '--portable', '--startreplaybuffer', ], cwd=os.path.dirname(obs_path))
+        obs_process_pid = obs_process.pid
+        connect_to_obs()
+        with open(OBS_PID_FILE, "w") as f:
+            f.write(str(obs_process_pid))
+        print(f"OBS launched with PID: {obs_process_pid}")
+        return obs_process_pid
+    except Exception as e:
+        print(f"Error launching OBS: {e}")
+        return None
+
+def check_obs_folder_is_correct():
+    obs_record_directory = get_record_directory()
+    if obs_record_directory and os.path.normpath(obs_record_directory) != os.path.normpath(
+            get_config().paths.folder_to_watch):
+        logger.info("OBS Path Setting wrong, OBS Recording folder in GSM Config")
+        get_config().paths.folder_to_watch = os.path.normpath(obs_record_directory)
+        get_master_config().sync_shared_fields()
+        save_full_config(get_master_config())
+
+
+def get_obs_websocket_config_values():
+    config_path = os.path.join(get_app_directory(), 'obs-studio', 'config', 'obs-studio', 'plugin_config', 'obs-websocket', 'config.json')
+
+        # Check if config file exists
+    if not os.path.isfile(config_path):
+        raise FileNotFoundError(f"OBS WebSocket config not found at {config_path}")
+
+    # Read the JSON configuration
+    with open(config_path, 'r') as file:
+        config = json.load(file)
+
+    # Extract values
+    server_enabled = config.get("server_enabled", False)
+    server_port = config.get("server_port", 7274)  # Default to 4455 if not set
+    server_password = config.get("server_password", None)
+
+    if not server_enabled:
+        logger.info("OBS WebSocket server is not enabled. Enabling it now... Restart OBS for changes to take effect.")
+        config["server_enabled"] = True
+
+        with open(config_path, 'w') as file:
+            json.dump(config, file, indent=4)
+
+    if get_config().obs.password == 'your_password':
+        logger.info("OBS WebSocket password is not set. Setting it now...")
+        full_config = get_master_config()
+        full_config.get_config().obs.port = server_port
+        full_config.get_config().obs.password = server_password
+        full_config.sync_shared_fields()
+        full_config.save()
+        reload_config()
+
+
+connected = False
+
+def on_connect(obs):
+    global connected
+    logger.info("Reconnected to OBS WebSocket.")
+    start_replay_buffer()
+    connected = True
+
+
+def on_disconnect(obs):
+    global connected
+    logger.error("OBS Connection Lost!")
+    connected = False
+
+
+def connect_to_obs(retry_count=0):
+    global client
+    if not get_config().obs.enabled or client:
+        return
+
+    if util.is_windows():
+        get_obs_websocket_config_values()
+
+    try:
+        client = obsws(
+            host=get_config().obs.host,
+            port=get_config().obs.port,
+            password=get_config().obs.password,
+            authreconnect=1,
+            on_connect=on_connect,
+            on_disconnect=on_disconnect
+        )
+        client.connect()
+        update_current_game()
+    except ConnectionFailure as e:
+        if retry_count % 5 == 0:
+            logger.error(f"Failed to connect to OBS WebSocket: {e}. Retrying...")
+        time.sleep(1)
+        connect_to_obs(retry_count=retry_count + 1)
+
+
+# Disconnect from OBS WebSocket
+def disconnect_from_obs():
+    global client
+    if client:
+        client.disconnect()
+        client = None
+        logger.info("Disconnected from OBS WebSocket.")
+
+def do_obs_call(request, from_dict=None, retry=3):
+    connect_to_obs()
+    for _ in range(retry + 1):
+        try:
+            response = client.call(request)
+            if response and response.status:
+                return from_dict(response.datain) if from_dict else response.datain
+            time.sleep(0.3)
+        except Exception as e:
+            logger.error(f"Error calling OBS: {e}")
+            if "socket is already closed" in str(e) or "object has no attribute" in str(e):
+                time.sleep(0.3)
+            else:
+                return None
+    return None
+
+def toggle_replay_buffer():
+    try:
+        do_obs_call(requests.ToggleReplayBuffer())
+        logger.info("Replay buffer Toggled.")
+    except Exception as e:
+        logger.error(f"Error toggling buffer: {e}")
+
+
+# Start replay buffer
+def start_replay_buffer(retry=5):
+    try:
+        if not get_replay_buffer_status()['outputActive']:
+            do_obs_call(requests.StartReplayBuffer(), retry=0)
+    except Exception as e:
+        if "socket is already closed" in str(e):
+            if retry > 0:
+                time.sleep(1)
+                start_replay_buffer(retry - 1)
+            else:
+                logger.error(f"Error starting replay buffer: {e}")
+
+def get_replay_buffer_status():
+    try:
+        return do_obs_call(requests.GetReplayBufferStatus())
+    except Exception as e:
+        logger.error(f"Error getting replay buffer status: {e}")
+
+
+# Stop replay buffer
+def stop_replay_buffer():
+    try:
+        client.call(requests.StopReplayBuffer())
+        logger.error("Replay buffer stopped.")
+    except Exception as e:
+        logger.error(f"Error stopping replay buffer: {e}")
+
+# Save the current replay buffer
+def save_replay_buffer():
+    replay_buffer_started = do_obs_call(requests.GetReplayBufferStatus())['outputActive']
+    if replay_buffer_started:
+        client.call(requests.SaveReplayBuffer())
+        logger.info("Replay buffer saved. If your log stops bere, make sure your obs output path matches \"Path To Watch\" in GSM settings.")
+    else:
+        logger.error("Replay Buffer is not active, could not save Replay Buffer!")
+
+
+def get_current_scene():
+    try:
+        return do_obs_call(requests.GetCurrentProgramScene(), SceneInfo.from_dict, retry=0).sceneName
+    except Exception as e:
+        logger.debug(f"Couldn't get scene: {e}")
+    return ''
+
+
+def get_source_from_scene(scene_name):
+    try:
+        return do_obs_call(requests.GetSceneItemList(sceneName=scene_name), SceneItemsResponse.from_dict).sceneItems[0]
+    except Exception as e:
+        logger.error(f"Error getting source from scene: {e}")
+        return ''
+
+def get_record_directory():
+    try:
+        return do_obs_call(requests.GetRecordDirectory(), RecordDirectory.from_dict).recordDirectory
+    except Exception as e:
+        logger.error(f"Error getting recording folder: {e}")
+        return ''
+
+def get_obs_scenes():
+    try:
+        response: SceneListResponse = do_obs_call(requests.GetSceneList(), SceneListResponse.from_dict, retry=0)
+        return response.scenes
+    except Exception as e:
+        logger.error(f"Error getting scenes: {e}")
+        return None
+
+def register_scene_change_callback(callback):
+    global client
+    if not client:
+        logger.error("OBS client is not connected.")
+        return
+
+    def on_scene_change(data):
+        logger.info("Scene changed: " + str(data))
+        scene_name = data.getSceneName()
+        if scene_name:
+            callback(scene_name)
+
+    client.register(on_scene_change, events.CurrentProgramSceneChanged)
+    logger.info("Scene change callback registered.")
+
+
+def get_screenshot(compression=-1):
+    try:
+        screenshot = util.make_unique_file_name(os.path.abspath(
+            configuration.get_temporary_directory()) + '/screenshot.png')
+        update_current_game()
+        current_source = get_source_from_scene(get_current_game())
+        current_source_name = current_source.sourceName
+        if not current_source_name:
+            logger.error("No active scene found.")
+            return
+        start = time.time()
+        logger.debug(f"Current source name: {current_source_name}")
+        response = client.call(requests.SaveSourceScreenshot(sourceName=current_source_name, imageFormat='png', imageFilePath=screenshot, imageCompressionQuality=compression))
+        logger.debug(f"Screenshot response: {response}")
+        logger.debug(f"Screenshot took {time.time() - start:.3f} seconds to save")
+        return screenshot
+    except Exception as e:
+        logger.error(f"Error getting screenshot: {e}")
+
+def get_screenshot_base64():
+    try:
+        update_current_game()
+        current_source = get_source_from_scene(get_current_game())
+        current_source_name = current_source.sourceName
+        if not current_source_name:
+            logger.error("No active scene found.")
+            return
+        response = do_obs_call(requests.GetSourceScreenshot(sourceName=current_source_name, imageFormat='png', imageCompressionQuality=0))
+        with open('screenshot_response.txt', 'wb') as f:
+            f.write(str(response).encode())
+        return response['imageData']
+    except Exception as e:
+        logger.error(f"Error getting screenshot: {e}")
+
+def update_current_game():
+    configuration.current_game = get_current_scene()
+
+
+def get_current_game(sanitize=False):
+    if not configuration.current_game:
+        update_current_game()
+
+    if sanitize:
+        return util.sanitize_filename(configuration.current_game)
+    return configuration.current_game

{gamesentenceminer-2.8.41 → gamesentenceminer-2.8.42}/GameSentenceMiner/ocr/owocr_helper.py

@@ -205,18 +205,18 @@ class WebsocketServerThread(threading.Thread):
 
 all_cords = None
 rectangles = None
+last_ocr2_result = ""
 
-def do_second_ocr(ocr1_text, rectangle_index, time, img):
-    global twopassocr, ocr2, last_ocr1_results, last_ocr2_results
+def do_second_ocr(ocr1_text, time, img, filtering):
+    global twopassocr, ocr2, last_ocr2_result
     try:
         orig_text, text = run.process_and_write_results(img, None, None, None, None,
                                                         engine=ocr2)
-        previous_ocr2_text = last_ocr2_results[rectangle_index]
-        if fuzz.ratio(previous_ocr2_text, text) >= 80:
+        if fuzz.ratio(last_ocr2_result, text) >= 80:
             logger.info("Seems like the same text from previous ocr2 result, not sending")
             return
         save_result_image(img)
-        last_ocr2_results[rectangle_index] = text
+        last_ocr2_result = text
         send_result(text, time)
     except json.JSONDecodeError:
         print("Invalid JSON received.")
@@ -243,91 +243,74 @@ def send_result(text, time):
         websocket_server_thread.send_text(text, time)
 
 
-last_oneocr_results_to_check = {}  # Store last OCR result for each rectangle
-last_oneocr_times = {}    # Store last OCR time for each rectangle
-text_stable_start_times = {} # Store the start time when text becomes stable for each rectangle
-previous_imgs = {}
-orig_text_results = {} # Store original text results for each rectangle
+previous_text = ""  # Store last OCR result
+last_oneocr_time = None  # Store last OCR time
+text_stable_start_time = None  # Store the start time when text becomes stable
+previous_img = None
+orig_text_result = ""  # Store original text result
 TEXT_APPEARENCE_DELAY = get_ocr_scan_rate() * 1000 + 500  # Adjust as needed
 
-def text_callback(text, orig_text, rectangle_index, time, img=None, came_from_ss=False):
-    global twopassocr, ocr2, last_oneocr_results_to_check, last_oneocr_times, text_stable_start_times, orig_text_results
+def text_callback(text, orig_text, time, img=None, came_from_ss=False, filtering=None):
+    global twopassocr, ocr2, previous_text, last_oneocr_time, text_stable_start_time, orig_text_result, previous_img
     orig_text_string = ''.join([item for item in orig_text if item is not None]) if orig_text else ""
-    # logger.debug(orig_text_string)
     if came_from_ss:
         save_result_image(img)
         send_result(text, time)
         return
 
-    current_time = time if time else datetime.now()
+    line_start_time = time if time else datetime.now()
 
-    previous_text = last_oneocr_results_to_check.pop(rectangle_index, "").strip()
-    previous_orig_text = orig_text_results.get(rectangle_index, "").strip()
-
-    # print(previous_orig_text)
-    # if orig_text:
-    #     print(orig_text_string)
     if not twopassocr:
-        if previous_orig_text and fuzz.ratio(orig_text_string, previous_orig_text) >= 80:
+        if previous_text and fuzz.ratio(orig_text_string, previous_text) >= 80:
             logger.info("Seems like Text we already sent, not doing anything.")
             return
         save_result_image(img)
         send_result(text, time)
-        orig_text_results[rectangle_index] = orig_text_string
-        last_ocr1_results[rectangle_index] = previous_text
+        orig_text_result = orig_text_string
+        previous_text = previous_text
+        previous_img = None
+        text_stable_start_time = None
+        last_oneocr_time = None
         return
     if not text:
         if previous_text:
-            if rectangle_index in text_stable_start_times:
-                stable_time = text_stable_start_times.pop(rectangle_index)
-                previous_img = previous_imgs.pop(rectangle_index)
-                previous_result = last_ocr1_results[rectangle_index]
-                if previous_result and fuzz.ratio(previous_result, previous_text) >= 80:
-                    logger.info("Seems like the same text, not " + "doing second OCR" if twopassocr else "sending")
-                    return
-                if previous_orig_text and fuzz.ratio(orig_text_string, previous_orig_text) >= 80:
+            if text_stable_start_time:
+                stable_time = text_stable_start_time
+                previous_img_local = previous_img
+                if fuzz.ratio(orig_text_string, previous_text) >= 80:
                     logger.info("Seems like Text we already sent, not doing anything.")
                     return
-                orig_text_results[rectangle_index] = orig_text_string
-                last_ocr1_results[rectangle_index] = previous_text
-                do_second_ocr(previous_text, rectangle_index, stable_time, previous_img)
+                orig_text_result = orig_text_string
+                previous_text = previous_text
+                do_second_ocr(previous_text, stable_time, previous_img_local, filtering)
+                previous_img = None
+                text_stable_start_time = None
+                last_oneocr_time = None
             return
         return
-
-    if rectangle_index not in last_oneocr_results_to_check:
-        last_oneocr_results_to_check[rectangle_index] = text
-        last_oneocr_times[rectangle_index] = current_time
-        text_stable_start_times[rectangle_index] = current_time
-        previous_imgs[rectangle_index] = img
-        return
-
-    stable = text_stable_start_times.get(rectangle_index)
-
-    if stable:
-        time_since_stable_ms = int((current_time - stable).total_seconds() * 1000)
-
-        if time_since_stable_ms >= TEXT_APPEARENCE_DELAY:
-            last_oneocr_results_to_check[rectangle_index] = text
-            last_oneocr_times[rectangle_index] = current_time
-    else:
-        last_oneocr_results_to_check[rectangle_index] = text
-        last_oneocr_times[rectangle_index] = current_time
-    previous_imgs[rectangle_index] = img
+    if not text_stable_start_time:
+        text_stable_start_time = line_start_time
+    previous_text = orig_text
+    last_oneocr_time = line_start_time
+    previous_img = img
 
 done = False
 
 
-def run_oneocr(ocr_config: OCRConfig, i, area=False):
+def run_oneocr(ocr_config: OCRConfig, area=False):
     global done
+    print("Running OneOCR")
     screen_area = None
-    if ocr_config.rectangles:
-        rect_config = ocr_config.rectangles[i]
+    screen_areas = []
+    for rect_config in ocr_config.rectangles:
         coords = rect_config.coordinates
         monitor_config = rect_config.monitor
         screen_area = ",".join(str(c) for c in coords) if area else None
+        if screen_area:
+            screen_areas.append(screen_area)
     exclusions = list(rect.coordinates for rect in list(filter(lambda x: x.is_excluded, ocr_config.rectangles)))
     run.run(read_from="screencapture",
-            read_from_secondary="clipboard" if i == 0 else None,
+            read_from_secondary="clipboard",
             write_to="callback",
             screen_capture_area=screen_area,
             # screen_capture_monitor=monitor_config['index'],
@@ -336,10 +319,11 @@ def run_oneocr(ocr_config: OCRConfig, i, area=False):
             screen_capture_delay_secs=get_ocr_scan_rate(), engine=ocr1,
             text_callback=text_callback,
             screen_capture_exclusions=exclusions,
-            rectangle=i,
             language=language,
             monitor_index=ocr_config.window,
-            ocr2=ocr2)
+            ocr2=ocr2,
+            gsm_ocr_config=ocr_config,
+            screen_capture_areas=screen_areas)
     done = True
 
 
@@ -400,17 +384,14 @@ if __name__ == "__main__":
     logger.info(f"Starting OCR with configuration: Window: {ocr_config.window}, Rectangles: {ocr_config.rectangles}, Engine 1: {ocr1}, Engine 2: {ocr2}, Two-pass OCR: {twopassocr}")
     if ocr_config:
         rectangles = list(filter(lambda rect: not rect.is_excluded, ocr_config.rectangles))
-        last_ocr1_results = [""] * len(rectangles) if rectangles else [""]
-        last_ocr2_results = [""] * len(rectangles) if rectangles else [""]
         oneocr_threads = []
         run.init_config(False)
         if rectangles:
-            for i, rectangle in enumerate(rectangles):
-                thread = threading.Thread(target=run_oneocr, args=(ocr_config, i,True, ), daemon=True)
-                oneocr_threads.append(thread)
-                thread.start()
+            thread = threading.Thread(target=run_oneocr, args=(ocr_config,True, ), daemon=True)
+            oneocr_threads.append(thread)
+            thread.start()
         else:
-            single_ocr_thread = threading.Thread(target=run_oneocr, args=(ocr_config, 0,False, ), daemon=True)
+            single_ocr_thread = threading.Thread(target=run_oneocr, args=(ocr_config,False, ), daemon=True)
             oneocr_threads.append(single_ocr_thread)
             single_ocr_thread.start()
         websocket_server_thread = WebsocketServerThread(read=True)

{gamesentenceminer-2.8.41 → gamesentenceminer-2.8.42}/GameSentenceMiner/owocr/owocr/run.py

@@ -379,7 +379,7 @@ class TextFiltering:
             else:
                 orig_text_filtered.append(None)
 
-        if last_result[1] == engine_index:
+        if last_result and last_result[1] == engine_index:
             last_text = last_result[0]
         else:
             last_text = []
@@ -399,6 +399,7 @@ class TextFiltering:
                         break
         else:
             for block in new_blocks:
+                print(block)
                 if lang not in ["ja", "zh"] or self.classify(block)[0] == lang:
                     final_blocks.append(block)
 
@@ -407,7 +408,7 @@ class TextFiltering:
 
 
 class ScreenshotClass:
-    def __init__(self, screen_capture_area, screen_capture_window, screen_capture_exclusions, screen_capture_only_active_windows):
+    def __init__(self, screen_capture_area, screen_capture_window, screen_capture_exclusions, screen_capture_only_active_windows, screen_capture_areas):
         self.macos_window_tracker_instance = None
         self.windows_window_tracker_instance = None
         self.screencapture_window_active = True
@@ -415,6 +416,7 @@ class ScreenshotClass:
         self.custom_left = None
         self.screen_capture_exclusions = screen_capture_exclusions
         self.screen_capture_window = screen_capture_window
+        self.areas = []
         if screen_capture_area == '':
             self.screencapture_mode = 0
         elif screen_capture_area.startswith('screen_'):
@@ -463,9 +465,15 @@ class ScreenshotClass:
 
             self.sct_params = {'top': coord_top, 'left': coord_left, 'width': coord_width, 'height': coord_height}
             logger.opt(ansi=True).info(f'Selected coordinates: {coord_left},{coord_top},{coord_width},{coord_height}')
-        if len(screen_capture_area.split(',')) == 4:
-            self.custom_left, self.custom_top, self.custom_width, self.custom_height = [int(c.strip()) for c in
-                                                                    screen_capture_area.split(',')]
+        if screen_capture_areas:
+            for area in screen_capture_areas:
+                if len(area.split(',')) == 4:
+                    self.areas.append(([int(c.strip()) for c in area.split(',')]))
+        else:
+            if len(screen_capture_area.split(',')) == 4:
+                self.areas.append(([int(c.strip()) for c in screen_capture_area.split(',')]))
+
+        self.areas.sort(key=lambda rect: (rect[1], rect[0]))
 
 
         if self.screencapture_mode == 2 or self.screen_capture_window:
@@ -724,8 +732,35 @@ class ScreenshotClass:
                 left, top, width, height = exclusion
                 draw.rectangle((left, top, left + width, top + height), fill=(0, 0, 0, 0))
 
-        if self.custom_left:
-            img = img.crop((self.custom_left, self.custom_top, self.custom_left + self.custom_width, self.custom_top + self.custom_height))
+        cropped_sections = []
+        start = time.time()
+        for area in self.areas:
+            cropped_sections.append(img.crop((area[0], area[1], area[0] + area[2], area[1] + area[3])))
+
+        # if len(cropped_sections) > 1:
+        #     combined_width = sum(section.width for section in cropped_sections)
+        #     combined_height = max(section.height for section in cropped_sections)
+        #     combined_img = Image.new("RGBA", (combined_width, combined_height))
+        #
+        #     x_offset = 0
+        #     for section in cropped_sections:
+        #         combined_img.paste(section, (x_offset, 0))
+        #         x_offset += section.width
+        #
+        #     img = combined_img
+        if len(cropped_sections) > 1:
+            combined_width = max(section.width for section in cropped_sections)
+            combined_height = sum(section.height for section in cropped_sections) + (len(cropped_sections) - 1) * 10  # Add space for gaps
+            combined_img = Image.new("RGBA", (combined_width, combined_height))
+
+            y_offset = 0
+            for section in cropped_sections:
+                combined_img.paste(section, (0, y_offset))
+                y_offset += section.height + 50  # Add gap between sections
+
+            img = combined_img
+        elif cropped_sections:
+            img = cropped_sections[0]
 
         if rand_int == 1:
             img.save(os.path.join(get_temporary_directory(), 'after_crop.png'), 'PNG')
@@ -858,7 +893,7 @@ def on_window_minimized(minimized):
     screencapture_window_visible = not minimized
 
 
-def process_and_write_results(img_or_path, write_to=None, last_result=None, filtering=None, notify=None, engine=None, rectangle=None, ocr_start_time=None):
+def process_and_write_results(img_or_path, write_to=None, last_result=None, filtering=None, notify=None, engine=None, ocr_start_time=None):
     global engine_index
     if auto_pause_handler:
         auto_pause_handler.stop()
@@ -900,7 +935,7 @@ def process_and_write_results(img_or_path, write_to=None, last_result=None, filt
         elif write_to == 'clipboard':
             pyperclipfix.copy(text)
         elif write_to == "callback":
-            txt_callback(text, orig_text, rectangle, ocr_start_time, img_or_path, bool(engine))
+            txt_callback(text, orig_text, ocr_start_time, img_or_path, bool(engine), filtering)
         elif write_to:
             with Path(write_to).open('a', encoding='utf-8') as f:
                 f.write(text + '\n')
@@ -937,6 +972,7 @@ def run(read_from=None,
         combo_pause=None,
         combo_engine_switch=None,
         screen_capture_area=None,
+        screen_capture_areas=None,
         screen_capture_exclusions=None,
         screen_capture_window=None,
         screen_capture_delay_secs=None,
@@ -944,11 +980,11 @@ def run(read_from=None,
         screen_capture_combo=None,
         stop_running_flag=None,
         screen_capture_event_bus=None,
-        rectangle=None,
         text_callback=None,
         language=None,
         monitor_index=None,
         ocr2=None,
+        gsm_ocr_config=None,
         ):
     """
     Japanese OCR client
@@ -1004,9 +1040,6 @@ def run(read_from=None,
     if screen_capture_event_bus is None:
         screen_capture_event_bus = config.get_general('screen_capture_event_bus')
 
-    if rectangle is None:
-        rectangle = config.get_general('rectangle')
-
     if text_callback is None:
         text_callback = config.get_general('text_callback')
 
@@ -1063,8 +1096,8 @@ def run(read_from=None,
     global paused
     global just_unpaused
     global first_pressed
-    global notifier
     global auto_pause_handler
+    global notifier
     global websocket_server_thread
     global image_queue
     custom_left = None
@@ -1124,7 +1157,8 @@ def run(read_from=None,
         if screen_capture_combo != '':
             screen_capture_on_combo = True
             key_combos[screen_capture_combo] = on_screenshot_combo
-        take_screenshot = ScreenshotClass(screen_capture_area, screen_capture_window, screen_capture_exclusions, screen_capture_only_active_windows)
+        take_screenshot = ScreenshotClass(screen_capture_area, screen_capture_window, screen_capture_exclusions, screen_capture_only_active_windows, screen_capture_areas)
+        # global_take_screenshot = ScreenshotClass(screen_capture_area, screen_capture_window, screen_capture_exclusions, screen_capture_only_active_windows, rectangle)
         filtering = TextFiltering()
         read_from_readable.append('screen capture')
     if 'websocket' in (read_from, read_from_secondary):
@@ -1201,11 +1235,11 @@ def run(read_from=None,
             break
         elif img:
             if filter_img:
-                res, _ = process_and_write_results(img, write_to, last_result, filtering, notify, rectangle=rectangle, ocr_start_time=ocr_start_time)
+                res, _ = process_and_write_results(img, write_to, last_result, filtering, notify, ocr_start_time=ocr_start_time)
                 if res:
                     last_result = (res, engine_index)
             else:
-                process_and_write_results(img, write_to, None, notify=notify, rectangle=rectangle, ocr_start_time=ocr_start_time, engine=ocr2)
+                process_and_write_results(img, write_to, None, notify=notify, ocr_start_time=ocr_start_time, engine=ocr2)
             if isinstance(img, Path):
                 if delete_images:
                     Path.unlink(img)

gamesentenceminer-2.8.42/GameSentenceMiner/ss_selector.py

@@ -0,0 +1,121 @@
+import tkinter as tk
+from PIL import Image, ImageTk
+import subprocess
+import os
+import sys
+
+from GameSentenceMiner import ffmpeg
+from GameSentenceMiner.configuration import get_temporary_directory, logger
+from GameSentenceMiner.ffmpeg import ffmpeg_base_command_list
+from GameSentenceMiner.util import sanitize_filename
+
+def extract_frames(video_path, timestamp, temp_dir, mode):
+    frame_paths = []
+    timestamp_number = float(timestamp)
+    golden_frame_index = 1  # Default to the first frame
+    golden_frame = None
+    video_duration = ffmpeg.get_video_duration(video_path)
+
+    if mode == 'middle':
+        timestamp_number = max(0.0, timestamp_number - 2.5)
+    elif mode == 'end':
+        timestamp_number = max(0.0, timestamp_number - 5.0)
+
+    if video_duration is not None and timestamp_number > video_duration:
+        logger.debug(f"Timestamp {timestamp_number} exceeds video duration {video_duration}.")
+        return None
+
+    try:
+        command = ffmpeg_base_command_list + [
+            "-y",
+            "-ss", str(timestamp_number),
+            "-i", video_path,
+            "-vf", f"fps=1/{0.25}",
+            "-vframes", "20",
+            os.path.join(temp_dir, "frame_%02d.png")
+        ]
+        subprocess.run(command, check=True, capture_output=True)
+        for i in range(1, 21):
+            if os.path.exists(os.path.join(temp_dir, f"frame_{i:02d}.png")):
+                frame_paths.append(os.path.join(temp_dir, f"frame_{i:02d}.png"))
+
+        if mode == "beginning":
+            golden_frame = frame_paths[0]
+        if mode == "middle":
+            golden_frame = frame_paths[len(frame_paths) // 2]
+        if mode == "end":
+            golden_frame = frame_paths[-1]
+    except subprocess.CalledProcessError as e:
+        logger.debug(f"Error extracting frames: {e}")
+        logger.debug(f"Command was: {' '.join(command)}")
+        logger.debug(f"FFmpeg output:\n{e.stderr.decode()}")
+        return None
+    except Exception as e:
+        logger.debug(f"An error occurred: {e}")
+        return None
+    return frame_paths, golden_frame
+
+def timestamp_to_seconds(timestamp):
+    hours, minutes, seconds = map(int, timestamp.split(':'))
+    return hours * 3600 + minutes * 60 + seconds
+
+def display_images(image_paths, golden_frame):
+    window = tk.Tk()
+    window.configure(bg="black")  # Set the background color to black
+    window.title("Image Selector")
+    selected_path = tk.StringVar()
+    image_widgets = []
+
+    def on_image_click(event):
+        widget = event.widget
+        index = image_widgets.index(widget)
+        selected_path.set(image_paths[index])
+        window.quit()
+
+    for i, path in enumerate(image_paths):
+        img = Image.open(path)
+        img.thumbnail((450, 450))
+        img_tk = ImageTk.PhotoImage(img)
+        if golden_frame and path == golden_frame:
+            label = tk.Label(window, image=img_tk, borderwidth=5, relief="solid")
+            label.config(highlightbackground="yellow", highlightthickness=5)
+        else:
+            label = tk.Label(window, image=img_tk)
+        label.image = img_tk
+        label.grid(row=i // 5, column=i % 5, padx=5, pady=5)
+        label.bind("<Button-1>", on_image_click)  # Bind click event to the label
+        image_widgets.append(label)
+
+    window.attributes("-topmost", True)
+    window.mainloop()
+    return selected_path.get()
+
+def run_extraction_and_display(video_path, timestamp_str, mode):
+    temp_dir = os.path.join(get_temporary_directory(), "screenshot_frames", sanitize_filename(os.path.splitext(os.path.basename(video_path))[0]))
+    os.makedirs(temp_dir, exist_ok=True)
+    image_paths, golden_frame = extract_frames(video_path, timestamp_str, temp_dir, mode)
+    if image_paths:
+        selected_image_path = display_images(image_paths, golden_frame)
+        if selected_image_path:
+            print(selected_image_path)
+        else:
+            logger.debug("No image was selected.")
+    else:
+        logger.debug("Frame extraction failed.")
+
+def main():
+    # if len(sys.argv) != 3:
+    #     print("Usage: python script.py <video_path> <timestamp>")
+    #     sys.exit(1)
+    try:
+        video_path = sys.argv[1]
+        timestamp_str = sys.argv[2]
+        mode = sys.argv[3] if len(sys.argv) > 3 else "beginning"
+        run_extraction_and_display(video_path, timestamp_str, mode)
+    except Exception as e:
+        logger.debug(e)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

{gamesentenceminer-2.8.41 → gamesentenceminer-2.8.42}/GameSentenceMiner/util.py

@@ -186,7 +186,12 @@ def wait_for_stable_file(file_path, timeout=10, check_interval=0.1):
         try:
             current_size = os.path.getsize(file_path)
             if current_size == last_size:
-                return True
+                try:
+                    with open(file_path, 'rb') as f:
+                        return True
+                except Exception as e:
+                    time.sleep(check_interval)
+                    elapsed_time += check_interval
             last_size = current_size
             time.sleep(check_interval)
             elapsed_time += check_interval

{gamesentenceminer-2.8.41 → gamesentenceminer-2.8.42}/GameSentenceMiner.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: GameSentenceMiner
-Version: 2.8.41
+Version: 2.8.42
 Summary: A tool for mining sentences from games. Update: Multi-Line Mining! Fixed!
 Author-email: Beangate <bpwhelan95@gmail.com>
 License: MIT License

{gamesentenceminer-2.8.41 → gamesentenceminer-2.8.42}/GameSentenceMiner.egg-info/SOURCES.txt

@@ -12,7 +12,9 @@ GameSentenceMiner/gsm.py
 GameSentenceMiner/model.py
 GameSentenceMiner/notification.py
 GameSentenceMiner/obs.py
+GameSentenceMiner/obs_back.py
 GameSentenceMiner/package.py
+GameSentenceMiner/ss_selector.py
 GameSentenceMiner/text_log.py
 GameSentenceMiner/util.py
 GameSentenceMiner.egg-info/PKG-INFO

{gamesentenceminer-2.8.41 → gamesentenceminer-2.8.42}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: GameSentenceMiner
-Version: 2.8.41
+Version: 2.8.42
 Summary: A tool for mining sentences from games. Update: Multi-Line Mining! Fixed!
 Author-email: Beangate <bpwhelan95@gmail.com>
 License: MIT License

{gamesentenceminer-2.8.41 → gamesentenceminer-2.8.42}/pyproject.toml

@@ -7,7 +7,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "GameSentenceMiner"
-version = "2.8.41"
+version = "2.8.42"
 description = "A tool for mining sentences from games. Update: Multi-Line Mining! Fixed!"
 readme = "README.md"
 requires-python = ">=3.10"