GameSentenceMiner 2.0.0__py3-none-any.whl

GameSentenceMiner/obs.py

@@ -0,0 +1,128 @@
+import time
+
+import obswebsocket
+from obswebsocket import obsws, requests
+from obswebsocket.exceptions import ConnectionFailure
+
+from . import util
+from . import configuration
+from .configuration import *
+from .model import *
+
+client: obsws = None
+
+# REFERENCE: https://github.com/obsproject/obs-websocket/blob/master/docs/generated/protocol.md
+
+
+def on_connect(obs):
+    logger.info("Connected to OBS WebSocket.")
+    time.sleep(2)
+    if get_config().obs.start_buffer:
+        start_replay_buffer()
+
+
+def on_disconnect(obs):
+    logger.error("OBS Connection Lost!")
+
+
+def connect_to_obs(start_replay=False):
+    global client
+    if get_config().obs.enabled:
+        client = obsws(host=get_config().obs.host, port=get_config().obs.port,
+                       password=get_config().obs.password, authreconnect=1, on_connect=on_connect,
+                       on_disconnect=on_disconnect)
+        try:
+            client.connect()
+        except ConnectionFailure:
+            logger.error("OBS Websocket Connection Has not been Set up, please set it up in Settings")
+            exit(1)
+
+        time.sleep(1)
+        if start_replay and get_config().obs.start_buffer:
+            start_replay_buffer()
+        update_current_game()
+
+
+# Disconnect from OBS WebSocket
+def disconnect_from_obs():
+    global client
+    if client:
+        client.disconnect()
+        client = None
+        logger.info("Disconnected from OBS WebSocket.")
+
+
+# Start replay buffer
+def start_replay_buffer():
+    try:
+        client.call(requests.GetVersion())
+        client.call(requests.StartReplayBuffer())
+    except Exception as e:
+        print(f"Error starting replay buffer: {e}")
+
+
+# Stop replay buffer
+def stop_replay_buffer():
+    try:
+        client.call(requests.StopReplayBuffer())
+        print("Replay buffer stopped.")
+    except Exception as e:
+        print(f"Error stopping replay buffer: {e}")
+
+
+# Save the current replay buffer
+def save_replay_buffer():
+    try:
+        client.call(requests.SaveReplayBuffer())
+    except Exception as e:
+        print(f"Error saving replay buffer: {e}")
+
+
+def get_current_scene():
+    try:
+        response = client.call(requests.GetCurrentProgramScene())
+        scene_info = SceneInfo.from_dict(response.datain)
+        return scene_info.sceneName
+    except Exception as e:
+        print(f"Couldn't get scene: {e}")
+    return ''
+
+
+def get_source_from_scene(scene_name):
+    try:
+        response = client.call(requests.GetSceneItemList(sceneName=scene_name))
+        scene_list = SceneItemsResponse.from_dict(response.datain)
+        print(scene_list)
+        return scene_list.sceneItems[0]
+    except Exception as e:
+        print(f"Error getting source from scene: {e}")
+        return ''
+
+
+def get_screenshot():
+    try:
+        screenshot = util.make_unique_file_name(os.path.abspath(configuration.temp_directory) + '/screenshot.png')
+        update_current_game()
+        current_source = get_source_from_scene(get_current_game())
+        current_source_name = current_source.sourceName
+        if not current_source_name:
+            print("No active scene found.")
+            return
+        client.call(
+            requests.SaveSourceScreenshot(sourceName=current_source_name, imageFormat='png', imageFilePath=screenshot))
+        return screenshot
+    except Exception as e:
+        print(f"Error getting screenshot: {e}")
+
+
+def update_current_game():
+    configuration.current_game = get_current_scene()
+
+
+def get_current_game(sanitize=False):
+    if not configuration.current_game:
+        update_current_game()
+
+    if sanitize:
+        return util.sanitize_filename(configuration.current_game)
+    return configuration.current_game

GameSentenceMiner/util.py

@@ -0,0 +1,136 @@
+import os
+import random
+import re
+import string
+import subprocess
+import threading
+from datetime import datetime
+from sys import platform
+
+from rapidfuzz import process
+
+SCRIPTS_DIR = r"E:\Japanese Stuff\agent-v0.1.4-win32-x64\data\scripts"
+
+# Global variables to control script execution
+use_previous_audio = False
+keep_running = True
+lock = threading.Lock()
+
+
+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()
+    print(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:
+        print(f"Found Script: {best_script}")
+        return best_script
+    else:
+        print("No similar script found.")
+
+
+def run_agent_and_hook(pname, agent_script):
+    command = f'agent --script=\"{agent_script}\" --pname={pname}'
+    print("Running and Hooking Agent!")
+    try:
+        dos_process = subprocess.Popen(command, shell=True)
+        dos_process.wait()  # Wait for the process to complete
+        print("Agent script finished or closed.")
+    except Exception as e:
+        print(f"Error occurred while running agent script: {e}")
+
+    keep_running = False
+
+
+def is_linux():
+    return platform == 'linux'
+
+# 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_tags(text):
+    clean_text = re.sub(r'<.*?>', '', text)
+    return clean_text

GameSentenceMiner/vad/silero_trim.py

@@ -0,0 +1,43 @@
+import tempfile
+
+from silero_vad import load_silero_vad, read_audio, get_speech_timestamps
+
+from .. import configuration, ffmpeg
+from ..configuration import *
+
+# 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.temp_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, sampling_rate=16000)
+    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
+
+
+# Example usage of Silero with trimming
+def process_audio_with_silero(input_audio, output_audio):
+    voice_activity = detect_voice_with_silero(input_audio)
+
+    if not voice_activity:
+        logger.info("No voice activity detected in the audio.")
+        return False
+
+    # Trim based on the first and last speech detected
+    start_time = voice_activity[0]['start'] if voice_activity else 0
+    end_time = voice_activity[-1]['end'] if voice_activity else 0
+
+    # Trim the audio using FFmpeg
+    ffmpeg.trim_audio(input_audio, start_time, end_time + get_config().audio.end_offset, output_audio)
+    logger.info(f"Trimmed audio saved to: {output_audio}")
+    return True

GameSentenceMiner/vad/vosk_helper.py

@@ -0,0 +1,152 @@
+import tarfile
+import tempfile
+import zipfile
+
+import numpy as np
+import requests
+import soundfile as sf
+import vosk
+
+from .. import ffmpeg, configuration
+from ..configuration import *
+
+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(model_dir):
+        os.makedirs(model_dir)
+
+    # Extract the model name from the URL
+    model_filename = get_config().vad.vosk_url.split("/")[-1]
+    model_path = os.path.join(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(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.temp_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):
+    voice_activity, total_duration = detect_voice_with_vosk(input_audio)
+
+    if not voice_activity:
+        logger.info("No voice activity detected in the audio.")
+        return False
+
+    # Trim based on the first and last speech detected
+    start_time = voice_activity[0]['start'] if voice_activity else 0
+    end_time = voice_activity[-1]['end'] if voice_activity else total_duration
+
+    if get_config().vad.trim_beginning:
+        logger.info(f"Trimmed Beginning of Audio to {start_time}")
+
+    # Print detected speech details with timestamps
+    logger.info(f"Trimmed End of Audio to {end_time} seconds:")
+
+    # Trim the audio using FFmpeg
+    ffmpeg.trim_audio(input_audio, start_time, end_time + get_config().audio.end_offset, output_audio)
+    logger.info(f"Trimmed audio saved to: {output_audio}")
+    return True
+
+
+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}")

GameSentenceMiner/vad/whisper_helper.py

@@ -0,0 +1,98 @@
+import tempfile
+import warnings
+
+import stable_whisper as whisper
+from stable_whisper import WhisperResult
+
+from .. import ffmpeg, configuration
+from ..configuration import *
+
+ffmpeg_base_command_list = ["ffmpeg", "-hide_banner", "-loglevel", "error"]
+whisper_model = None
+
+
+# Function to download and load the Whisper model
+def load_whisper_model():
+    global whisper_model
+    if whisper_model is None:
+        logger.info(f"Loading Whisper model '{get_config().vad.whisper_model}'... This may take a while.")
+        with warnings.catch_warnings(action="ignore"):
+            whisper_model = whisper.load_model(get_config().vad.whisper_model)
+        logger.info("Whisper model loaded.")
+
+
+# Use Whisper to detect voice activity with timestamps in the audio
+def detect_voice_with_whisper(input_audio):
+    # Convert the audio to 16kHz mono WAV
+    temp_wav = tempfile.NamedTemporaryFile(dir=configuration.temp_directory, suffix='.wav').name
+    ffmpeg.convert_audio_to_wav(input_audio, temp_wav)
+
+    # Make sure Whisper is loaded
+    load_whisper_model()
+
+    logger.info('transcribing audio...')
+
+    # Transcribe the audio using Whisper
+    with warnings.catch_warnings(action="ignore"):
+        result: WhisperResult = whisper_model.transcribe(temp_wav, vad=True, language='ja')
+
+    voice_activity = []
+
+    logger.debug(result.to_dict())
+
+    # Process the segments to extract tokens, timestamps, and confidence
+    for segment in result.segments:
+        logger.debug(segment.to_dict())
+        for word in segment.words:
+            logger.debug(word.to_dict())
+            confidence = word.probability
+            if confidence > .1:
+                logger.debug(word)
+                voice_activity.append({
+                    'text': word.word,
+                    'start': word.start,
+                    'end': word.end,
+                    'confidence': word.probability
+                })
+
+    # Analyze the detected words to decide whether to use the audio
+    should_use = False
+    unique_words = set(word['text'] for word in voice_activity)
+    if len(unique_words) > 1 or not all(item in ['えー', 'ん'] for item in unique_words):
+        should_use = True
+
+    if not should_use:
+        return None
+
+    # Return the detected voice activity and the total duration
+    return voice_activity
+
+
+# Example usage of Whisper with trimming
+def process_audio_with_whisper(input_audio, output_audio):
+    voice_activity = detect_voice_with_whisper(input_audio)
+
+    if not voice_activity:
+        logger.info("No voice activity detected in the audio.")
+        return False
+
+    # Trim based on the first and last speech detected
+    start_time = voice_activity[0]['start']
+    end_time = voice_activity[-1]['end']
+
+    if get_config().vad.trim_beginning:
+        logger.info(f"Trimmed Beginning of Audio to {start_time}")
+
+    # Print detected speech details with timestamps
+    logger.info(f"Trimmed End of Audio to {end_time} seconds:")
+
+    # Trim the audio using FFmpeg
+    ffmpeg.trim_audio(input_audio, start_time, end_time + get_config().audio.end_offset, output_audio)
+    logger.info(f"Trimmed audio saved to: {output_audio}")
+    return True
+
+
+# Load Whisper model initially
+def initialize_whisper_model():
+    load_whisper_model()
+    logger.info(f"Using Whisper model '{get_config().vad.whisper_model}' for Japanese voice detection")