GameSentenceMiner 2.17.6__py3-none-any.whl → 2.18.0__py3-none-any.whl

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()

GameSentenceMiner/ocr/owocr_helper.py

@@ -38,7 +38,7 @@ logger.setLevel(logging.DEBUG)
 # Create a file handler for logging
 log_file = os.path.join(get_app_directory(), "logs", "ocr_log.txt")
 os.makedirs(os.path.join(get_app_directory(), "logs"), exist_ok=True)
-file_handler = RotatingFileHandler(log_file, maxBytes=1024 * 1024, backupCount=5, encoding='utf-8')
+file_handler = RotatingFileHandler(log_file, maxBytes=1024 * 1024, backupCount=2, encoding='utf-8')
 file_handler.setLevel(logging.DEBUG)
 # Create a formatter and set it for the handler
 formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')

GameSentenceMiner/tools/ss_selector.py

@@ -1,22 +1,21 @@
-
+# TODO REMOVE THIS, DEPRECATED
 
 import os
 import sys
 import subprocess
 
+import tkinter as tk
+from PIL import Image, ImageTk
+from GameSentenceMiner.util.gsm_utils import sanitize_filename
+from GameSentenceMiner.util.configuration import get_temporary_directory, logger, ffmpeg_base_command_list
+from GameSentenceMiner.util import ffmpeg
+
 # Suppress stdout and stderr during imports
 sys_stdout = sys.stdout
 sys_stderr = sys.stderr
 sys.stdout = open(os.devnull, 'w')
 sys.stderr = open(os.devnull, 'w')
 
-import tkinter as tk
-from PIL import Image, ImageTk
-from GameSentenceMiner.util.gsm_utils import sanitize_filename
-from GameSentenceMiner.util.configuration import get_temporary_directory, logger
-from GameSentenceMiner.util.ffmpeg import ffmpeg_base_command_list
-from GameSentenceMiner.util import ffmpeg
-
 def extract_frames(video_path, timestamp, temp_dir, mode):
     frame_paths = []
     timestamp_number = float(timestamp)

GameSentenceMiner/ui/anki_confirmation.py

@@ -0,0 +1,187 @@
+import tkinter as tk
+from tkinter import scrolledtext
+from PIL import Image, ImageTk
+
+import ttkbootstrap as ttk
+from GameSentenceMiner.util.configuration import get_config, logger, gsm_state
+
+import platform
+import subprocess
+import os
+
+class AnkiConfirmationDialog(tk.Toplevel):
+    """
+    A modal dialog to confirm Anki card details and choose an audio option.
+    """
+    def __init__(self, parent, config_app, expression, sentence, screenshot_path, audio_path, translation, screenshot_timestamp):
+        super().__init__(parent)
+        self.config_app = config_app
+        self.screenshot_timestamp = screenshot_timestamp
+        
+        # Initialize screenshot_path here, will be updated by button if needed
+        self.screenshot_path = screenshot_path 
+
+        self.title("Confirm Anki Card Details")
+        self.result = None  # This will store the user's choice
+
+        # This makes the dialog block interaction with other windows.
+        self.grab_set()
+
+        # --- Create and lay out widgets ---
+        self._create_widgets(expression, sentence, screenshot_path, audio_path, translation)
+
+        # --- Smarter Centering Logic ---
+        self.update_idletasks()
+
+        if parent.state() == 'withdrawn':
+            screen_width = self.winfo_screenwidth()
+            screen_height = self.winfo_screenheight()
+            dialog_width = self.winfo_width()
+            dialog_height = self.winfo_height()
+            x = (screen_width // 2) - (dialog_width // 2)
+            y = (screen_height // 2) - (dialog_height // 2)
+            self.geometry(f'+{x}+{y}')
+        else:
+            self.transient(parent)
+            parent_x = parent.winfo_x()
+            parent_y = parent.winfo_y()
+            parent_width = parent.winfo_width()
+            parent_height = parent.winfo_height()
+            dialog_width = self.winfo_width()
+            dialog_height = self.winfo_height()
+            x = parent_x + (parent_width // 2) - (dialog_width // 2)
+            y = parent_y + (parent_height // 2) - (dialog_height // 2)
+            self.geometry(f'+{x}+{y}')
+
+        self.protocol("WM_DELETE_WINDOW", self._on_cancel)
+        self.attributes('-topmost', True)
+        self.wait_window(self)
+
+    def _create_widgets(self, expression, sentence, screenshot_path, audio_path, translation):
+        main_frame = ttk.Frame(self, padding=20)
+        main_frame.pack(expand=True, fill="both")
+
+        row = 0
+
+        # Expression
+        ttk.Label(main_frame, text=f"{get_config().anki.word_field}:", font=("-weight bold")).grid(row=row, column=0, sticky="ne", padx=5, pady=2)
+        ttk.Label(main_frame, text=expression, wraplength=400, justify="left").grid(row=row, column=1, sticky="w", padx=5, pady=2)
+        row += 1
+
+        # Sentence
+        ttk.Label(main_frame, text=f"{get_config().anki.sentence_field}:", font=("-weight bold")).grid(row=row, column=0, sticky="ne", padx=5, pady=2)
+        sentence_text = scrolledtext.ScrolledText(main_frame, height=4, width=50, wrap=tk.WORD)
+        sentence_text.insert(tk.END, sentence)
+        sentence_text.grid(row=row, column=1, sticky="w", padx=5, pady=2)
+        self.sentence_text = sentence_text
+        row += 1
+
+        # Translation
+        ttk.Label(main_frame, text=f"{get_config().ai.anki_field}:", font=("-weight bold")).grid(row=row, column=0, sticky="ne", padx=5, pady=2)
+        translation_text = scrolledtext.ScrolledText(main_frame, height=4, width=50, wrap=tk.WORD)
+        translation_text.insert(tk.END, translation)
+        translation_text.grid(row=row, column=1, sticky="w", padx=5, pady=2)
+        self.translation_text = translation_text
+        row += 1
+
+        # Screenshot
+        ttk.Label(main_frame, text=f"{get_config().anki.picture_field}:", font=("-weight bold")).grid(row=row, column=0, sticky="ne", padx=5, pady=2)
+        
+        # <<< CHANGED: Step 1 - Create and store the label for the image
+        self.image_label = ttk.Label(main_frame)
+        self.image_label.grid(row=row, column=1, sticky="w", padx=5, pady=2)
+        
+        try:
+            img = Image.open(screenshot_path)
+            img.thumbnail((400, 300))
+            self.photo_image = ImageTk.PhotoImage(img)
+            # Configure the label we just created
+            self.image_label.config(image=self.photo_image)
+            # Keep a reference on the widget itself to prevent garbage collection!
+            self.image_label.image = self.photo_image
+        except Exception as e:
+            # Configure the label to show an error message
+            self.image_label.config(text=f"Could not load image:\n{screenshot_path}\n{e}", foreground="red")
+       
+        # Open Screenshot Selector button
+        ttk.Button(main_frame, text="Open Screenshot Selector", command=self._get_different_screenshot).grid(row=row, column=2, sticky="w", padx=5, pady=2)
+       
+        row += 1
+        
+        # Audio Path
+        ttk.Label(main_frame, text="Audio Path:", font=("-weight bold")).grid(row=row, column=0, sticky="ne", padx=5, pady=2)
+        ttk.Label(main_frame, text=audio_path if audio_path else "No Audio", wraplength=400, justify="left").grid(row=row, column=1, sticky="w", padx=5, pady=2)
+        if audio_path and os.path.isfile(audio_path):
+            ttk.Button(main_frame, text="Play Audio", command=lambda: self._play_audio(audio_path)).grid(row=row, column=2, sticky="w", padx=5, pady=2)
+            
+        row += 1
+
+        # Action Buttons
+        button_frame = ttk.Frame(main_frame)
+        button_frame.grid(row=row, column=0, columnspan=2, pady=15)
+        if audio_path and os.path.isfile(audio_path):
+            ttk.Button(button_frame, text="Voice", command=self._on_voice, bootstyle="success").pack(side="left", padx=10)
+            ttk.Button(button_frame, text="NO Voice", command=self._on_no_voice, bootstyle="danger").pack(side="left", padx=10)
+        else:
+            ttk.Button(button_frame, text="Confirm", command=self._on_no_voice, bootstyle="primary").pack(side="left", padx=10)
+        
+        
+    def _get_different_screenshot(self):
+        video_path = gsm_state.current_replay
+        new_screenshot_path = self.config_app.show_screenshot_selector(
+            video_path, self.screenshot_timestamp, mode=get_config().screenshot.screenshot_timing_setting
+        )
+
+        # If the user cancels the selector, it might return None or an empty string
+        if not new_screenshot_path:
+            return
+
+        self.screenshot_path = new_screenshot_path # Update the path to be returned later
+
+        try:
+            img = Image.open(self.screenshot_path)
+            img.thumbnail((400, 300))
+            # Create the new image object
+            self.photo_image = ImageTk.PhotoImage(img)
+
+            # <<< CHANGED: Step 2 - Update the label with the new image
+            self.image_label.config(image=self.photo_image, text="") # Clear any previous error text
+            
+            # This is crucial! Keep a reference to the new image object on the widget
+            # itself, so it doesn't get garbage-collected.
+            self.image_label.image = self.photo_image
+        
+        except Exception as e:
+            # Handle cases where the newly selected file is invalid
+            self.image_label.config(image=None, text=f"Could not load new image:\n{e}", foreground="red")
+            self.image_label.image = None # Clear old image reference
+
+
+    def _play_audio(self, audio_path):
+        if not os.path.isfile(audio_path):
+            print(f"Audio file does not exist: {audio_path}")
+            return
+        try:
+            if platform.system() == "Windows":
+                os.startfile(audio_path)
+            elif platform.system() == "Darwin":
+                subprocess.run(["open", audio_path])
+            else:
+                subprocess.run(["xdg-open", audio_path])
+        except Exception as e:
+            print(f"Failed to play audio: {e}")
+        
+    def _on_voice(self):
+        # The screenshot_path is now correctly updated if the user chose a new one
+        self.result = (True, self.sentence_text.get("1.0", tk.END).strip(), self.translation_text.get("1.0", tk.END).strip(), self.screenshot_path)
+        self.destroy()
+
+    def _on_no_voice(self):
+        self.result = (False, self.sentence_text.get("1.0", tk.END).strip(), self.translation_text.get("1.0", tk.END).strip(), self.screenshot_path)
+        self.destroy()
+        
+    def _on_cancel(self):
+        # We block the cancel button, but if you wanted to enable it:
+        # self.result = None
+        # self.destroy()
+        pass