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

GameSentenceMiner/{config_gui.py → ui/config_gui.py}

@@ -7,11 +7,14 @@ import sys
 import time
 import tkinter as tk
 from tkinter import filedialog, messagebox, simpledialog, scrolledtext, font
+from PIL import Image, ImageTk
 
 import pyperclip
 import ttkbootstrap as ttk
 
 from GameSentenceMiner import obs
+from GameSentenceMiner.ui.anki_confirmation import AnkiConfirmationDialog
+from GameSentenceMiner.ui.screenshot_selector import ScreenshotSelectorDialog
 from GameSentenceMiner.util import configuration
 from GameSentenceMiner.util.communication.send import send_restart_signal
 from GameSentenceMiner.util.configuration import Config, Locale, logger, CommonLanguages, ProfileConfig, General, Paths, \
@@ -40,7 +43,7 @@ def load_localization(locale=Locale.English):
     try:
         # Use a path relative to this script file
         script_dir = os.path.dirname(os.path.abspath(__file__))
-        lang_file = os.path.join(script_dir, 'locales', f'{locale.value}.json')
+        lang_file = os.path.join(script_dir, '..', 'locales', f'{locale.value}.json')
         with open(lang_file, 'r', encoding='utf-8') as f:
             return json.load(f)['python']['config']
     except (FileNotFoundError, json.JSONDecodeError) as e:
@@ -167,7 +170,6 @@ class ResetToDefaultButton(ttk.Button):
             self.tooltip.destroy()
             self.tooltip = None
 
-
 class ConfigApp:
     def __init__(self, root):
         self.window = root
@@ -267,6 +269,56 @@ class ConfigApp:
     def set_test_func(self, func):
         self.test_func = func
         
+    def show_anki_confirmation_dialog(self, expression, sentence, screenshot_path, audio_path, translation, ss_timestamp):
+        """
+        Displays a modal dialog for the user to confirm Anki card details and
+        choose whether to include audio.
+
+        Args:
+            expression (str): The target word or expression.
+            sentence (str): The full sentence.
+            screenshot_path (str): The file path to the screenshot image.
+            audio_path (str): The file path to the audio clip.
+            translation (str): The translation or definition.
+
+        Returns:
+            str: 'voice' if the user chooses to add with voice,
+                 'no_voice' if they choose to add without voice,
+                 or None if they cancel.
+        """
+        dialog = AnkiConfirmationDialog(self.window,
+                                        self,
+                                        expression=expression,
+                                        sentence=sentence,
+                                        screenshot_path=screenshot_path,
+                                        audio_path=audio_path,
+                                        translation=translation,
+                                        screenshot_timestamp=ss_timestamp)
+        return dialog.result
+    
+    def show_screenshot_selector(self, video_path, timestamp, mode='beginning'):
+        """
+        Displays a modal dialog for the user to select the best screenshot from
+        a series of extracted video frames.
+
+        Args:
+            video_path (str): The file path to the source video.
+            timestamp (str or float): The timestamp (in seconds) around which to extract frames.
+            mode (str): 'beginning', 'middle', or 'end'. Determines the time offset
+                        and which frame is highlighted as the "golden" frame.
+
+        Returns:
+            str: The file path of the image the user selected, or None if they canceled.
+        """
+        dialog = ScreenshotSelectorDialog(self.window,
+                                          self,
+                                          video_path=video_path,
+                                          timestamp=str(timestamp), # Ensure it's a string for ffmpeg
+                                          mode=mode)
+        
+        print(dialog.selected_path)
+        return dialog.selected_path
+        
     def create_vars(self):
         """
         Initializes all the tkinter variables used in the configuration GUI.
@@ -290,9 +342,8 @@ class ConfigApp:
         self.obs_password_value = tk.StringVar(value=self.settings.obs.password)
         self.obs_open_obs_value = tk.BooleanVar(value=self.settings.obs.open_obs)
         self.obs_close_obs_value = tk.BooleanVar(value=self.settings.obs.close_obs)
-        self.obs_get_game_from_scene_name_value = tk.BooleanVar(value=self.settings.obs.get_game_from_scene)
         self.obs_minimum_replay_size_value = tk.StringVar(value=str(self.settings.obs.minimum_replay_size))
-        self.obs_turn_off_output_check_value = tk.BooleanVar(value=self.settings.obs.turn_off_output_check)
+        self.automatically_manage_replay_buffer_value = tk.BooleanVar(value=self.settings.obs.automatically_manage_replay_buffer)
         
         # Paths Settings
         self.folder_to_watch_value = tk.StringVar(value=self.settings.paths.folder_to_watch)
@@ -306,6 +357,7 @@ class ConfigApp:
 
         # Anki Settings
         self.update_anki_value = tk.BooleanVar(value=self.settings.anki.update_anki)
+        self.show_update_confirmation_dialog_value = tk.BooleanVar(value=self.settings.anki.show_update_confirmation_dialog)
         self.anki_url_value = tk.StringVar(value=self.settings.anki.url)
         self.sentence_field_value = tk.StringVar(value=self.settings.anki.sentence_field)
         self.sentence_audio_field_value = tk.StringVar(value=self.settings.anki.sentence_audio_field)
@@ -331,6 +383,7 @@ class ConfigApp:
         self.open_anki_browser_value = tk.BooleanVar(value=self.settings.features.open_anki_in_browser)
         self.backfill_audio_value = tk.BooleanVar(value=self.settings.features.backfill_audio)
         self.browser_query_value = tk.StringVar(value=self.settings.features.browser_query)
+        self.generate_longplay_value = tk.BooleanVar(value=self.settings.features.generate_longplay)
         
         # Screenshot Settings
         self.screenshot_enabled_value = tk.BooleanVar(value=self.settings.screenshot.enabled)
@@ -534,6 +587,7 @@ class ConfigApp:
             ),
             anki=Anki(
                 update_anki=self.update_anki_value.get(),
+                show_update_confirmation_dialog=self.show_update_confirmation_dialog_value.get(),
                 url=self.anki_url_value.get(),
                 sentence_field=self.sentence_field_value.get(),
                 sentence_audio_field=self.sentence_audio_field_value.get(),
@@ -559,6 +613,7 @@ class ConfigApp:
                 open_anki_in_browser=self.open_anki_browser_value.get(),
                 backfill_audio=self.backfill_audio_value.get(),
                 browser_query=self.browser_query_value.get(),
+                generate_longplay=self.generate_longplay_value.get(),
             ),
             screenshot=Screenshot(
                 enabled=self.screenshot_enabled_value.get(),
@@ -590,9 +645,8 @@ class ConfigApp:
                 host=self.obs_host_value.get(),
                 port=int(self.obs_port_value.get()),
                 password=self.obs_password_value.get(),
-                get_game_from_scene=self.obs_get_game_from_scene_name_value.get(),
                 minimum_replay_size=int(self.obs_minimum_replay_size_value.get()),
-                turn_off_output_check=self.obs_turn_off_output_check_value.get()
+                automatically_manage_replay_buffer=self.automatically_manage_replay_buffer_value.get()
             ),
             hotkeys=Hotkeys(
                 reset_line=self.reset_line_hotkey_value.get(),
@@ -647,8 +701,8 @@ class ConfigApp:
                 monitor_to_capture=self.overlay_monitor.current() if self.monitors else 0,
                 engine=OverlayEngine(self.overlay_engine_value.get()).value if self.overlay_engine_value.get() else OverlayEngine.LENS.value,
                 scan_delay=float(self.scan_delay_value.get()),
-                periodic=self.periodic_value.get(),
-                periodic_interval=self.periodic_interval_value.get(),
+                periodic=float(self.periodic_value.get()),
+                periodic_interval=float(self.periodic_interval_value.get()),
             )
             # wip=WIP(
             #     overlay_websocket_port=int(self.overlay_websocket_port_value.get()),
@@ -838,21 +892,6 @@ class ConfigApp:
                                 row=self.current_row, column=0)
         ttk.Combobox(self.general_tab, textvariable=self.native_language_value, values=CommonLanguages.get_all_names_pretty(), state="readonly").grid(row=self.current_row, column=1, sticky='EW', pady=2)
         self.current_row += 1
-
-        legend_i18n = general_i18n.get('legend', {})
-        ttk.Label(self.general_tab, text=legend_i18n.get('important', '...'), foreground="dark orange",
-                  font=("Helvetica", 10, "bold")).grid(row=self.current_row, column=0, columnspan=2, sticky='W', pady=2)
-        self.current_row += 1
-        ttk.Label(self.general_tab, text=legend_i18n.get('advanced', '...'), foreground="red",
-                  font=("Helvetica", 10, "bold")).grid(row=self.current_row, column=0, columnspan=2, sticky='W', pady=2)
-        self.current_row += 1
-        ttk.Label(self.general_tab, text=legend_i18n.get('recommended', '...'), foreground="green",
-                  font=("Helvetica", 10, "bold")).grid(row=self.current_row, column=0, columnspan=2, sticky='W', pady=2)
-        self.current_row += 1
-        ttk.Label(self.general_tab,
-                  text=legend_i18n.get('tooltip_info', '...'),
-                  font=("Helvetica", 10, "bold")).grid(row=self.current_row, column=0, columnspan=2, sticky='W', pady=2)
-        self.current_row += 1
         
         if is_beangate:
             ttk.Button(self.general_tab, text=self.i18n.get('buttons', {}).get('run_function', 'Run Function'), command=self.test_func, bootstyle="info").grid(
@@ -1040,6 +1079,26 @@ class ConfigApp:
             row=self.current_row, column=3, sticky='W', pady=2)
         self.current_row += 1
         
+        # Add Horizontal Separator
+        sep = ttk.Separator(feature_frame, orient='horizontal')
+        sep.grid(row=self.current_row, column=0, columnspan=5, sticky='EW', pady=10)
+        self.current_row += 1
+
+        legend_i18n = general_i18n.get('legend', {})
+        ttk.Label(feature_frame,
+            text=legend_i18n.get('tooltip_info', '...'),
+            font=("Helvetica", 10, "bold")).grid(row=self.current_row, column=0, columnspan=2, sticky='W', pady=2)
+        self.current_row += 1
+        ttk.Label(feature_frame, text=legend_i18n.get('important', '...'), foreground="dark orange",
+                  font=("Helvetica", 10, "bold")).grid(row=self.current_row, column=0, columnspan=2, sticky='W', pady=2)
+        self.current_row += 1
+        ttk.Label(feature_frame, text=legend_i18n.get('advanced', '...'), foreground="red",
+                  font=("Helvetica", 10, "bold")).grid(row=self.current_row, column=0, columnspan=2, sticky='W', pady=2)
+        self.current_row += 1
+        ttk.Label(feature_frame, text=legend_i18n.get('recommended', '...'), foreground="green",
+                  font=("Helvetica", 10, "bold")).grid(row=self.current_row, column=0, columnspan=2, sticky='W', pady=2)
+        self.current_row += 1
+        
         # screenshot_i18n = simple_i18n.get('screenshot_enabled', {})
         # HoverInfoLabelWidget(feature_frame, text=screenshot_i18n.get('label', '...'),
         #                      tooltip=screenshot_i18n.get('tooltip', '...'), row=self.current_row, column=0)
@@ -1318,6 +1377,13 @@ class ConfigApp:
                                                                                               column=1, sticky='W', pady=2)
         self.current_row += 1
 
+        show_confirmation_i18n = anki_i18n.get('show_update_confirmation_dialog', {})
+        HoverInfoLabelWidget(anki_frame, text=show_confirmation_i18n.get('label', '...'), tooltip=show_confirmation_i18n.get('tooltip', '...'),
+                             foreground="red", font=("Helvetica", 10, "bold"), row=self.current_row, column=0)
+        ttk.Checkbutton(anki_frame, variable=self.show_update_confirmation_dialog_value, bootstyle="round-toggle").grid(row=self.current_row,
+                                                                                              column=1, sticky='W', pady=2)
+        self.current_row += 1
+
         url_i18n = anki_i18n.get('url', {})
         HoverInfoLabelWidget(anki_frame, text=url_i18n.get('label', '...'), tooltip=url_i18n.get('tooltip', '...'),
                              foreground="dark orange", font=("Helvetica", 10, "bold"), row=self.current_row, column=0)
@@ -1492,6 +1558,12 @@ class ConfigApp:
             row=self.current_row, column=1, sticky='W', pady=2)
         self.current_row += 1
 
+        HoverInfoLabelWidget(features_frame, text="Generate LongPlay", tooltip="Generate a LongPlay video using OBS recording, and write to a .srt file with all the text coming into gsm. RESTART REQUIRED FOR SETTING TO TAKE EFFECT.",
+                             row=self.current_row, column=0)
+        ttk.Checkbutton(features_frame, variable=self.generate_longplay_value, bootstyle="round-toggle").grid(
+            row=self.current_row, column=1, sticky='W', pady=2)
+        self.current_row += 1
+
         self.add_reset_button(features_frame, "features", self.current_row, 0, self.create_features_tab)
 
         for col in range(3):
@@ -1797,13 +1869,6 @@ class ConfigApp:
         ttk.Entry(obs_frame, show="*", textvariable=self.obs_password_value).grid(row=self.current_row, column=1, sticky='EW', pady=2)
         self.current_row += 1
 
-        game_scene_i18n = obs_i18n.get('game_from_scene', {})
-        HoverInfoLabelWidget(obs_frame, text=game_scene_i18n.get('label', '...'), tooltip=game_scene_i18n.get('tooltip', '...'),
-                             row=self.current_row, column=0)
-        ttk.Checkbutton(obs_frame, variable=self.obs_get_game_from_scene_name_value, bootstyle="round-toggle").grid(
-            row=self.current_row, column=1, sticky='W', pady=2)
-        self.current_row += 1
-
         min_size_i18n = obs_i18n.get('min_replay_size', {})
         HoverInfoLabelWidget(obs_frame, text=min_size_i18n.get('label', '...'),
                              tooltip=min_size_i18n.get('tooltip', '...'),
@@ -1811,13 +1876,13 @@ class ConfigApp:
         ttk.Entry(obs_frame, textvariable=self.obs_minimum_replay_size_value).grid(row=self.current_row, column=1, sticky='EW', pady=2)
         self.current_row += 1
 
-        turn_off_output_check_i18n = obs_i18n.get('turn_off_output_check', {})
-        HoverInfoLabelWidget(obs_frame, text=turn_off_output_check_i18n.get('label', '...'),
-                             tooltip=turn_off_output_check_i18n.get('tooltip', '...'),
-                             row=self.current_row, column=0)
-        ttk.Checkbutton(obs_frame, variable=self.obs_turn_off_output_check_value, bootstyle="round-toggle").grid(
-            row=self.current_row, column=1, sticky='W', pady=2)
-        self.current_row += 1
+        # turn_off_output_check_i18n = obs_i18n.get('turn_off_replay_buffer_management', {})
+        # HoverInfoLabelWidget(obs_frame, text=turn_off_output_check_i18n.get('label', '...'),
+        #                      tooltip=turn_off_output_check_i18n.get('tooltip', '...'),
+        #                      row=self.current_row, column=0)
+        # ttk.Checkbutton(obs_frame, variable=self.obs_turn_off_output_check_value, bootstyle="round-toggle").grid(
+        #     row=self.current_row, column=1, sticky='W', pady=2)
+        # self.current_row += 1
 
         self.add_reset_button(obs_frame, "obs", self.current_row, 0, self.create_obs_tab)
 

GameSentenceMiner/ui/screenshot_selector.py

@@ -0,0 +1,215 @@
+import os
+import subprocess
+import json
+import tkinter as tk
+from tkinter import messagebox
+import ttkbootstrap as ttk
+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, get_ffprobe_path
+
+
+class ScreenshotSelectorDialog(tk.Toplevel):
+    """
+    A modal dialog that extracts frames from a video around a specific timestamp
+    and allows the user to select the best one.
+    """
+    def __init__(self, parent, config_app, video_path, timestamp, mode='beginning'):
+        super().__init__(parent)
+        self.config_app = config_app
+
+        self.title("Select Screenshot")
+        self.configure(bg="black")
+        self.selected_path = None # This will store the final result
+        self.parent_window = parent # Store a reference to the parent
+
+        # Handle the user closing the window with the 'X' button
+        self.protocol("WM_DELETE_WINDOW", self._on_cancel)
+
+        # Make the dialog modal
+        self.grab_set()
+
+        # --- Show a loading message while ffmpeg runs ---
+        self.loading_label = ttk.Label(
+            self,
+            text="Extracting frames, please wait...",
+            bootstyle="inverse-primary",
+            font=("Helvetica", 16)
+        )
+        self.loading_label.pack(pady=50, padx=50)
+        self.update() # Force the UI to update and show the label
+
+        # --- Run extraction and build the main UI ---
+        try:
+            image_paths, golden_frame = self._extract_frames(video_path, timestamp, mode)
+            self.loading_label.destroy() # Remove the loading message
+
+            if not image_paths:
+                messagebox.showerror("Error", "Failed to extract frames from the video.", parent=self)
+                self.destroy()
+                return
+
+            self._build_image_grid(image_paths, golden_frame)
+
+        except Exception as e:
+            logger.error(f"ScreenshotSelector failed: {e}")
+            messagebox.showerror("Error", f"An unexpected error occurred: {e}", parent=self)
+            self.destroy()
+            return
+
+        # --- Center the dialog and wait for it to close ---
+        self._center_window()
+        self.attributes('-topmost', True)
+        self.wait_window(self)
+        # Force always on top to ensure visibility
+
+    def _extract_frames(self, video_path, timestamp, mode):
+        """Extracts frames using ffmpeg. Encapsulated from the original script."""
+        temp_dir = os.path.join(
+            get_temporary_directory(False),
+            "screenshot_frames",
+            sanitize_filename(os.path.splitext(os.path.basename(video_path))[0])
+        )
+        os.makedirs(temp_dir, exist_ok=True)
+
+        frame_paths = []
+        golden_frame = None
+        timestamp_number = float(timestamp)
+        video_duration = self.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.warning(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, text=True)
+
+            for i in range(1, 21):
+                frame_path = os.path.join(temp_dir, f"frame_{i:02d}.png")
+                if os.path.exists(frame_path):
+                    frame_paths.append(frame_path)
+
+            if not frame_paths: return [], None
+
+            if mode == "beginning":
+                golden_frame = frame_paths[0] if frame_paths else None
+            elif mode == "middle":
+                golden_frame = frame_paths[len(frame_paths) // 2] if frame_paths else None
+            elif mode == "end":
+                golden_frame = frame_paths[-1] if frame_paths else None
+
+            return frame_paths, golden_frame
+
+        except subprocess.CalledProcessError as e:
+            logger.error(f"Error extracting frames: {e}")
+            logger.error(f"FFmpeg command was: {' '.join(command)}")
+            logger.error(f"FFmpeg output:\n{e.stderr}")
+            return [], None
+        except Exception as e:
+            logger.error(f"An unexpected error occurred during frame extraction: {e}")
+            return [], None
+
+    def _build_image_grid(self, image_paths, golden_frame):
+        """Creates and displays the grid of selectable images."""
+        self.images = [] # Keep a reference to images to prevent garbage collection
+        max_cols = 5
+        for i, path in enumerate(image_paths):
+            try:
+                img = Image.open(path)
+                # Use a larger thumbnail size for better visibility
+                # Making this division-based can be risky if images are very small
+                # Let's use a fixed thumbnail size for robustness
+                img.thumbnail((256, 144))
+                img_tk = ImageTk.PhotoImage(img)
+                self.images.append(img_tk)
+
+                is_golden = (path == golden_frame)
+                border_width = 4 if is_golden else 2
+                border_color = "gold" if is_golden else "grey"
+                
+                # Using a Frame for better border control
+                frame = tk.Frame(self, bg=border_color, borderwidth=border_width, relief="solid")
+                frame.grid(row=i // max_cols, column=i % max_cols, padx=3, pady=3)
+
+                label = tk.Label(frame, image=img_tk, borderwidth=0, bg="black")
+                label.pack()
+
+                # Bind the click event to both the frame and the label for better UX
+                frame.bind("<Button-1>", lambda e, p=path: self._on_image_click(p))
+                label.bind("<Button-1>", lambda e, p=path: self._on_image_click(p))
+
+            except Exception as e:
+                logger.error(f"Could not load image {path}: {e}")
+                error_label = ttk.Label(self, text="Load Error", bootstyle="inverse-danger", width=30, anchor="center")
+                error_label.grid(row=i // max_cols, column=i % max_cols, padx=3, pady=3, ipadx=10, ipady=50)
+
+    def _on_image_click(self, path):
+        """Handles a user clicking on an image."""
+        self.selected_path = path
+        self.destroy()
+
+    def _on_cancel(self):
+        """Handles the user closing the window without a selection."""
+        self.selected_path = None
+        self.destroy()
+
+    def _center_window(self):
+        """
+        Smarter centering logic. Centers on the parent if it's visible,
+        otherwise centers on the screen.
+        """
+        self.update_idletasks()
+        
+        parent = self.parent_window
+        dialog_width = self.winfo_width()
+        dialog_height = self.winfo_height()
+
+        if parent.state() == 'withdrawn':
+            # PARENT IS HIDDEN: Center the dialog on the screen
+            screen_width = self.winfo_screenwidth()
+            screen_height = self.winfo_screenheight()
+            x = (screen_width // 2) - (dialog_width // 2)
+            y = (screen_height // 2) - (dialog_height // 2)
+        else:
+            # PARENT IS VISIBLE: Center relative to the parent window
+            self.transient(parent) # Associate dialog with its parent
+            parent_x = parent.winfo_x()
+            parent_y = parent.winfo_y()
+            parent_width = parent.winfo_width()
+            parent_height = parent.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}')
+
+    def get_video_duration(self, file_path):
+        try:
+            ffprobe_command = [
+                f"{get_ffprobe_path()}",
+                "-v", "error",
+                "-show_entries", "format=duration",
+                "-of", "json",
+                file_path
+            ]
+            logger.debug(" ".join(ffprobe_command))
+            result = subprocess.run(ffprobe_command, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True, check=True)
+            duration_info = json.loads(result.stdout)
+            logger.debug(f"Video duration: {duration_info}")
+            return float(duration_info["format"]["duration"])
+        except (subprocess.CalledProcessError, json.JSONDecodeError, KeyError, FileNotFoundError) as e:
+            logger.error(f"Failed to get video duration for {file_path}: {e}")
+            return None