GameSentenceMiner 2.0.0__py3-none-any.whl

GameSentenceMiner/configuration.py

@@ -0,0 +1,359 @@
+import json
+import logging
+import os
+import shutil
+from dataclasses import dataclass, field
+from logging.handlers import RotatingFileHandler
+from os.path import expanduser
+from typing import List, Dict
+
+import toml
+from dataclasses_json import dataclass_json
+
+
+OFF = 'OFF'
+VOSK = 'VOSK'
+SILERO = 'SILERO'
+WHISPER = 'WHISPER'
+
+VOSK_BASE = 'BASE'
+VOSK_SMALL = 'SMALL'
+
+WHISPER_TINY = 'tiny'
+WHISPER_BASE = 'base'
+WHISPER_SMALL = 'small'
+WHISPER_MEDIUM = 'medium'
+WHSIPER_LARGE = 'large'
+
+INFO = 'INFO'
+DEBUG = 'DEBUG'
+
+DEFAULT_CONFIG = 'Default'
+
+current_game = ''
+
+
+@dataclass_json
+@dataclass
+class General:
+    use_websocket: bool = True
+    websocket_uri: str = 'localhost:6677'
+    open_config_on_startup: bool = False
+
+
+@dataclass_json
+@dataclass
+class Paths:
+    folder_to_watch: str = expanduser("~/Videos/OBS")
+    audio_destination: str = expanduser("~/Videos/OBS/Audio/")
+    screenshot_destination: str = expanduser("~/Videos/OBS/SS/")
+    remove_video: bool = True
+    remove_audio: bool = False
+    remove_screenshot: bool = False
+
+
+@dataclass_json
+@dataclass
+class Anki:
+    update_anki: bool = True
+    url: str = 'http://127.0.0.1:8765'
+    sentence_field: str = "Sentence"
+    sentence_audio_field: str = "SentenceAudio"
+    picture_field: str = "Picture"
+    word_field: str = 'Word'
+    previous_sentence_field: str = ''
+    custom_tags: List[str] = None  # Initialize to None and set it in __post_init__
+    tags_to_check: List[str] = None
+    add_game_tag: bool = True
+    polling_rate: int = 200
+    overwrite_audio: bool = False
+    overwrite_picture: bool = True
+    anki_custom_fields: Dict[str, str] = None  # Initialize to None and set it in __post_init__
+
+    def __post_init__(self):
+        if self.custom_tags is None:
+            self.custom_tags = []
+        if self.anki_custom_fields is None:
+            self.anki_custom_fields = {}
+        if self.tags_to_check is None:
+            self.tags_to_check = []
+
+
+@dataclass_json
+@dataclass
+class Features:
+    full_auto: bool = True
+    notify_on_update: bool = True
+    open_anki_edit: bool = False
+    backfill_audio: bool = False
+
+
+@dataclass_json
+@dataclass
+class Screenshot:
+    width: str = 0
+    height: str = 0
+    quality: str = 85
+    extension: str = "webp"
+    custom_ffmpeg_settings: str = ''
+    screenshot_hotkey_updates_anki: bool = False
+    seconds_after_line: int = 1
+
+
+@dataclass_json
+@dataclass
+class Audio:
+    extension: str = 'opus'
+    beginning_offset: float = 0.0
+    end_offset: float = 0.5
+    ffmpeg_reencode_options: str = ''
+    external_tool: str = ""
+    anki_media_collection: str = ""
+
+
+@dataclass_json
+@dataclass
+class OBS:
+    enabled: bool = True
+    host: str = "localhost"
+    port: int = 4455
+    password: str = "your_password"
+    start_buffer: bool = True
+    get_game_from_scene: bool = True
+    minimum_replay_size: int = 0
+
+
+@dataclass_json
+@dataclass
+class Hotkeys:
+    reset_line: str = 'f5'
+    take_screenshot: str = 'f6'
+
+
+@dataclass_json
+@dataclass
+class VAD:
+    whisper_model: str = WHISPER_BASE
+    do_vad_postprocessing: bool = True
+    vosk_url: str = VOSK_BASE
+    selected_vad_model: str = SILERO
+    backup_vad_model: str = OFF
+    trim_beginning: bool = False
+
+
+@dataclass_json
+@dataclass
+class ProfileConfig:
+    name: str = 'Default'
+    general: General = field(default_factory=General)
+    paths: Paths = field(default_factory=Paths)
+    anki: Anki = field(default_factory=Anki)
+    features: Features = field(default_factory=Features)
+    screenshot: Screenshot = field(default_factory=Screenshot)
+    audio: Audio = field(default_factory=Audio)
+    obs: OBS = field(default_factory=OBS)
+    hotkeys: Hotkeys = field(default_factory=Hotkeys)
+    vad: VAD = field(default_factory=VAD)
+
+
+    # This is just for legacy support
+    def load_from_toml(self, file_path: str):
+        with open(file_path, 'r') as f:
+            config_data = toml.load(f)
+
+        self.paths.folder_to_watch = expanduser(config_data['paths'].get('folder_to_watch', self.paths.folder_to_watch))
+        self.paths.audio_destination = expanduser(
+            config_data['paths'].get('audio_destination', self.paths.audio_destination))
+        self.paths.screenshot_destination = expanduser(config_data['paths'].get('screenshot_destination',
+                                                                                self.paths.screenshot_destination))
+
+        self.anki.url = config_data['anki'].get('url', self.anki.url)
+        self.anki.sentence_field = config_data['anki'].get('sentence_field', self.anki.sentence_field)
+        self.anki.sentence_audio_field = config_data['anki'].get('sentence_audio_field', self.anki.sentence_audio_field)
+        self.anki.word_field = config_data['anki'].get('word_field', self.anki.word_field)
+        self.anki.picture_field = config_data['anki'].get('picture_field', self.anki.picture_field)
+        self.anki.custom_tags = config_data['anki'].get('custom_tags', self.anki.custom_tags)
+        self.anki.add_game_tag = config_data['anki'].get('add_game_tag', self.anki.add_game_tag)
+        self.anki.polling_rate = config_data['anki'].get('polling_rate', self.anki.polling_rate)
+        self.anki.overwrite_audio = config_data['anki_overwrites'].get('overwrite_audio', self.anki.overwrite_audio)
+        self.anki.overwrite_picture = config_data['anki_overwrites'].get('overwrite_picture',
+                                                                         self.anki.overwrite_picture)
+
+        self.features.full_auto = config_data['features'].get('do_vosk_postprocessing', self.features.full_auto)
+        self.features.notify_on_update = config_data['features'].get('notify_on_update', self.features.notify_on_update)
+        self.features.open_anki_edit = config_data['features'].get('open_anki_edit', self.features.open_anki_edit)
+        self.features.backfill_audio = config_data['features'].get('backfill_audio', self.features.backfill_audio)
+
+        self.screenshot.width = config_data['screenshot'].get('width', self.screenshot.width)
+        self.screenshot.height = config_data['screenshot'].get('height', self.screenshot.height)
+        self.screenshot.quality = config_data['screenshot'].get('quality', self.screenshot.quality)
+        self.screenshot.extension = config_data['screenshot'].get('extension', self.screenshot.extension)
+        self.screenshot.custom_ffmpeg_settings = config_data['screenshot'].get('custom_ffmpeg_settings',
+                                                                               self.screenshot.custom_ffmpeg_settings)
+
+        self.audio.extension = config_data['audio'].get('extension', self.audio.extension)
+        self.audio.beginning_offset = config_data['audio'].get('beginning_offset', self.audio.beginning_offset)
+        self.audio.end_offset = config_data['audio'].get('end_offset', self.audio.end_offset)
+        self.audio.ffmpeg_reencode_options = config_data['audio'].get('ffmpeg_reencode_options',
+                                                                      self.audio.ffmpeg_reencode_options)
+
+        self.vad.whisper_model = config_data['vosk'].get('whisper_model', self.vad.whisper_model)
+        self.vad.vosk_url = config_data['vosk'].get('url', self.vad.vosk_url)
+        self.vad.do_vad_postprocessing = config_data['features'].get('do_vosk_postprocessing',
+                                                                     self.vad.do_vad_postprocessing)
+        self.vad.trim_beginning = config_data['audio'].get('vosk_trim_beginning', self.vad.trim_beginning)
+
+        self.obs.enabled = config_data['obs'].get('enabled', self.obs.enabled)
+        self.obs.host = config_data['obs'].get('host', self.obs.host)
+        self.obs.port = config_data['obs'].get('port', self.obs.port)
+        self.obs.password = config_data['obs'].get('password', self.obs.password)
+
+        self.general.use_websocket = config_data['websocket'].get('enabled', self.general.use_websocket)
+        self.general.websocket_uri = config_data['websocket'].get('uri', self.general.websocket_uri)
+
+        self.hotkeys.reset_line = config_data['hotkeys'].get('reset_line', self.hotkeys.reset_line)
+        self.hotkeys.take_screenshot = config_data['hotkeys'].get('take_screenshot', self.hotkeys.take_screenshot)
+
+        self.anki.anki_custom_fields = config_data.get('anki_custom_fields', {})
+
+        with open('config.json', 'w') as f:
+            f.write(self.to_json(indent=4))
+            print(
+                'config.json successfully generated from previous settings. config.toml will no longer be used.')
+
+        return self
+
+@dataclass_json
+@dataclass
+class Config:
+    configs: Dict[str, ProfileConfig] = field(default_factory=dict)
+    current_profile: str = DEFAULT_CONFIG
+
+    @classmethod
+    def new(cls):
+        instance = cls(configs={DEFAULT_CONFIG: ProfileConfig()}, current_profile=DEFAULT_CONFIG)
+        return instance
+
+    def get_config(self) -> ProfileConfig:
+        return self.configs[self.current_profile]
+
+    def set_config_for_profile(self, profile: str, config: ProfileConfig):
+        config.name = profile
+        self.configs[profile] = config
+
+    def has_config_for_current_game(self):
+        return current_game in self.configs
+
+    def get_all_profile_names(self):
+        return list(self.configs.keys())
+
+
+logger = logging.getLogger("GameSentenceMiner")
+logger.setLevel(logging.DEBUG)  # Set the base level to DEBUG so that all messages are captured
+
+# Create console handler with level INFO
+console_handler = logging.StreamHandler()
+console_handler.setLevel(logging.INFO)
+
+# Create rotating file handler with level DEBUG
+file_handler = RotatingFileHandler("gamesentenceminer.log", maxBytes=10_000_000, backupCount=2, encoding='utf-8')
+file_handler.setLevel(logging.DEBUG)
+
+# Create a formatter
+formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+
+# Add formatter to handlers
+console_handler.setFormatter(formatter)
+file_handler.setFormatter(formatter)
+
+# Add handlers to the logger
+logger.addHandler(console_handler)
+logger.addHandler(file_handler)
+
+CONFIG_FILE = os.path.join(os.path.dirname(__file__), 'get_config().json')
+temp_directory = ''
+
+def get_app_directory():
+    appdata_dir = os.getenv('APPDATA')  # Get the AppData directory
+    config_dir = os.path.join(appdata_dir, 'GameSentenceMiner')
+    os.makedirs(config_dir, exist_ok=True)  # Create the directory if it doesn't exist
+    return config_dir
+
+def get_config_path():
+    return os.path.join(get_app_directory(), 'config.json')
+
+
+def load_config():
+    config_path = get_config_path()
+
+    if os.path.exists('config.json') and not os.path.exists(config_path):
+        shutil.copy('config.json', config_path)
+
+    if os.path.exists(config_path):
+        try:
+            with open(config_path, 'r') as file:
+                config_file = json.load(file)
+                if "current_profile" in config_file:
+                    return Config.from_dict(config_file)
+                else:
+                    print(f"Loading Profile-less Config, Converting to new Config!")
+                    with open(config_path, 'r') as file:
+                        config_file = json.load(file)
+
+                    config = ProfileConfig.from_dict(config_file)
+                    new_config = Config(configs = {DEFAULT_CONFIG : config}, current_profile=DEFAULT_CONFIG)
+
+                    print(new_config)
+
+                    with open(config_path, 'w') as file:
+                        json.dump(new_config.to_dict(), file, indent=4)
+                    return new_config
+        except json.JSONDecodeError as e:
+            print(f"Error parsing config.json: {e}")
+            return None
+    elif os.path.exists('config.toml'):
+        config = ProfileConfig().load_from_toml('config.toml')
+        new_config = Config({DEFAULT_CONFIG: config}, current_profile=DEFAULT_CONFIG)
+        return new_config
+    else:
+        config = Config.new()
+        with open(config_path, 'w') as file:
+            json.dump(config.to_dict(), file, indent=4)
+        return config
+
+
+config_instance: Config = None
+
+
+def get_config():
+    global config_instance
+    if config_instance is None:
+        config_instance = load_config()
+        config = config_instance.get_config()
+
+        if config.features.backfill_audio and config.features.full_auto:
+            print("Cannot have backfill_audio and obs_full_auto_mode turned on at the same time!")
+            exit(1)
+
+    # print(config_instance.get_config())
+    return config_instance.get_config()
+
+
+def reload_config():
+    global config_instance
+    config_instance = load_config()
+    config = config_instance.get_config()
+
+    if config.features.backfill_audio and config.features.full_auto:
+        print("Cannot have backfill_audio and obs_full_auto_mode turned on at the same time!")
+        exit(1)
+
+def get_master_config():
+    return config_instance
+
+def switch_profile_and_save(profile_name):
+    global config_instance
+    config_instance.current_profile = profile_name
+    with open('config.json', 'w') as file:
+        json.dump(config_instance.to_dict(), file, indent=4)
+    return config_instance.get_config()

GameSentenceMiner/ffmpeg.py

@@ -0,0 +1,297 @@
+import tempfile
+import time
+
+from . import obs
+from . import util
+from . import configuration
+from .configuration import *
+from .util import *
+
+ffmpeg_base_command_list = ["ffmpeg", "-hide_banner", "-loglevel", "error", '-nostdin']
+
+
+def get_screenshot(video_file, time_from_end):
+    time_from_end_to_capture = -time_from_end if time_from_end else -1
+    output_image = make_unique_file_name(
+        get_config().paths.screenshot_destination + obs.get_current_game(sanitize=True) + f".{get_config().screenshot.extension}")
+    # FFmpeg command to extract the last frame of the video
+    ffmpeg_command = ffmpeg_base_command_list + [
+        "-sseof", f"{time_from_end_to_capture}",  # Seek to 1 second before the end of the video
+        "-i", f"{video_file}",
+        "-vframes", "1"  # Extract only one frame
+    ]
+
+    if get_config().screenshot.custom_ffmpeg_settings:
+        ffmpeg_command.extend(get_config().screenshot.custom_ffmpeg_settings.replace("\"", "").split(" "))
+    else:
+        ffmpeg_command.extend(["-compression_level", "6", "-q:v", get_config().screenshot.quality])
+
+    if get_config().screenshot.width or get_config().screenshot.height:
+        ffmpeg_command.extend(
+            ["-vf", f"scale={get_config().screenshot.width or -1}:{get_config().screenshot.height or -1}"])
+
+    ffmpeg_command.append(f"{output_image}")
+
+    logger.debug(f"FFMPEG SS Command: {ffmpeg_command}")
+
+    # Run the command
+    subprocess.run(ffmpeg_command)
+
+    logger.info(f"Screenshot saved to: {output_image}")
+
+    return output_image
+
+
+def get_screenshot_time(video_path, line_time):
+    file_length = get_video_duration(video_path)
+    file_mod_time = get_file_modification_time(video_path)
+
+    time_delta = file_mod_time - line_time
+    total_seconds = file_length - time_delta.total_seconds()
+
+    time_from_end = file_length - total_seconds - get_config().screenshot.seconds_after_line
+
+    if time_from_end < 0 or time_from_end > (file_length - total_seconds):
+        raise ValueError("Calculated screenshot time is out of bounds for trimmed video.")
+
+    return time_from_end
+
+
+def process_image(image_file):
+    output_image = make_unique_file_name(
+        get_config().paths.screenshot_destination + obs.get_current_game(sanitize=True) + f".{get_config().screenshot.extension}")
+
+    # FFmpeg command to process the input image
+    ffmpeg_command = ffmpeg_base_command_list + [
+        "-i", image_file
+    ]
+
+    if get_config().screenshot.custom_ffmpeg_settings:
+        ffmpeg_command.extend(get_config().screenshot.custom_ffmpeg_settings.split(" "))
+    else:
+        ffmpeg_command.extend(["-compression_level", "6", "-q:v", get_config().screenshot.quality])
+
+    if get_config().screenshot.width or get_config().screenshot.height:
+        ffmpeg_command.extend(
+            ["-vf", f"scale={get_config().screenshot.width or -1}:{get_config().screenshot.height or -1}"])
+
+    ffmpeg_command.append(output_image)
+    logger.debug(ffmpeg_command)
+    logger.debug(" ".join(ffmpeg_command))
+    # Run the command
+    subprocess.run(ffmpeg_command)
+
+    logger.info(f"Processed image saved to: {output_image}")
+
+    return output_image
+
+
+def get_audio_codec(video_path):
+    command = [
+        "ffprobe",
+        "-v", "error",
+        "-select_streams", "a:0",
+        "-show_entries", "stream=codec_name",
+        "-of", "json",
+        video_path
+    ]
+
+    logger.debug(" ".join(command))
+    # Run the command and capture the output
+    result = subprocess.run(command, capture_output=True, text=True)
+
+    # Parse the JSON output
+    try:
+        output = json.loads(result.stdout)
+        codec_name = output['streams'][0]['codec_name']
+        return codec_name
+    except (json.JSONDecodeError, KeyError, IndexError):
+        logger.error("Failed to get codec information. Re-encoding Anyways")
+        return None
+
+
+def get_audio_and_trim(video_path, line_time, next_line_time):
+    supported_formats = {
+        'opus': 'opus',
+        'mp3': 'libmp3lame',
+        'ogg': 'libvorbis',
+        'aac': 'aac',
+        'm4a': 'aac',
+    }
+
+    codec = get_audio_codec(video_path)
+
+    if codec == get_config().audio.extension:
+        codec_command = ['-c:a', 'copy']
+        logger.info(f"Extracting {get_config().audio.extension} from video")
+    else:
+        codec_command = ["-c:a", f"{supported_formats[get_config().audio.extension]}"]
+        logger.info(f"Re-encoding {codec} to {get_config().audio.extension}")
+
+    untrimmed_audio = tempfile.NamedTemporaryFile(dir=configuration.temp_directory,
+                                                  suffix=f"_untrimmed.{get_config().audio.extension}").name
+
+    command = ffmpeg_base_command_list + [
+        "-i", video_path,
+        "-map", "0:a"] + codec_command + [
+                  untrimmed_audio
+              ]
+
+    # FFmpeg command to extract OR re-encode the audio
+    # command = f"{ffmpeg_base_command} -i \"{video_path}\" -map 0:a {codec_command} \"{untrimmed_audio}\""
+
+    logger.debug(" ".join(command))
+
+    subprocess.run(command)
+
+    return trim_audio_based_on_last_line(untrimmed_audio, video_path, line_time, next_line_time)
+
+
+def get_video_duration(file_path):
+    ffprobe_command = [
+        "ffprobe",
+        "-v", "error",
+        "-show_entries", "format=duration",
+        "-of", "json",
+        file_path
+    ]
+    result = subprocess.run(ffprobe_command, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+    duration_info = json.loads(result.stdout)
+    return float(duration_info["format"]["duration"])  # Return the duration in seconds
+
+
+def trim_audio_based_on_last_line(untrimmed_audio, video_path, line_time, next_line):
+    trimmed_audio = tempfile.NamedTemporaryFile(dir=configuration.temp_directory,
+                                                suffix=f".{get_config().audio.extension}").name
+    file_mod_time = get_file_modification_time(video_path)
+    file_length = get_video_duration(video_path)
+    time_delta = file_mod_time - line_time
+    # Convert time_delta to FFmpeg-friendly format (HH:MM:SS.milliseconds)
+    total_seconds = file_length - time_delta.total_seconds() + get_config().audio.beginning_offset
+    if total_seconds < 0 or total_seconds >= file_length:
+        logger.info(f"0 seconds trimmed off of beginning")
+        return untrimmed_audio
+
+    hours, remainder = divmod(total_seconds, 3600)
+    minutes, seconds = divmod(remainder, 60)
+    start_trim_time = "{:02}:{:02}:{:06.3f}".format(int(hours), int(minutes), seconds)
+
+    ffmpeg_command = ffmpeg_base_command_list + [
+        "-i", untrimmed_audio,
+        "-ss", start_trim_time]
+    if next_line and next_line > line_time:
+        end_total_seconds = total_seconds + (next_line - line_time).total_seconds() + 1
+        hours, remainder = divmod(end_total_seconds, 3600)
+        minutes, seconds = divmod(remainder, 60)
+        end_trim_time = "{:02}:{:02}:{:06.3f}".format(int(hours), int(minutes), seconds)
+        ffmpeg_command.extend(['-to', end_trim_time])
+        logger.info(
+            f"Looks like Clipboard/Websocket was modified before the script knew about the anki card! Trimming end of video to {end_trim_time}")
+
+    ffmpeg_command.extend([
+        "-c", "copy",  # Using copy to avoid re-encoding, adjust if needed
+        trimmed_audio
+    ])
+
+    logger.debug(" ".join(ffmpeg_command))
+    subprocess.run(ffmpeg_command)
+
+    logger.info(f"{total_seconds} trimmed off of beginning")
+
+    logger.info(f"Audio trimmed and saved to {trimmed_audio}")
+    return trimmed_audio
+
+
+def reencode_file_with_user_config(input_file, final_output_audio, user_ffmpeg_options):
+    logger.info(f"Re-encode running with settings:  {user_ffmpeg_options}")
+    temp_file = create_temp_file_with_same_name(input_file)
+    command = ffmpeg_base_command_list + [
+        "-i", input_file,
+        "-map", "0:a"
+    ] + user_ffmpeg_options.replace("\"", "").split(" ") + [
+                  temp_file
+              ]
+
+    logger.debug(" ".join(command))
+    process = subprocess.run(command)
+
+    if process.returncode != 0:
+        logger.error("Re-encode failed, using original audio")
+        return
+
+    replace_file_with_retry(temp_file, final_output_audio)
+
+
+def create_temp_file_with_same_name(input_file: str):
+    split = input_file.split(".")
+    return f"{split[0]}_temp.{split[1]}"
+
+
+def replace_file_with_retry(temp_file, input_file, retries=5, delay=1):
+    for attempt in range(retries):
+        try:
+            os.replace(temp_file, input_file)
+            logger.info(f'Re-encode Finished!')
+            return
+        except OSError as e:
+            if attempt < retries - 1:
+                logger.warning(f"Attempt {attempt + 1}: File still in use. Retrying in {delay} seconds...")
+                time.sleep(delay)
+            else:
+                logger.error(f"Failed to replace the file after {retries} attempts. Error: {e}")
+                raise
+
+
+def trim_audio_by_end_time(input_audio, end_time, output_audio):
+    command = ffmpeg_base_command_list + [
+        "-i", input_audio,
+        "-to", str(end_time),
+        "-c", "copy",
+        output_audio
+    ]
+    logger.debug(" ".join(command))
+    subprocess.run(command)
+
+
+def convert_audio_to_wav(input_audio, output_wav):
+    command = ffmpeg_base_command_list + [
+        "-i", input_audio,
+        "-ar", "16000",
+        "-ac", "1",
+        "-af", "afftdn,dialoguenhance" if not util.is_linux() else "afftdn",
+        output_wav
+    ]
+    logger.debug(" ".join(command))
+    subprocess.run(command)
+
+
+# Trim the audio using FFmpeg based on detected speech timestamps
+def trim_audio(input_audio, start_time, end_time, output_audio):
+    command = ffmpeg_base_command_list.copy()
+
+    if get_config().vad.trim_beginning and start_time > 0:
+        command.extend(['-ss', f"{start_time:.2f}"])
+
+    command.extend([
+        '-to', f"{end_time:.2f}",
+        '-i', input_audio,
+        '-c', 'copy',
+        output_audio
+    ])
+
+    logger.debug(" ".join(command))
+
+    subprocess.run(command)
+
+
+def is_video_big_enough(file_path, min_size_kb=250):
+    try:
+        file_size = os.path.getsize(file_path)  # Size in bytes
+        file_size_kb = file_size / 1024  # Convert to KB
+        return file_size_kb >= min_size_kb
+    except FileNotFoundError:
+        logger.error("File not found!")
+        return False
+    except Exception as e:
+        logger.error(f"Error: {e}")
+        return False