GameSentenceMiner 2.8.41__tar.gz → 2.8.43__tar.gz

{gamesentenceminer-2.8.41 → gamesentenceminer-2.8.43}/GameSentenceMiner/ai/ai_prompting.py

@@ -119,7 +119,10 @@ class GeminiAI(AIManager):
         try:
             prompt = self._build_prompt(lines, sentence, current_line, game_title)
             self.logger.debug(f"Generated prompt:\n{prompt}")
-            response = self.model.generate_content(prompt)
+            response = self.model.generate_content(
+                prompt,
+                temperature=0.5,
+            )
             result = response.text.strip()
             self.logger.debug(f"Received response:\n{result}")
             return result

{gamesentenceminer-2.8.41 → gamesentenceminer-2.8.43}/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.43}/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.43}/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.41 → gamesentenceminer-2.8.43}/GameSentenceMiner/obs.py

@@ -27,8 +27,8 @@ class OBSConnectionManager(threading.Thread):
 
     def run(self):
         while self.running:
-            time.sleep(5)
-            if not client.get_version():
+            time.sleep(1)
+            if not client or not client.get_version():
                 logger.info("OBS WebSocket not connected. Attempting to reconnect...")
                 connect_to_obs()
 

gamesentenceminer-2.8.43/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