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

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

GameSentenceMiner/util/configuration.py

@@ -4,10 +4,13 @@ import logging
 import os
 import shutil
 import threading
+import inspect
+
 from dataclasses import dataclass, field
 from logging.handlers import RotatingFileHandler
 from os.path import expanduser
 from sys import platform
+import time
 from typing import List, Dict
 import sys
 from enum import Enum
@@ -19,6 +22,7 @@ from importlib import metadata
 
 
 
+
 OFF = 'OFF'
 # VOSK = 'VOSK'
 SILERO = 'SILERO'
@@ -355,7 +359,7 @@ def get_current_version():
         version = metadata.version(PACKAGE_NAME)
         return version
     except metadata.PackageNotFoundError:
-        return None
+        return ""
 
 
 def get_latest_version():
@@ -429,6 +433,7 @@ class Paths:
 @dataclass
 class Anki:
     update_anki: bool = True
+    show_update_confirmation_dialog: bool = False
     url: str = 'http://127.0.0.1:8765'
     sentence_field: str = "Sentence"
     sentence_audio_field: str = "SentenceAudio"
@@ -464,6 +469,7 @@ class Features:
     open_anki_in_browser: bool = True
     browser_query: str = ''
     backfill_audio: bool = False
+    generate_longplay: bool = False
 
 
 @dataclass_json
@@ -529,12 +535,16 @@ class Audio:
 class OBS:
     open_obs: bool = True
     close_obs: bool = True
+    automatically_manage_replay_buffer: bool = True
     host: str = "127.0.0.1"
     port: int = 7274
     password: str = "your_password"
     get_game_from_scene: bool = True
     minimum_replay_size: int = 0
-    turn_off_output_check: bool = False
+    
+    def __post__init__(self):
+        # Force get_game_from_scene to be True
+        self.get_game_from_scene = True
 
 
 @dataclass_json
@@ -554,7 +564,7 @@ class VAD:
     language: str = 'ja'
     # vosk_url: str = VOSK_BASE
     selected_vad_model: str = WHISPER
-    backup_vad_model: str = SILERO
+    backup_vad_model: str = OFF
     trim_beginning: bool = False
     beginning_offset: float = -0.25
     add_audio_on_no_results: bool = False
@@ -565,6 +575,10 @@ class VAD:
     use_cpu_for_inference: bool = False
     use_vad_filter_for_whisper: bool = True
 
+    def __post_init__(self):
+        if self.selected_vad_model == self.backup_vad_model:
+            self.backup_vad_model = OFF
+
     def is_silero(self):
         return self.selected_vad_model == SILERO or self.backup_vad_model == SILERO
 
@@ -797,6 +811,9 @@ class StatsConfig:
     reading_hours_target: int = 1500  # Target reading hours based on TMW N1 achievement data
     character_count_target: int = 25000000  # Target character count (25M) inspired by Discord server milestones
     games_target: int = 100  # Target VNs/games completed based on Refold community standards
+    reading_hours_target_date: str = ""  # Target date for reading hours goal (ISO format: YYYY-MM-DD)
+    character_count_target_date: str = ""  # Target date for character count goal (ISO format: YYYY-MM-DD)
+    games_target_date: str = ""  # Target date for games/VNs goal (ISO format: YYYY-MM-DD)
 
 @dataclass_json
 @dataclass
@@ -806,6 +823,7 @@ class Config:
     switch_to_default_if_not_found: bool = True
     locale: str = Locale.English.value
     stats: StatsConfig = field(default_factory=StatsConfig)
+    version: str = ""
 
     @classmethod
     def new(cls):
@@ -842,6 +860,26 @@ class Config:
                     self.stats.session_gap_seconds = profile.advanced.session_gap_seconds
                 if profile.advanced.streak_requirement_hours != default_stats.streak_requirement_hours:
                     self.stats.streak_requirement_hours = profile.advanced.streak_requirement_hours
+        
+        # Add a way to migrate certain things based on version if needed, also help with better defaults
+        if self.version:
+            if self.version != get_current_version():
+                logger.info(f"Config version mismatch detected: {self.version} != {get_current_version()}")
+                # Handle version mismatch
+                changed = False
+                if self.version < "2.18.0":
+                    changed = True
+                    # Example, doesn't need to be done
+                    for profile in self.configs.values():
+                        profile.obs.get_game_from_scene = True
+                        # Whisper basically uses Silero's VAD internally, so no need for backup
+                        if profile.vad.selected_vad_model == WHISPER and profile.vad.backup_vad_model == SILERO:
+                            profile.vad.backup_vad_model = OFF
+
+                if changed:
+                    self.save()
+
+        self.version = get_current_version()
 
     def save(self):
         with open(get_config_path(), 'w') as file:
@@ -1000,8 +1038,40 @@ def get_app_directory():
     return config_dir
 
 
+def get_logger_name():
+    """Determine the appropriate logger name based on the calling context."""
+    frame = inspect.currentframe()
+    try:
+        # Go up the call stack to find the main module
+        while frame:
+            filename = frame.f_code.co_filename
+            if filename.endswith(('gsm.py', 'gamesentenceminer.py', '__main__.py')):
+                return "GameSentenceMiner"
+            elif 'ocr' in filename.lower():
+                return "misc_ocr_utils"
+            elif 'overlay' in filename.lower():
+                return "GSM_Overlay"
+            frame = frame.f_back
+        
+        # Fallback: check the main module name
+        main_module = inspect.getmodule(inspect.stack()[-1][0])
+        if main_module and hasattr(main_module, '__file__'):
+            main_file = os.path.basename(main_module.__file__)
+            if main_file in ('gsm.py', 'gamesentenceminer.py'):
+                return "GameSentenceMiner"
+            elif 'ocr' in main_file.lower():
+                return "misc_ocr_utils"
+            elif 'overlay' in main_file.lower():
+                return "GSM_Overlay"
+
+        return "GameSentenceMiner"  # Default fallback
+    finally:
+        del frame
+        
+logger_name = get_logger_name()
+
 def get_log_path():
-    path = os.path.join(get_app_directory(), "logs", 'gamesentenceminer.log')
+    path = os.path.join(get_app_directory(), "logs", f'{logger_name.lower()}.log')
     os.makedirs(os.path.dirname(path), exist_ok=True)
     return path
 
@@ -1139,7 +1209,7 @@ def switch_profile_and_save(profile_name):
 sys.stdout.reconfigure(encoding='utf-8')
 sys.stderr.reconfigure(encoding='utf-8')
 
-logger = logging.getLogger("GameSentenceMiner")
+logger = logging.getLogger(logger_name)
 # Set the base level to DEBUG so that all messages are captured
 logger.setLevel(logging.DEBUG)
 formatter = logging.Formatter(
@@ -1154,27 +1224,47 @@ console_handler.setFormatter(formatter)
 logger.addHandler(console_handler)
 
 file_path = get_log_path()
-try:
-    if os.path.exists(file_path) and os.path.getsize(file_path) > 1 * 1024 * 1024 and os.access(file_path, os.W_OK):
-        old_log_path = os.path.join(os.path.dirname(
-            file_path), "gamesentenceminer_old.log")
-        if os.path.exists(old_log_path):
-            os.remove(old_log_path)
-        shutil.move(file_path, old_log_path)
-except Exception as e:
-    logger.info(
-        "Couldn't rotate log, probably because the file is being written to by another process. NOT AN ERROR")
-
-file_handler = logging.FileHandler(file_path, encoding='utf-8')
-file_handler.setLevel(logging.DEBUG)
-file_handler.setFormatter(formatter)
-logger.addHandler(file_handler)
+# Use RotatingFileHandler for automatic log rotation
+rotating_handler = RotatingFileHandler(
+    file_path, 
+    maxBytes=10 * 1024 * 1024,  # 10MB
+    backupCount=5 if logger_name == "GameSentenceMiner" else 0,  # Keep more logs for OCR and Overlay
+    encoding='utf-8'
+)
+rotating_handler.setLevel(logging.DEBUG)
+rotating_handler.setFormatter(formatter)
+logger.addHandler(rotating_handler)
 
 DB_PATH = os.path.join(get_app_directory(), 'gsm.db')
 
 
+# Clean up files in log directory older than 7 days
+def cleanup_old_logs(days=7):
+    log_dir = os.path.dirname(get_log_path())
+    now = time.time()
+    cutoff = now - (days * 86400)  # 86400 seconds in a day
+
+    if os.path.exists(log_dir):
+        for filename in os.listdir(log_dir):
+            file_path = os.path.join(log_dir, filename)
+            if os.path.isfile(file_path):
+                file_modified = os.path.getmtime(file_path)
+                if file_modified < cutoff:
+                    try:
+                        os.remove(file_path)
+                        logger.info(f"Deleted old log file: {file_path}")
+                    except Exception as e:
+                        logger.error(f"Error deleting file {file_path}: {e}")
+
+try:
+    cleanup_old_logs()
+except Exception as e:
+    logger.warning(f"Error during log cleanup: {e}")
+
+
 class GsmAppState:
     def __init__(self):
+        self.config_app = None
         self.line_for_audio = None
         self.line_for_screenshot = None
         self.anki_note_for_screenshot = None
@@ -1184,11 +1274,15 @@ class GsmAppState:
         self.previous_audio = None
         self.previous_screenshot = None
         self.previous_replay = None
+        self.current_replay = None
         self.lock = threading.Lock()
         self.last_mined_line = None
         self.keep_running = True
         self.current_game = ''
         self.videos_to_remove = set()
+        self.recording_started_time = None
+        self.current_srt = None
+        self.srt_index = 1
 
 
 @dataclass_json
@@ -1237,8 +1331,6 @@ def is_running_from_source():
     while project_root != os.path.dirname(project_root):  # Avoid infinite loop
         if os.path.isdir(os.path.join(project_root, '.git')):
             return True
-        if os.path.isfile(os.path.join(project_root, 'pyproject.toml')):
-            return True
         project_root = os.path.dirname(project_root)
     return False
 
@@ -1250,5 +1342,15 @@ is_dev = is_running_from_source()
 
 is_beangate = os.path.exists("C:/Users/Beangate")
 
+
+def get_ffmpeg_path():
+    return os.path.join(get_app_directory(), "ffmpeg", "ffmpeg.exe") if is_windows() else "ffmpeg"
+
+def get_ffprobe_path():
+    return os.path.join(get_app_directory(), "ffmpeg", "ffprobe.exe") if is_windows() else "ffprobe"
+
+ffmpeg_base_command_list = [get_ffmpeg_path(), "-hide_banner", "-loglevel", "error", '-nostdin']
+
+
 # logger.debug(f"Running in development mode: {is_dev}")
 # logger.debug(f"Running on Beangate's PC: {is_beangate}")

GameSentenceMiner/util/db.py

@@ -110,6 +110,11 @@ class SQLiteDBTable:
             pk_def = f"{cls._pk} TEXT PRIMARY KEY" if not cls._auto_increment else f"{cls._pk} INTEGER PRIMARY KEY AUTOINCREMENT"
             create_table_sql = f"CREATE TABLE IF NOT EXISTS {cls._table} ({pk_def}, {fields_def})"
             db.create_table(create_table_sql)
+        # Check for missing columns and add them
+        existing_columns = [col[1] for col in db.fetchall(f"PRAGMA table_info({cls._table})")]
+        for field in cls._fields:
+            if field not in existing_columns:
+                db.execute(f"ALTER TABLE {cls._table} ADD COLUMN {field} TEXT", commit=True)
 
     @classmethod
     def all(cls: Type[T]) -> List[T]:
@@ -135,15 +140,17 @@ class SQLiteDBTable:
         fields = [cls._pk] + cls._fields
         for i, field in enumerate(fields):
             if i == 0 and field == cls._pk:
-                if cls._types[i] == int:
+                if cls._types[i] is int:
                     setattr(obj, field, int(row[i])
                             if row[i] is not None else None)
-                elif cls._types[i] == str:
+                elif cls._types[i] is str:
                     setattr(obj, field, str(row[i])
                             if row[i] is not None else None)
                 continue
-            if cls._types[i] == str:
-                if (row[i].startswith('[') or row[i].startswith('{')):
+            if cls._types[i] is str:
+                if not row[i]:
+                    setattr(obj, field, "")
+                elif (row[i].startswith('[') or row[i].startswith('{')):
                     try:
                         setattr(obj, field, json.loads(row[i]))
                     except json.JSONDecodeError:
@@ -151,21 +158,21 @@ class SQLiteDBTable:
                 else:
                     setattr(obj, field, str(row[i])
                             if row[i] is not None else None)
-            elif cls._types[i] == list:
+            elif cls._types[i] is list:
                 try:
                     setattr(obj, field, json.loads(row[i]) if row[i] else [])
                 except json.JSONDecodeError:
                     setattr(obj, field, [])
-            elif cls._types[i] == int:
+            elif cls._types[i] is int:
                 setattr(obj, field, int(row[i])
                         if row[i] is not None else None)
-            elif cls._types[i] == float:
+            elif cls._types[i] is float:
                 setattr(obj, field, float(row[i])
                         if row[i] is not None else None)
-            elif cls._types[i] == bool:
+            elif cls._types[i] is bool:
                 setattr(obj, field, bool(row[i])
                         if row[i] is not None else None)
-            elif cls._types[i] == dict:
+            elif cls._types[i] is dict:
                 try:
                     setattr(obj, field, json.loads(row[i]) if row[i] else {})
                 except json.JSONDecodeError:
@@ -212,7 +219,7 @@ class SQLiteDBTable:
     def add(self, retry=1):
         try:
             pk_val = getattr(self, self._pk, None)
-            if cls._auto_increment:
+            if self._auto_increment:
                 self.save()
             elif pk_val is None:
                 raise ValueError(
@@ -378,9 +385,9 @@ class AIModelsTable(SQLiteDBTable):
 class GameLinesTable(SQLiteDBTable):
     _table = 'game_lines'
     _fields = ['game_name', 'line_text', 'screenshot_in_anki',
-               'audio_in_anki', 'screenshot_path', 'audio_path', 'replay_path', 'translation', 'timestamp']
+               'audio_in_anki', 'screenshot_path', 'audio_path', 'replay_path', 'translation', 'timestamp', 'original_game_name']
     _types = [str,  # Includes primary key type
-              str, str, str, str, str, str, str, str, float]
+              str, str, str, str, str, str, str, str, float, str]
     _pk = 'id'
     _auto_increment = False  # Use string IDs
 
@@ -394,7 +401,8 @@ class GameLinesTable(SQLiteDBTable):
                  screenshot_path: Optional[str] = None,
                  audio_path: Optional[str] = None,
                  replay_path: Optional[str] = None,
-                 translation: Optional[str] = None):
+                 translation: Optional[str] = None,
+                 original_game_name: Optional[str] = None):
         self.id = id
         self.game_name = game_name
         self.line_text = line_text
@@ -406,6 +414,7 @@ class GameLinesTable(SQLiteDBTable):
         self.audio_path = audio_path if audio_path is not None else ''
         self.replay_path = replay_path if replay_path is not None else ''
         self.translation = translation if translation is not None else ''
+        self.original_game_name = original_game_name if original_game_name is not None else ''
 
     @classmethod
     def get_all_lines_for_scene(cls, game_name: str) -> List['GameLinesTable']:

GameSentenceMiner/util/downloader/download_tools.py

@@ -7,8 +7,8 @@ import platform
 import zipfile
 
 from GameSentenceMiner.util.downloader.Untitled_json import scenes
-from GameSentenceMiner.util.configuration import get_app_directory, logger
-from GameSentenceMiner.util.ffmpeg import get_ffmpeg_path, get_ffprobe_path
+from GameSentenceMiner.util.configuration import get_app_directory, get_ffmpeg_path, logger
+from GameSentenceMiner.util.configuration import get_ffprobe_path
 from GameSentenceMiner.obs import get_obs_path
 import tempfile