GameSentenceMiner 2.17.7__py3-none-any.whl → 2.18.1__py3-none-any.whl

GameSentenceMiner/gsm.py

@@ -1,3 +1,7 @@
+# There should be no imports here, as any error will crash the program.
+# All imports should be done in the try/except block below.
+
+
 def handle_error_in_initialization(e):
     """Handle errors that occur during initialization."""
     logger.exception(e, exc_info=True)
@@ -24,6 +28,7 @@ try:
     import requests
     import os.path
     import signal
+    import datetime
     from subprocess import Popen
     os.environ.pop('TCL_LIBRARY', None)
 
@@ -36,13 +41,17 @@ try:
     import psutil
 
     start_time = time.time()
+    import GameSentenceMiner.util.configuration
     from GameSentenceMiner.util.configuration import logger, gsm_state, get_config, anki_results, AnkiUpdateResult, \
     get_temporary_directory, get_log_path, get_master_config, switch_profile_and_save, get_app_directory, gsm_status, \
-    is_windows, is_linux
-    from GameSentenceMiner.util.get_overlay_coords import OverlayThread
-    from GameSentenceMiner.util.gsm_utils import remove_html_and_cloze_tags
+    is_windows, is_linux, get_ffmpeg_path
 
     logger.debug(f"[Import] configuration: {time.time() - start_time:.3f}s")
+    
+    start_time = time.time()
+    from GameSentenceMiner.util.get_overlay_coords import OverlayThread
+    from GameSentenceMiner.util.gsm_utils import remove_html_and_cloze_tags, add_srt_line
+    logger.debug(f"[Import] get_overlay_coords (OverlayThread, remove_html_and_cloze_tags): {time.time() - start_time:.3f}s")
 
     start_time = time.time()
     from GameSentenceMiner.util.model import VADResult
@@ -72,7 +81,7 @@ try:
     logger.debug(f"[Import] anki: {time.time() - start_time:.3f}s")
 
     start_time = time.time()
-    from GameSentenceMiner import config_gui
+    from GameSentenceMiner.ui import config_gui
     logger.debug(f"[Import] config_gui: {time.time() - start_time:.3f}s")
 
     start_time = time.time()
@@ -98,7 +107,7 @@ try:
         f"[Import] websocket (connect_websocket, register_websocket_message_handler, FunctionName): {time.time() - start_time:.3f}s")
 
     start_time = time.time()
-    from GameSentenceMiner.util.ffmpeg import get_audio_and_trim, get_video_timings, get_ffmpeg_path
+    from GameSentenceMiner.util.ffmpeg import get_audio_and_trim, get_video_timings
     logger.debug(
         f"[Import] util.ffmpeg (get_audio_and_trim, get_video_timings, get_ffmpeg_path): {time.time() - start_time:.3f}s")
 
@@ -145,15 +154,28 @@ class VideoToAudioHandler(FileSystemEventHandler):
         super().__init__()
 
     def on_created(self, event):
-        if event.is_directory or ("Replay" not in event.src_path and "GSM" not in event.src_path):
+        file_name = os.path.basename(event.src_path)
+        if event.is_directory or ("Replay" not in file_name and "GSM" not in file_name):
+            # This shows up as soon as recording starts, so it's kinda hard to use...
+            # if get_config().features.generate_longplay and event.src_path.endswith(".mkv") or event.src_path.endswith(".mp4"):
+            #     add_srt_line(datetime.datetime.now(), get_all_lines()[-1])
+            #     logger.info(f"Recording {event.src_path} FOUND, RUNNING LOGIC")
+            #     wait_for_stable_file(event.src_path)
+            #     current_srt = gsm_state.current_srt
+            #     srt_name = os.path.splitext(os.path.basename(event.src_path))[0] + ".srt"
+            #     srt_path = os.path.join(os.path.dirname(event.src_path), srt_name)
+            #     shutil.move(current_srt, srt_path)
+            #     gsm_state.current_srt = None
+            #     # self.process_replay(event.src_path)
             return
         # Adjust based on your OBS output format
-        if event.src_path.endswith(".mkv") or event.src_path.endswith(".mp4"):
+        if file_name.endswith(".mkv") or file_name.endswith(".mp4"):
             logger.info(f"MKV {event.src_path} FOUND, RUNNING LOGIC")
             wait_for_stable_file(event.src_path)
             self.process_replay(event.src_path)
 
     def process_replay(self, video_path):
+        gsm_state.current_replay = video_path
         vad_trimmed_audio = ''
         final_audio_output = ''
         skip_delete = False
@@ -194,6 +216,7 @@ class VideoToAudioHandler(FileSystemEventHandler):
             # Get Info of line mined
             line_cutoff = None
             start_line = None
+            full_text = ''
             if selected_lines:
                 start_line = selected_lines[0]
                 mined_line = get_mined_line(last_note, selected_lines)
@@ -300,7 +323,7 @@ class VideoToAudioHandler(FileSystemEventHandler):
                                                                 f"{obs.get_current_game(sanitize=True)}.{get_config().audio.extension}"))
 
         vad_result = vad_processor.trim_audio_with_vad(
-            trimmed_audio, vad_trimmed_audio, game_line)
+            trimmed_audio, vad_trimmed_audio, game_line, full_text)
         if timing_only:
             return vad_result
 
@@ -337,7 +360,7 @@ class VideoToAudioHandler(FileSystemEventHandler):
 
 def initial_checks():
     try:
-        subprocess.run(ffmpeg.ffmpeg_base_command_list)
+        subprocess.run(GameSentenceMiner.util.configuration.ffmpeg_base_command_list)
         logger.debug("FFMPEG is installed and accessible.")
     except FileNotFoundError:
         logger.error(
@@ -465,6 +488,13 @@ class GSMTray(threading.Thread):
         self.run_tray()
 
     def run_tray(self):
+        def run_anki_confirmation_window():
+            settings_window.show_anki_confirmation_dialog(expression="こんにちは",
+                sentence="こんにちは、世界！元気ですか？",
+                screenshot_path="test_image.png",
+                audio_path="C:/path/to/my/audio.mp3",
+                translation="Hello world! How are you?")
+
         self.profile_menu = Menu(
             *[MenuItem(("Active: " if profile == get_master_config().current_profile else "") + profile, self.switch_profile) for
               profile in
@@ -478,9 +508,10 @@ class GSMTray(threading.Thread):
             MenuItem("Toggle Replay Buffer", self.play_pause),
             MenuItem("Restart OBS", restart_obs),
             MenuItem("Switch Profile", self.profile_menu),
+            MenuItem("Run Test Code", run_anki_confirmation_window),
             MenuItem("Exit", exit_program)
         )
-
+        
         self.icon = Icon("TrayApp", create_image(), "GameSentenceMiner", menu)
         self.icon.run()
 
@@ -574,6 +605,8 @@ def restart_obs():
 
 def cleanup():
     try:
+        if gsm_state.current_srt and len(get_all_lines()) > 0:
+            add_srt_line(datetime.datetime.now(), get_all_lines()[-1])
         logger.info("Performing cleanup...")
         gsm_state.keep_running = False
 
@@ -794,6 +827,7 @@ async def async_main(reloading=False):
         root = ttk.Window(themename='darkly')
         start_time = time.time()
         settings_window = config_gui.ConfigApp(root)
+        gsm_state.config_app = settings_window
         initialize_async()
         observer = Observer()
         observer.schedule(VideoToAudioHandler(),
@@ -823,6 +857,11 @@ async def async_main(reloading=False):
             if get_config().general.open_config_on_startup:
                 root.after(50, settings_window.show)
             root.after(50, gsm_tray.start)
+            # root.after(100, settings_window.show_anki_confirmation_dialog(expression="こんにちは",
+            #     sentence="こんにちは、世界！元気ですか？",
+            #     screenshot_path="test_image.png",
+            #     audio_path="C:/path/to/my/audio.mp3",
+            #     translation="Hello world! How are you?"))
             settings_window.add_save_hook(gsm_tray.update_icon)
             settings_window.on_exit = exit_program
             root.mainloop()

GameSentenceMiner/locales/en_us.json

@@ -154,6 +154,10 @@
             "label": "Update Anki:",
             "tooltip": "Automatically update Anki with new data."
           },
+          "show_update_confirmation_dialog": {
+            "label": "Show Update Confirmation Dialog:",
+            "tooltip": "Show a confirmation dialog before updating Anki cards."
+          },
           "url": {
             "label": "Anki URL:",
             "tooltip": "The URL to connect to your Anki instance."
@@ -440,9 +444,9 @@
             "label": "Minimum Replay Size (KB):",
             "tooltip": "Minimum Replay Size for OBS Replays in KB. If Replay is Under this, Audio/Screenshot Will not be grabbed."
           },
-          "turn_off_output_check": {
-            "label": "Turn Off Output Check:",
-            "tooltip": "Disable the video output Replay Buffer Check."
+          "turn_off_replay_buffer_management": {
+            "label": "Turn off Replay Buffer Management:",
+            "tooltip": "Disable OBS Replay Buffer Management. This is useful if you want to manually manage the replay buffer in OBS."
           }
         },
         "profiles": {

GameSentenceMiner/locales/ja_jp.json

@@ -153,6 +153,10 @@
             "label": "Ankiを更新:",
             "tooltip": "自動的にAnkiを更新します。"
           },
+          "show_update_confirmation_dialog": {
+            "label": "更新確認ダイアログを表示:",
+            "tooltip": "Ankiカードを更新する前に確認ダイアログを表示します。"
+          },
           "url": {
             "label": "Anki URL:",
             "tooltip": "AnkiConnectの接続URL。"
@@ -439,10 +443,10 @@
             "label": "最小リプレイサイズ (KB):",
             "tooltip": "このサイズ未満のリプレイは処理しません。"
           },
-          "turn_off_output_check": {
-            "label": "出力チェックを無効化:",
-            "tooltip": "動画出力のリプレイバッファチェックを無効化します。"
-          }
+            "turn_off_replay_buffer_management": {
+            "label": "リプレイバッファ管理を無効化:",
+            "tooltip": "OBSリプレイバッファの管理を無効化します。OBSでリプレイバッファを手動で管理したい場合に便利です。"
+            }
         },
         "profiles": {
           "title": "プロファイル",

GameSentenceMiner/locales/zh_cn.json

@@ -154,6 +154,10 @@
             "label": "更新 Anki:",
             "tooltip": "使用新数据自动更新 Anki。"
           },
+          "show_update_confirmation_dialog": {
+            "label": "显示更新确认对话框:",
+            "tooltip": "在更新 Anki 卡片之前显示确认对话框。"
+          },
           "url": {
             "label": "Anki URL:",
             "tooltip": "连接到您的 Anki 实例的 URL。"
@@ -440,10 +444,10 @@
             "label": "最小回放大小 (KB):",
             "tooltip": "OBS 录像回放的最小大小（KB）。如果回放小于此大小，将不抓取音频/截图。"
           },
-          "turn_off_output_check": {
-            "label": "关闭输出检查:",
-            "tooltip": "禁用视频输出的回放缓冲区检查。"
-          }
+            "turn_off_replay_buffer_management": {
+            "label": "关闭回放缓冲区管理:",
+            "tooltip": "禁用 OBS 回放缓冲区管理。如果您想在 OBS 中手动管理回放缓冲区，这将很有用。"
+            }
         },
         "profiles": {
           "title": "配置文件",

GameSentenceMiner/obs.py

@@ -1,4 +1,5 @@
 import asyncio
+import datetime
 import json
 import os.path
 import subprocess
@@ -11,12 +12,11 @@ import shutil
 import psutil
 
 import obsws_python as obs
+import numpy as np
 
 from GameSentenceMiner.util import configuration
 from GameSentenceMiner.util.configuration import get_app_directory, get_config, get_master_config, is_windows, save_full_config, reload_config, logger, gsm_status, gsm_state
-from GameSentenceMiner.util.gsm_utils import sanitize_filename, make_unique_file_name
-import tkinter as tk
-from tkinter import messagebox
+from GameSentenceMiner.util.gsm_utils import sanitize_filename, make_unique_file_name, make_unique_temp_file
 
 connection_pool: 'OBSConnectionPool' = None
 event_client: obs.EventClient = None
@@ -75,7 +75,7 @@ class OBSConnectionPool:
             self._clients[index] = obs.ReqClient(**self.connection_kwargs)
 
     @contextlib.contextmanager
-    def get_client(self):
+    def get_client(self) -> obs.ReqClient:
         """A context manager to safely get a client from the pool."""
         with self._idx_lock:
             idx = self._next_idx
@@ -106,37 +106,114 @@ class OBSConnectionManager(threading.Thread):
         super().__init__()
         self.daemon = True
         self.running = True
+        self.should_check_output = check_output
         self.check_connection_interval = 1
-        self.said_no_to_replay_buffer = False
         self.counter = 0
-        self.check_output = check_output
+        self.last_replay_buffer_status = None
+        self.no_output_timestamp = None
+        self.NO_OUTPUT_SHUTDOWN_SECONDS = 300
+        self.last_errors = []
+        self.previous_image = None
+
+    def _check_obs_connection(self):
+        try:
+            client = connection_pool.get_healthcheck_client() if connection_pool else None
+            if client and not connecting:
+                client.get_version()
+                gsm_status.obs_connected = True
+                return True
+            else:
+                raise ConnectionError("Healthcheck client not available or connection in progress")
+        except Exception as e:
+            logger.debug(f"OBS WebSocket not connected. Attempting to reconnect... {e}")
+            gsm_status.obs_connected = False
+            asyncio.run(connect_to_obs())
+            return False
+        
+    def check_replay_buffer_enabled(self):
+        if not self.should_check_output:
+            return True, ""
+        output = get_replay_buffer_output()
+        if not output:
+            return False, "Replay Buffer output not found in OBS. Please enable Replay Buffer In OBS Settings -> Output -> Replay Buffer. I recommend 300 seconds (5 minutes) or higher."
+        return True, ""
+
+    def _manage_replay_buffer_and_utils(self):
+        errors = []
+        
+        if not self.should_check_output:
+            return errors
+        
+        set_fit_to_screen_for_scene_items(get_current_scene())
+            
+        if not get_config().obs.automatically_manage_replay_buffer:
+            errors.append("Automatic Replay Buffer management is disabled in GSM settings.")
+            return errors
+
+        replay_buffer_enabled, error_message = self.check_replay_buffer_enabled()
+
+        if not replay_buffer_enabled:
+            errors.append(error_message)
+            return errors
+
+        current_status = get_replay_buffer_status()
+
+        if self.last_replay_buffer_status is None:
+            self.last_replay_buffer_status = current_status
+            return errors
+
+        if current_status != self.last_replay_buffer_status:
+            self.last_replay_buffer_status = current_status
+            self.no_output_timestamp = None
+            return errors
+        
+        img = get_screenshot_PIL(compression=100, img_format='jpg', width=1280, height=720)
+        has_changed = self.has_image_changed(img) if img else True
+
+        if not has_changed:
+            self.no_output_timestamp = None
+            if not current_status:
+                start_replay_buffer()
+                self.last_replay_buffer_status = True
+        else: # is_empty
+            if current_status:
+                if self.no_output_timestamp is None:
+                    self.no_output_timestamp = time.time()
+                elif time.time() - self.no_output_timestamp >= self.NO_OUTPUT_SHUTDOWN_SECONDS:
+                    stop_replay_buffer()
+                    self.last_replay_buffer_status = False
+                    self.no_output_timestamp = None
+
+    def has_image_changed(self, img):
+        if self.previous_image is None:
+            self.previous_image = np.array(img)
+            return True
+        try:
+            img1_np = np.array(img) if not isinstance(img, np.ndarray) else img
+            img2_np = self.previous_image
+            self.previous_image = img1_np
+        except Exception:
+            logger.warning("Failed to convert images to numpy arrays for comparison.")
+            return False
+
+        return (img1_np.shape == img2_np.shape) and np.array_equal(img1_np, img2_np)
 
     def run(self):
+        time.sleep(5)  # Initial delay to allow OBS to start
         while self.running:
             time.sleep(self.check_connection_interval)
-            try:
-                client = connection_pool.get_healthcheck_client() if connection_pool else None
-                if client and not connecting:
-                    client.get_version()
-                else:
-                    raise ConnectionError("Healthcheck client not healthy or not initialized")
-            except Exception as e:
-                logger.info(f"OBS WebSocket not connected. Attempting to reconnect... {e}")
-                gsm_status.obs_connected = False
-                asyncio.run(connect_to_obs())
+
+            if not self._check_obs_connection():
+                continue
+
             if self.counter % 5 == 0:
                 try:
-                    set_fit_to_screen_for_scene_items(get_current_scene())
-                    if get_config().obs.turn_off_output_check and self.check_output:
-                        replay_buffer_status = get_replay_buffer_status()
-                        if replay_buffer_status and self.said_no_to_replay_buffer:
-                            self.said_no_to_replay_buffer = False
-                            self.counter = 0
-                        if gsm_status.obs_connected and not replay_buffer_status and not self.said_no_to_replay_buffer:
-                            try:
-                                self.check_output()
-                            except Exception:
-                                pass
+                    errors = self._manage_replay_buffer_and_utils()
+                    if errors != self.last_errors:
+                        if errors:
+                            for error in errors:
+                                logger.error(f"OBS Health Check: {error}")
+                    self.last_errors = errors
                 except Exception as e:
                     logger.error(f"Error when running Extra Utils in OBS Health Check, Keeping ConnectionManager Alive: {e}")
             self.counter += 1
@@ -144,28 +221,6 @@ class OBSConnectionManager(threading.Thread):
     def stop(self):
         self.running = False
     
-    def check_output(self):
-        img = get_screenshot_PIL(compression=100, img_format='jpg', width=1280, height=720)
-        extrema = img.getextrema()
-        if isinstance(extrema[0], tuple):
-            is_empty = all(e[0] == e[1] for e in extrema)
-        else:
-            is_empty = extrema[0] == extrema[1]
-        if is_empty:
-            return
-        else:
-            root = tk.Tk()
-            root.attributes('-topmost', True)
-            root.withdraw()
-            root.deiconify()
-            result = messagebox.askyesno("GSM - Replay Buffer", "The replay buffer is not running, but there seems to be output in OBS. Do you want to start it? (If you click 'No', you won't be asked until you either restart GSM or start/stop replay buffer manually.)")
-            root.destroy()
-            if not result:
-                self.said_no_to_replay_buffer = True
-                self.counter = 0
-                return
-            start_replay_buffer()
-    
 def get_obs_path():
     return os.path.join(configuration.get_app_directory(), 'obs-studio/bin/64bit/obs64.exe')
 
@@ -232,6 +287,7 @@ async def wait_for_obs_connected():
     for _ in range(10):
         try:
             with connection_pool.get_client() as client:
+                client: obs.ReqClient
                 response = client.get_version()
             if response:
                 return True
@@ -313,6 +369,8 @@ async def connect_to_obs(retry=5, connections=2, check_output=False):
                 obs_connection_manager = OBSConnectionManager(check_output=check_output)
                 obs_connection_manager.start()
             update_current_game()
+            if get_config().features.generate_longplay and check_output:
+                start_recording(True)
             break  # Exit the loop once connected
         except Exception as e:
             if retry <= 0:
@@ -368,8 +426,8 @@ def do_obs_call(method_name: str, from_dict=None, retry=3, **kwargs):
 def toggle_replay_buffer():
     try:
         with connection_pool.get_client() as client:
-            response = client.toggle_replay_buffer()
-        if response:
+            client: obs.ReqClient
+            client.toggle_replay_buffer()
             logger.info("Replay buffer Toggled.")
     except Exception as e:
         logger.error(f"Error toggling buffer: {e}")
@@ -377,8 +435,10 @@ def toggle_replay_buffer():
 def start_replay_buffer():
     try:
         with connection_pool.get_client() as client:
-            response = client.start_replay_buffer()
-        if response and response.ok:
+            client: obs.ReqClient
+            client.start_replay_buffer()
+            if get_config().features.generate_longplay:
+                start_recording(True)
             logger.info("Replay buffer started.")
     except Exception as e:
         logger.error(f"Error starting replay buffer: {e}")
@@ -394,8 +454,10 @@ def get_replay_buffer_status():
 def stop_replay_buffer():
     try:
         with connection_pool.get_client() as client:
-            response = client.stop_replay_buffer()
-        if response and response.ok:
+            client: obs.ReqClient
+            client.stop_replay_buffer()
+            if get_config().features.generate_longplay:
+                stop_recording()
             logger.info("Replay buffer stopped.")
     except Exception as e:
         logger.warning(f"Error stopping replay buffer: {e}")
@@ -403,15 +465,49 @@ def stop_replay_buffer():
 def save_replay_buffer():
     try:
         with connection_pool.get_client() as client:
-            response = client.save_replay_buffer()
-        if response and response.ok:
+            client: obs.ReqClient
+            client.save_replay_buffer()
             logger.info("Replay buffer saved. If your log stops here, make sure your obs output path matches \"Path To Watch\" in GSM settings.")
     except Exception as e:
         raise Exception(f"Error saving replay buffer: {e}")
 
+def start_recording(longplay=False):
+    try:
+        with connection_pool.get_client() as client:
+            client: obs.ReqClient
+            if longplay:
+                gsm_state.recording_started_time = datetime.datetime.now()
+                gsm_state.current_srt = make_unique_temp_file(f"{get_current_game(sanitize=True)}.srt")
+                gsm_state.srt_index = 1
+            client.start_record()
+            logger.info("Recording started.")
+    except Exception as e:
+        logger.error(f"Error starting recording: {e}")
+        return None
+    
+def stop_recording():
+    try:
+        with connection_pool.get_client() as client:
+            client: obs.ReqClient
+            client.stop_record()
+            logger.info("Recording stopped.")
+    except Exception as e:
+        logger.error(f"Error stopping recording: {e}")
+        
+def get_last_recording_filename():
+    try:
+        with connection_pool.get_client() as client:
+            client: obs.ReqClient
+            response = client.get_record_status()
+        return response.recording_filename if response else ''
+    except Exception as e:
+        logger.error(f"Error getting last recording filename: {e}")
+        return ''
+
 def get_current_scene():
     try:
         with connection_pool.get_client() as client:
+            client: obs.ReqClient
             response = client.get_current_program_scene()
         return response.scene_name if response else ''
     except Exception as e:
@@ -421,6 +517,7 @@ def get_current_scene():
 def get_source_from_scene(scene_name):
     try:
         with connection_pool.get_client() as client:
+            client: obs.ReqClient
             response = client.get_scene_item_list(name=scene_name)
         return response.scene_items[0] if response and response.scene_items else ''
     except Exception as e:
@@ -436,15 +533,80 @@ def get_active_source():
 def get_record_directory():
     try:
         with connection_pool.get_client() as client:
+            client: obs.ReqClient
             response = client.get_record_directory()
         return response.record_directory if response else ''
     except Exception as e:
         logger.error(f"Error getting recording folder: {e}")
         return ''
+    
+def get_replay_buffer_max_time_seconds():
+    """
+    Gets the configured maximum replay buffer time in seconds using the v5 protocol.
+    """
+    try:
+        # Assumes a connection_pool object that provides a connected client
+        with connection_pool.get_client() as client:
+            client: obs.ReqClient
+            # For v5, we get settings for the 'replay_buffer' output
+            response = client.get_output_settings(name='Replay Buffer')
+            
+            print(response.output_settings)
+
+            # The response object contains a dict of the actual settings
+            if response:
+                # The key for replay buffer length in seconds is 'max_time_sec'
+                settings = response.output_settings
+                if settings and 'max_time_sec' in settings:
+                    return settings['max_time_sec']
+                else:
+                    logger.warning("Replay buffer settings received, but 'max_time_sec' key was not found.")
+                    return 0
+            else:
+                logger.warning(f"get_output_settings for replay_buffer failed: {response.status}")
+                return 0
+    except Exception as e:
+        logger.error(f"Exception while fetching replay buffer settings: {e}")
+        return 0
+    
+def enable_replay_buffer():
+    try:
+        with connection_pool.get_client() as client:
+            client: obs.ReqClient
+            response = client.set_output_settings(name='Replay Buffer', settings={'outputFlags': {'OBS_OUTPUT_AUDIO': True, 'OBS_OUTPUT_ENCODED': True, 'OBS_OUTPUT_MULTI_TRACK': True, 'OBS_OUTPUT_SERVICE': False, 'OBS_OUTPUT_VIDEO': True}})
+        if response and response.ok:
+            logger.info("Replay buffer enabled.")
+            return True
+        else:
+            logger.error(f"Failed to enable replay buffer: {response.status if response else 'No response'}")
+            return False
+    except Exception as e:
+        logger.error(f"Error enabling replay buffer: {e}")
+        return False
+    
+def get_output_list():
+    try:
+        with connection_pool.get_client() as client:
+            client: obs.ReqClient
+            response = client.get_output_list()
+        return response.outputs if response else None
+    except Exception as e:
+        logger.error(f"Error getting output list: {e}")
+        return None
+    
+def get_replay_buffer_output():
+    outputs = get_output_list()
+    if not outputs:
+        return None
+    for output in outputs:
+        if output.get('outputKind') == 'replay_buffer':
+            return output
+    return None
 
 def get_obs_scenes():
     try:
         with connection_pool.get_client() as client:
+            client: obs.ReqClient
             response = client.get_scene_list()
         return response.scenes if response else None
     except Exception as e:
@@ -526,6 +688,7 @@ def get_screenshot_PIL(source_name=None, compression=75, img_format='png', width
         return None
     while True:
         with connection_pool.get_client() as client:
+            client: obs.ReqClient
             response = client.get_source_screenshot(name=source_name, img_format=img_format, quality=compression, width=width, height=height)
         try:
             response.image_data = response.image_data.split(',', 1)[-1]  # Remove data:image/png;base64, prefix if present
@@ -567,6 +730,7 @@ def set_fit_to_screen_for_scene_items(scene_name: str):
         
     try:
         with connection_pool.get_client() as client:
+            client: obs.ReqClient
             # 1. Get the canvas (base) resolution from OBS video settings
             video_settings = client.get_video_settings()
             if not hasattr(video_settings, 'base_width') or not hasattr(video_settings, 'base_height'):
@@ -686,6 +850,7 @@ def main():
     
 def create_scene():
     with connection_pool.get_client() as client:
+        client: obs.ReqClient
         # Extract fields from request_json
         request_json = r'{"sceneName":"SILENT HILL f","inputName":"SILENT HILL f - Capture","inputKind":"window_capture","inputSettings":{"mode":"window","window":"SILENT HILL f  :UnrealWindow:SHf-Win64-Shipping.exe","capture_audio":true,"cursor":false,"method":"2"}}'
         request_dict = json.loads(request_json)
@@ -701,7 +866,21 @@ def create_scene():
 if __name__ == '__main__':
     logging.basicConfig(level=logging.INFO)
     connect_to_obs_sync()
-    img = get_screenshot_PIL(source_name='Display Capture 2', compression=100, img_format='jpg', width=2560, height=1440)
-    img.show()
+    
+    save_replay_buffer()
+    # img = get_screenshot_PIL(source_name='Display Capture 2', compression=100, img_format='jpg', width=2560, height=1440)
+    # img.show()
+    # output_list = get_output_list()
+    # print(output_list)
+    
+    # response = enable_replay_buffer()
+    # print(response)
+    
+    # response = get_replay_buffer_max_time_seconds()
+    # # response is dataclass with attributes, print attributes
+    # print(response)
+    
+    # response = enable_replay_buffer()
+    # print(response)
     # # set_fit_to_screen_for_scene_items(get_current_scene())
     # create_scene()