GameSentenceMiner 2.9.3__py3-none-any.whl → 2.9.5__py3-none-any.whl

GameSentenceMiner/util.py

@@ -1,262 +0,0 @@
-import json
-import os
-import random
-import re
-import string
-import subprocess
-import threading
-import time
-from datetime import datetime
-
-from rapidfuzz import process
-
-from GameSentenceMiner.configuration import logger, get_config, get_app_directory
-
-SCRIPTS_DIR = r"E:\Japanese Stuff\agent-v0.1.4-win32-x64\data\scripts"
-
-# Global variables to control script execution
-keep_running = True
-lock = threading.Lock()
-last_mined_line = None
-
-def get_last_mined_line():
-    return last_mined_line
-
-def set_last_mined_line(line):
-    global last_mined_line
-    last_mined_line = line
-
-def run_new_thread(func):
-    thread = threading.Thread(target=func, daemon=True)
-    thread.start()
-    return thread
-
-
-def make_unique_file_name(path):
-    split = path.rsplit('.', 1)
-    filename = split[0]
-    extension = split[1]
-
-    current_time = datetime.now().strftime('%Y-%m-%d-%H-%M-%S-%f')[:-3]
-
-    return f"{filename}_{current_time}.{extension}"
-
-def sanitize_filename(filename):
-        return re.sub(r'[ <>:"/\\|?*\x00-\x1F]', '', filename)
-
-
-def get_random_digit_string():
-    return ''.join(random.choice(string.digits) for i in range(9))
-
-
-def timedelta_to_ffmpeg_friendly_format(td_obj):
-    total_seconds = td_obj.total_seconds()
-    hours, remainder = divmod(total_seconds, 3600)
-    minutes, seconds = divmod(remainder, 60)
-    return "{:02}:{:02}:{:06.3f}".format(int(hours), int(minutes), seconds)
-
-
-def get_file_modification_time(file_path):
-    mod_time_epoch = os.path.getmtime(file_path)
-    mod_time = datetime.fromtimestamp(mod_time_epoch)
-    return mod_time
-
-
-def get_process_id_by_title(game_title):
-    powershell_command = f"Get-Process | Where-Object {{$_.MainWindowTitle -like '*{game_title}*'}} | Select-Object -First 1 -ExpandProperty Id"
-    process_id = subprocess.check_output(["powershell", "-Command", powershell_command], text=True).strip()
-    logger.info(f"Process ID for {game_title}: {process_id}")
-    return process_id
-
-
-def get_script_files(directory):
-    script_files = []
-    for root, dirs, files in os.walk(directory):
-        for file in files:
-            if file.endswith(".js"):  # Assuming the scripts are .js files
-                script_files.append(os.path.join(root, file))
-    return script_files
-
-
-def filter_steam_scripts(scripts):
-    return [script for script in scripts if "PC_Steam" in os.path.basename(script)]
-
-
-def extract_game_name(script_path):
-    # Remove directory and file extension to get the name part
-    script_name = os.path.basename(script_path)
-    game_name = script_name.replace("PC_Steam_", "").replace(".js", "")
-    return game_name.replace("_", " ").replace(".", " ")
-
-
-def find_most_similar_script(game_title, steam_scripts):
-    # Create a list of game names from the script paths
-    game_names = [extract_game_name(script) for script in steam_scripts]
-
-    # Use rapidfuzz to find the closest match
-    best_match = process.extractOne(game_title, game_names)
-
-    if best_match:
-        matched_game_name, confidence_score, index = best_match
-        return steam_scripts[index], matched_game_name, confidence_score
-    return None, None, None
-
-
-def find_script_for_game(game_title):
-    script_files = get_script_files(SCRIPTS_DIR)
-
-    steam_scripts = filter_steam_scripts(script_files)
-
-    best_script, matched_game_name, confidence = find_most_similar_script(game_title, steam_scripts)
-
-
-    if best_script:
-        logger.info(f"Found Script: {best_script}")
-        return best_script
-    else:
-        logger.warning("No similar script found.")
-
-
-def run_agent_and_hook(pname, agent_script):
-    command = f'agent --script=\"{agent_script}\" --pname={pname}'
-    logger.info("Running and Hooking Agent!")
-    try:
-        dos_process = subprocess.Popen(command, shell=True)
-        dos_process.wait()  # Wait for the process to complete
-        logger.info("Agent script finished or closed.")
-    except Exception as e:
-        logger.error(f"Error occurred while running agent script: {e}")
-
-    keep_running = False
-
-
-# def run_command(command, shell=False, input=None, capture_output=False, timeout=None, check=False, **kwargs):
-#     # Use shell=True if the OS is Linux, otherwise shell=False
-#     if is_linux():
-#         return subprocess.run(command, shell=True, input=input, capture_output=capture_output, timeout=timeout,
-#                               check=check, **kwargs)
-#     else:
-#         return subprocess.run(command, shell=shell, input=input, capture_output=capture_output, timeout=timeout,
-#                               check=check, **kwargs)
-def remove_html_and_cloze_tags(text):
-    text = re.sub(r'<.*?>', '', re.sub(r'{{c\d+::(.*?)(::.*?)?}}', r'\1', text))
-    return text
-
-
-def combine_dialogue(dialogue_lines, new_lines=None):
-    if not dialogue_lines:  # Handle empty input
-        return []
-
-    if new_lines is None:
-        new_lines = []
-
-    if len(dialogue_lines) == 1 and '「' not in dialogue_lines[0]:
-        new_lines.append(dialogue_lines[0])
-        return new_lines
-
-    character_name = dialogue_lines[0].split("「")[0]
-    text = character_name + "「"
-
-    for i, line in enumerate(dialogue_lines):
-        if not line.startswith(character_name + "「"):
-            text = text + "」" + get_config().advanced.multi_line_line_break
-            new_lines.append(text)
-            new_lines.extend(combine_dialogue(dialogue_lines[i:]))
-            break
-        else:
-            text +=  (get_config().advanced.multi_line_line_break if i > 0 else "") + line.split("「")[1].rstrip("」") + ""
-    else:
-        text = text + "」"
-        new_lines.append(text)
-
-    return new_lines
-
-def wait_for_stable_file(file_path, timeout=10, check_interval=0.1):
-    elapsed_time = 0
-    last_size = -1
-
-    while elapsed_time < timeout:
-        try:
-            current_size = os.path.getsize(file_path)
-            if current_size == last_size:
-                try:
-                    with open(file_path, 'rb') as f:
-                        return True
-                except Exception as e:
-                    time.sleep(check_interval)
-                    elapsed_time += check_interval
-            last_size = current_size
-            time.sleep(check_interval)
-            elapsed_time += check_interval
-        except Exception as e:
-            logger.warning(f"Error checking file size, will still try updating Anki Card!: {e}")
-            return False
-    logger.warning("File size did not stabilize within the timeout period. Continuing...")
-    return False
-
-
-def import_vad_models():
-    silero_trim, whisper_helper, vosk_helper = None, None, None
-    if get_config().vad.is_silero():
-        from GameSentenceMiner.vad import silero_trim
-    if get_config().vad.is_whisper():
-        from GameSentenceMiner.vad import whisper_helper
-    if get_config().vad.is_vosk():
-        from GameSentenceMiner.vad import vosk_helper
-    return silero_trim, whisper_helper, vosk_helper
-
-
-def isascii(s: str):
-    try:
-        return s.isascii()
-    except:
-        try:
-            s.encode("ascii")
-            return True
-        except:
-            return False
-
-def do_text_replacements(text, replacements_json):
-    if not text:
-        return text
-
-    replacements = {}
-    if os.path.exists(replacements_json):
-        with open(replacements_json, 'r', encoding='utf-8') as f:
-            replacements.update(json.load(f))
-
-    if replacements.get("enabled", False):
-        orig_text = text
-        filters = replacements.get("args", {}).get("replacements", {})
-        for fil, replacement in filters.items():
-            if not fil:
-                continue
-            if fil.startswith("re:"):
-                pattern = fil[3:]
-                try:
-                    text = re.sub(pattern, replacement, text)
-                except Exception:
-                    logger.error(f"Invalid regex pattern: {pattern}")
-                    continue
-            if isascii(fil):
-                text = re.sub(r"\b{}\b".format(re.escape(fil)), replacement, text)
-            else:
-                text = text.replace(fil, replacement)
-        if text != orig_text:
-            logger.info(f"Text replaced: '{orig_text}' -> '{text}' using replacements.")
-    return text
-
-
-TEXT_REPLACEMENTS_FILE = os.path.join(get_app_directory(), 'config', 'text_replacements.json')
-OCR_REPLACEMENTS_FILE = os.path.join(get_app_directory(), 'config', 'ocr_replacements.json')
-os.makedirs(os.path.dirname(TEXT_REPLACEMENTS_FILE), exist_ok=True)
-
-# 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:
-#         with urllib.request.urlopen(url) as response:
-#             data = response.read().decode('utf-8')
-#             with open(OCR_REPLACEMENTS_FILE, 'w', encoding='utf-8') as f:
-#                 f.write(data)
-#     except Exception as e:
-#         logger.error(f"Failed to fetch JSON from {url}: {e}")

GameSentenceMiner/vad/groq_trim.py

@@ -1,82 +0,0 @@
-import os
-import tempfile
-import time
-
-from groq import Groq
-
-# Assuming these are available from GameSentenceMiner
-from GameSentenceMiner import configuration, ffmpeg
-from GameSentenceMiner.configuration import get_config, logger, GROQ  # Import specific functions/objects
-from GameSentenceMiner.vad.result import VADResult
-from GameSentenceMiner.vad.vad_utils import get_audio_length
-
-# Initialize Groq Client
-client = Groq(api_key=get_config().ai.groq_api_key)
-
-def detect_voice_with_groq(input_audio_path):
-    """
-    Detects voice activity and extracts speech timestamps using the Groq Whisper API.
-    """
-    try:
-        with open(input_audio_path, "rb") as file:
-            transcription = client.audio.transcriptions.create(
-                file=(os.path.basename(input_audio_path), file.read()),
-                model="whisper-large-v3-turbo",
-                response_format="verbose_json",
-                language=get_config().vad.language,
-                temperature=0.0,
-                timestamp_granularities=["segment"],
-                prompt=f"Start detecting speech from the first spoken word. If there is music or background noise, ignore it completely. Be very careful to not hallucinate on silence. If the transcription is anything but language:{get_config().vad.language}, ignore it completely. If the end of the audio seems like the start of a new sentence, ignore it completely.",
-            )
-
-        logger.debug(transcription)
-
-        # print(transcription)
-
-        speech_segments = transcription.segments if hasattr(transcription, 'segments') else []
-        # print(f"Groq speech segments: {speech_segments}")
-
-        audio_length = get_audio_length(input_audio_path)
-        # print(f"FFPROBE Length of input audio: {audio_length}")
-
-        return speech_segments, audio_length
-    except Exception as e:
-        logger.error(f"Error detecting voice with Groq: {e}")
-        return [], 0.0
-
-def process_audio_with_groq(input_audio, output_audio, game_line):
-    """
-    Processes an audio file by detecting voice activity using Groq Whisper API,
-    trimming the audio based on detected speech timestamps, and saving the trimmed audio.
-    """
-    start = time.time()
-    voice_activity, audio_length = detect_voice_with_groq(input_audio)
-    logger.info(f"Processing time for Groq: {time.time() - start:.2f} seconds")
-
-    if not voice_activity:
-        logger.info(f"No voice activity detected in {input_audio}")
-        return VADResult(False, 0, 0, GROQ)
-
-    start_time = voice_activity[0]['start']
-    end_time = voice_activity[-1]['end']
-
-    # Logic to potentially use the second-to-last timestamp if a next game line is expected
-    # and there's a significant pause before the very last segment.
-    if (game_line and hasattr(game_line, 'next') and game_line.next and
-        len(voice_activity) > 1 and
-        (voice_activity[-1]['start'] - voice_activity[-2]['end']) > 3.0):
-        end_time = voice_activity[-2]['end']
-        logger.info("Using the second last timestamp for trimming due to game_line.next and significant pause.")
-
-    # Apply offsets from configuration, ensuring times are within valid bounds
-    final_start_time = max(0, start_time + get_config().vad.beginning_offset)
-    final_end_time = min(audio_length, end_time + get_config().audio.end_offset)
-
-    logger.debug(f"Trimming {input_audio} from {final_start_time:.2f}s to {final_end_time:.2f}s into {output_audio}")
-
-    ffmpeg.trim_audio(input_audio, final_start_time, final_end_time, output_audio)
-
-    return VADResult(True, final_start_time, final_end_time, GROQ)
-
-# Example usage (uncomment and modify with your actual file paths for testing)
-# process_audio_with_groq("tmp6x81cy27.opus", "tmp6x81cy27_trimmed_groq.opus", None)

GameSentenceMiner/vad/result.py

@@ -1,21 +0,0 @@
-from GameSentenceMiner.configuration import get_config
-
-
-class VADResult:
-    def __init__(self, success: bool, start: float, end: float, model: str):
-        self.success = success
-        self.start = start
-        self.end = end
-        self.model = model
-
-    def __repr__(self):
-        return f"VADResult(success={self.success}, start={self.start}, end={self.end}, model={self.model})"
-
-    def trim_successful_string(self):
-        if self.success:
-            if get_config().vad.trim_beginning:
-                return f"Trimmed audio from {self.start:.2f} to {self.end:.2f} seconds using {self.model}."
-            else:
-                return f"Trimmed end of audio to {self.end:.2f} seconds using {self.model}."
-        else:
-            return f"Failed to trim audio using {self.model}."

GameSentenceMiner/vad/silero_trim.py

@@ -1,52 +0,0 @@
-import tempfile
-
-from silero_vad import load_silero_vad, read_audio, get_speech_timestamps
-
-from GameSentenceMiner  import configuration, ffmpeg
-from GameSentenceMiner.configuration import *
-from GameSentenceMiner.vad.result import VADResult
-from GameSentenceMiner.vad.vad_utils import get_audio_length
-
-# Silero VAD setup
-vad_model = load_silero_vad()
-
-
-# Use Silero to detect voice activity with timestamps in the audio
-def detect_voice_with_silero(input_audio):
-    # Convert the audio to 16kHz mono WAV
-    temp_wav = tempfile.NamedTemporaryFile(dir=configuration.get_temporary_directory(), suffix='.wav').name
-    ffmpeg.convert_audio_to_wav(input_audio, temp_wav)
-
-    # Load the audio and detect speech timestamps
-    wav = read_audio(temp_wav)
-    speech_timestamps = get_speech_timestamps(wav, vad_model, return_seconds=True)
-
-    logger.debug(speech_timestamps)
-
-    # Return the speech timestamps (start and end in seconds)
-    return speech_timestamps, len(wav) / 16000
-
-
-# Example usage of Silero with trimming
-def process_audio_with_silero(input_audio, output_audio, game_line):
-    voice_activity, audio_length = detect_voice_with_silero(input_audio)
-
-    if not voice_activity:
-        return VADResult(False, 0, 0, SILERO)
-
-    # Trim based on the first and last speech detected
-    start_time = voice_activity[0]['start'] if voice_activity else 0
-    if game_line and game_line.next and len(voice_activity) > 1 and 0 > audio_length - voice_activity[-1]['start'] + get_config().audio.beginning_offset:
-    #         and (voice_activity[-1]['start'] - voice_activity[-2]['end']) > 3.0):
-            end_time = voice_activity[-2]['end']
-            logger.info("Using the second last timestamp for trimming")
-    else:
-        end_time = voice_activity[-1]['end'] if voice_activity else 0
-
-    # Trim the audio using FFmpeg
-    ffmpeg.trim_audio(input_audio, start_time + get_config().vad.beginning_offset, end_time + get_config().audio.end_offset, output_audio)
-    return VADResult(True, start_time + get_config().vad.beginning_offset, end_time + get_config().audio.end_offset, SILERO)
-
-
-# process_audio_with_silero("tmp6x81cy27.opus", "tmp6x81cy27_trimmed.opus", None)
-# print(detect_voice_with_silero("tmp6x81cy27.opus"))

GameSentenceMiner/vad/vad_utils.py

@@ -1,13 +0,0 @@
-import subprocess
-
-from GameSentenceMiner.ffmpeg import get_ffprobe_path
-
-
-def get_audio_length(path):
-    result = subprocess.run(
-        [get_ffprobe_path(), "-v", "error", "-show_entries", "format=duration", "-of", "default=noprint_wrappers=1:nokey=1", path],
-        stdout=subprocess.PIPE,
-        stderr=subprocess.PIPE,
-        text=True
-    )
-    return float(result.stdout.strip())

GameSentenceMiner/vad/vosk_helper.py

@@ -1,158 +0,0 @@
-import tarfile
-import tempfile
-import zipfile
-
-import numpy as np
-import requests
-import soundfile as sf
-import vosk
-
-from GameSentenceMiner  import configuration, ffmpeg
-from GameSentenceMiner.configuration import *
-from GameSentenceMiner.vad.result import VADResult
-
-ffmpeg_base_command_list = ["ffmpeg", "-hide_banner", "-loglevel", "error"]
-vosk.SetLogLevel(-1)
-vosk_model_path = ''
-vosk_model = None
-
-
-# Function to download and cache the Vosk model
-def download_and_cache_vosk_model(model_dir="vosk_model_cache"):
-    # Ensure the cache directory exists
-    if not os.path.exists(os.path.join(get_app_directory(), model_dir)):
-        os.makedirs(os.path.join(get_app_directory(), model_dir))
-
-    # Extract the model name from the URL
-    model_filename = get_config().vad.vosk_url.split("/")[-1]
-    model_path = os.path.join(get_app_directory(), model_dir, model_filename)
-
-    # If the model is already downloaded, skip the download
-    if not os.path.exists(model_path):
-        logger.info(
-            f"Downloading the Vosk model from {get_config().vad.vosk_url}... This will take a while if using large model, ~1G")
-        response = requests.get(get_config().vad.vosk_url, stream=True)
-        with open(model_path, "wb") as file:
-            for chunk in response.iter_content(chunk_size=8192):
-                if chunk:
-                    file.write(chunk)
-        logger.info("Download complete.")
-
-    # Extract the model if it's a zip or tar file
-    model_extract_path = os.path.join(get_app_directory(), model_dir, "vosk_model")
-    if not os.path.exists(model_extract_path):
-        logger.info("Extracting the Vosk model...")
-        if model_filename.endswith(".zip"):
-            with zipfile.ZipFile(model_path, "r") as zip_ref:
-                zip_ref.extractall(model_extract_path)
-        elif model_filename.endswith(".tar.gz"):
-            with tarfile.open(model_path, "r:gz") as tar_ref:
-                tar_ref.extractall(model_extract_path)
-        else:
-            logger.info("Unknown archive format. Model extraction skipped.")
-        logger.info(f"Model extracted to {model_extract_path}.")
-    else:
-        logger.info(f"Model already extracted at {model_extract_path}.")
-
-    # Return the path to the actual model folder inside the extraction directory
-    extracted_folders = os.listdir(model_extract_path)
-    if extracted_folders:
-        actual_model_folder = os.path.join(model_extract_path,
-                                           extracted_folders[0])  # Assuming the first folder is the model
-        return actual_model_folder
-    else:
-        return model_extract_path  # In case there's no subfolder, return the extraction path directly
-
-
-# Use Vosk to detect voice activity with timestamps in the audio
-def detect_voice_with_vosk(input_audio):
-    global vosk_model_path, vosk_model
-    # Convert the audio to 16kHz mono WAV
-    temp_wav = tempfile.NamedTemporaryFile(dir=configuration.get_temporary_directory(), suffix='.wav').name
-    ffmpeg.convert_audio_to_wav(input_audio, temp_wav)
-
-    if not vosk_model_path or not vosk_model:
-        vosk_model_path = download_and_cache_vosk_model()
-        vosk_model = vosk.Model(vosk_model_path)
-
-    # Open the audio file
-    with sf.SoundFile(temp_wav) as audio_file:
-        recognizer = vosk.KaldiRecognizer(vosk_model, audio_file.samplerate)
-        voice_activity = []
-        total_duration = len(audio_file) / audio_file.samplerate  # Get total duration in seconds
-
-        recognizer.SetWords(True)
-        # recognizer.SetPartialWords(True)
-
-        # Process audio in chunks
-        while True:
-            data = audio_file.buffer_read(4000, dtype='int16')
-            if len(data) == 0:
-                break
-
-            # Convert buffer to bytes using NumPy
-            data_bytes = np.frombuffer(data, dtype='int16').tobytes()
-
-            if recognizer.AcceptWaveform(data_bytes):
-                pass
-
-        final_result = json.loads(recognizer.FinalResult())
-        if 'result' in final_result:
-            should_use = False
-            unique_words = set()
-            for word in final_result['result']:
-                if word['conf'] >= .90:
-                    logger.debug(word)
-                    should_use = True
-                    unique_words.add(word['word'])
-            if len(unique_words) == 1 or all(item in ['えー', 'ん'] for item in unique_words):
-                should_use = False
-
-            if not should_use:
-                return None, 0
-
-            for word in final_result['result']:
-                voice_activity.append({
-                    'text': word['word'],
-                    'start': word['start'],
-                    'end': word['end']
-                })
-
-    # Return the detected voice activity and the total duration
-    return voice_activity, total_duration
-
-
-# Example usage of Vosk with trimming
-def process_audio_with_vosk(input_audio, output_audio, game_line):
-    voice_activity, total_duration = detect_voice_with_vosk(input_audio)
-
-    if not voice_activity:
-        logger.info("No voice activity detected in the audio.")
-        return VADResult(False, 0, 0, VOSK)
-
-    # Trim based on the first and last speech detected
-    start_time = voice_activity[0]['start'] if voice_activity else 0
-    # if (game_line.next and len(voice_activity) > 1
-    #         and voice_activity[-1]['start'] - get_config().audio.beginning_offset > len(input_audio) / 16000
-    #         and (voice_activity[-1]['start'] - voice_activity[-2]['end']) > 5.0):
-    #     end_time = voice_activity[-2]['end']
-    #     logger.info("Using the second last timestamp for trimming")
-    # else:
-    end_time = voice_activity[-1]['end'] if voice_activity else 0
-
-    if get_config().vad.trim_beginning:
-        logger.info(f"VAD Trimmed Beginning of Audio to {start_time}")
-
-    # Print detected speech details with timestamps
-    logger.info(f"VAD Trimmed End of Audio to {end_time} seconds:")
-
-    # Trim the audio using FFmpeg
-    ffmpeg.trim_audio(input_audio, start_time + get_config().vad.beginning_offset, end_time + get_config().audio.end_offset, output_audio)
-    return VADResult(True, start_time + get_config().vad.beginning_offset, end_time + get_config().audio.end_offset, VOSK)
-
-
-def get_vosk_model():
-    global vosk_model_path, vosk_model
-    vosk_model_path = download_and_cache_vosk_model()
-    vosk_model = vosk.Model(vosk_model_path)
-    logger.info(f"Using Vosk model from {vosk_model_path}")