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

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
 

GameSentenceMiner/util/ffmpeg.py

@@ -5,23 +5,20 @@ import sys
 import tempfile
 import time
 from pathlib import Path
+import subprocess
+from pathlib import Path
+import shutil
+
 
 from GameSentenceMiner import obs
-from GameSentenceMiner.util.configuration import get_app_directory, is_windows, logger, get_config, \
+from GameSentenceMiner.ui.config_gui import ConfigApp
+from GameSentenceMiner.util.configuration import ffmpeg_base_command_list, get_ffprobe_path, logger, get_config, \
     get_temporary_directory, gsm_state, is_linux
 from GameSentenceMiner.util.gsm_utils import make_unique_file_name, get_file_modification_time
 from GameSentenceMiner.util import configuration
 from GameSentenceMiner.util.text_log import initial_time
 
 
-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']
-
 supported_formats = {
     'opus': 'libopus',
     'mp3': 'libmp3lame',
@@ -30,11 +27,6 @@ supported_formats = {
     'm4a': 'aac',
 }
 
-import subprocess
-from pathlib import Path
-import shutil
-
-
 def video_to_anim(
     input_path: str | Path,
     output_path: str | Path = None,
@@ -184,22 +176,24 @@ def call_frame_extractor(video_path, timestamp):
         str: The path of the selected image, or None on error.
     """
     try:
-        logger.info(' '.join([sys.executable, "-m", "GameSentenceMiner.tools.ss_selector", video_path, str(timestamp)]))
-
-        # Run the script using subprocess.run()
-        result = subprocess.run(
-            [sys.executable, "-m", "GameSentenceMiner.tools.ss_selector", video_path, str(timestamp), get_config().screenshot.screenshot_timing_setting],  # Use sys.executable
-            capture_output=True,
-            text=True,  # Get output as text
-            check=False  # Raise an exception for non-zero exit codes
-        )
-        if result.returncode != 0:
-            logger.error(f"Script failed with return code: {result.returncode}")
-            return None
-        logger.info(result)
-        # Print the standard output
-        logger.info(f"Frame extractor script output: {result.stdout.strip()}")
-        return result.stdout.strip() # Return the output
+        config_app: ConfigApp = gsm_state.config_app
+        return config_app.show_screenshot_selector(video_path, timestamp, get_config().screenshot.screenshot_timing_setting)
+        # logger.info(' '.join([sys.executable, "-m", "GameSentenceMiner.tools.ss_selector", video_path, str(timestamp)]))
+
+        # # Run the script using subprocess.run()
+        # result = subprocess.run(
+        #     [sys.executable, "-m", "GameSentenceMiner.tools.ss_selector", video_path, str(timestamp), get_config().screenshot.screenshot_timing_setting],  # Use sys.executable
+        #     capture_output=True,
+        #     text=True,  # Get output as text
+        #     check=False  # Raise an exception for non-zero exit codes
+        # )
+        # if result.returncode != 0:
+        #     logger.error(f"Script failed with return code: {result.returncode}")
+        #     return None
+        # logger.info(result)
+        # # Print the standard output
+        # logger.info(f"Frame extractor script output: {result.stdout.strip()}")
+        # return result.stdout.strip() # Return the output
 
     except subprocess.CalledProcessError as e:
         logger.error(f"Error calling script: {e}")

GameSentenceMiner/util/get_overlay_coords.py

@@ -190,37 +190,38 @@ class OverlayProcessor:
         """
         with mss.mss() as sct:
             monitors = sct.monitors[1:]
-            if is_windows() and monitor_index == 0:
-                from ctypes import wintypes
-                import ctypes
-                # Get work area for primary monitor (ignores taskbar)
-                SPI_GETWORKAREA = 0x0030
-                rect = wintypes.RECT()
-                res = ctypes.windll.user32.SystemParametersInfoW(
-                    SPI_GETWORKAREA, 0, ctypes.byref(rect), 0
-                )
-                if not res:
-                    raise ctypes.WinError()
+            return monitors[monitor_index] if 0 <= monitor_index < len(monitors) else monitors[0]
+            # if is_windows() and monitor_index == 0:
+            #     from ctypes import wintypes
+            #     import ctypes
+            #     # Get work area for primary monitor (ignores taskbar)
+            #     SPI_GETWORKAREA = 0x0030
+            #     rect = wintypes.RECT()
+            #     res = ctypes.windll.user32.SystemParametersInfoW(
+            #         SPI_GETWORKAREA, 0, ctypes.byref(rect), 0
+            #     )
+            #     if not res:
+            #         raise ctypes.WinError()
                 
-                return {
-                    "left": rect.left,
-                    "top": rect.top,
-                    "width": rect.right - rect.left,
-                    "height": rect.bottom - rect.top,
-                }
-            elif is_windows() and monitor_index > 0:
-                # Secondary monitors: just return with a guess of how tall the taskbar is
-                taskbar_height_guess = 48  # A common taskbar height, may vary
-                mon = monitors[monitor_index]
-                return {
-                    "left": mon["left"],
-                    "top": mon["top"],
-                    "width": mon["width"],
-                    "height": mon["height"] - taskbar_height_guess
-                }
-            else:
-                # For non-Windows systems or unspecified monitors, return the monitor area as-is
-                return monitors[monitor_index] if 0 <= monitor_index < len(monitors) else monitors[0]
+            #     return {
+            #         "left": rect.left,
+            #         "top": rect.top,
+            #         "width": rect.right - rect.left,
+            #         "height": rect.bottom - rect.top,
+            #     }
+            # elif is_windows() and monitor_index > 0:
+            #     # Secondary monitors: just return with a guess of how tall the taskbar is
+            #     taskbar_height_guess = 48  # A common taskbar height, may vary
+            #     mon = monitors[monitor_index]
+            #     return {
+            #         "left": mon["left"],
+            #         "top": mon["top"],
+            #         "width": mon["width"],
+            #         "height": mon["height"] - taskbar_height_guess
+            #     }
+            # else:
+            #     # For non-Windows systems or unspecified monitors, return the monitor area as-is
+            #     return monitors[monitor_index] if 0 <= monitor_index < len(monitors) else monitors[0]
 
 
     def _get_full_screenshot(self) -> Tuple[Image.Image | None, int, int]:
@@ -309,11 +310,9 @@ class OverlayProcessor:
                 
                 score = fuzz.ratio(text_str, self.last_oneocr_result)
                 if score >= 80:
-                    logger.info("OneOCR results are similar to the last results (score: %d). Skipping overlay update.", score)
                     return
             self.last_oneocr_result = text_str
 
-            logger.info("Sending OneOCR results to overlay.")
             await send_word_coordinates_to_overlay(self._convert_oneocr_results_to_percentages(oneocr_results, monitor_width, monitor_height))
             
             # If User Home is beangate
@@ -322,7 +321,7 @@ class OverlayProcessor:
                     f.write(json.dumps(oneocr_results, ensure_ascii=False, indent=2))
             
             if get_config().overlay.engine == OverlayEngine.ONEOCR.value and self.oneocr:
-                logger.info("Using OneOCR results for overlay as configured.")
+                logger.info("Sent %d text boxes to overlay.", len(oneocr_results))
                 return
 
             # 3. Create a composite image with only the detected text regions
@@ -371,8 +370,9 @@ class OverlayProcessor:
             crop_height=composite_image.height,
             use_percentages=True
         )
-        logger.info("Sending Google Lens results to overlay.")
         await send_word_coordinates_to_overlay(extracted_data)
+        
+        logger.info("Sent %d text boxes to overlay.", len(extracted_data))
 
     def _extract_text_with_pixel_boxes(
         self,

GameSentenceMiner/util/gsm_utils.py

@@ -13,7 +13,7 @@ from pathlib import Path
 import requests
 from rapidfuzz import process
 
-from GameSentenceMiner.util.configuration import logger, get_config, get_app_directory
+from GameSentenceMiner.util.configuration import gsm_state, logger, get_config, get_app_directory, get_temporary_directory
 
 SCRIPTS_DIR = r"E:\Japanese Stuff\agent-v0.1.4-win32-x64\data\scripts"
 
@@ -22,6 +22,13 @@ def run_new_thread(func):
     thread.start()
     return thread
 
+def make_unique_temp_file(path):
+    path = Path(path)
+    current_time = datetime.now().strftime('%Y-%m-%d-%H-%M-%S-%f')[:-3]
+    temp_dir = get_temporary_directory()
+    os.makedirs(temp_dir, exist_ok=True)
+    return str(Path(temp_dir) / f"{path.stem}_{current_time}{path.suffix}")
+
 def make_unique_file_name(path):
     path = Path(path)
     current_time = datetime.now().strftime('%Y-%m-%d-%H-%M-%S-%f')[:-3]
@@ -258,6 +265,29 @@ TEXT_REPLACEMENTS_FILE = os.path.join(get_app_directory(), 'config', 'text_repla
 OCR_REPLACEMENTS_FILE = os.path.join(get_app_directory(), 'config', 'ocr_replacements.json')
 os.makedirs(os.path.dirname(TEXT_REPLACEMENTS_FILE), exist_ok=True)
 
+
+def add_srt_line(line_time, new_line):
+    global srt_index
+    if get_config().features.generate_longplay and gsm_state.recording_started_time and new_line.prev:
+        logger.info(f"Adding SRT line {new_line.prev.text}... for longplay")
+        with open(gsm_state.current_srt, 'a', encoding='utf-8') as srt_file:
+            # Calculate start and end times for the previous line
+            prev_start_time = new_line.prev.time - gsm_state.recording_started_time
+            prev_end_time = (line_time if line_time else datetime.now()) - gsm_state.recording_started_time
+            # Format times as SRT timestamps (HH:MM:SS,mmm)
+            def format_srt_time(td, offset=0):
+                total_seconds = int(td.total_seconds()) + offset
+                hours = total_seconds // 3600
+                minutes = (total_seconds % 3600) // 60
+                seconds = total_seconds % 60
+                milliseconds = int(td.microseconds / 1000)
+                return f"{hours:02}:{minutes:02}:{seconds:02},{milliseconds:03}"
+            
+            srt_file.write(f"{gsm_state.srt_index}\n")
+            srt_file.write(f"{format_srt_time(prev_start_time)} --> {format_srt_time(prev_end_time, offset=-1)}\n")
+            srt_file.write(f"{new_line.prev.text}\n\n")
+            gsm_state.srt_index += 1
+
 # if not os.path.exists(OCR_REPLACEMENTS_FILE):
 #     url = "https://raw.githubusercontent.com/bpwhelan/GameSentenceMiner/refs/heads/main/electron-src/assets/ocr_replacements.json"
 #     try: