GameSentenceMiner 2.1.2.post1__py3-none-any.whl → 2.2.1__py3-none-any.whl

{GameSentenceMiner → src}/ffmpeg.py

@@ -1,19 +1,24 @@
+import subprocess
 import tempfile
 import time
 
-from . import obs
-from . import util
-from . import configuration
-from .configuration import *
-from .util import *
+from src import obs, util, configuration
+from src.configuration import *
+from src.util import *
 
-ffmpeg_base_command_list = ["ffmpeg", "-hide_banner", "-loglevel", "error", '-nostdin']
+def get_ffmpeg_path():
+    return os.path.join(get_app_directory(), "ffmpeg", "ffmpeg.exe") if util.is_windows() else "ffmpeg"
+
+def get_ffprobe_path():
+    return os.path.join(get_app_directory(), "ffmpeg", "ffprobe.exe") if util.is_windows() else "ffprobe"
+
+ffmpeg_base_command_list = [get_ffmpeg_path(), "-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}")
+    output_image = make_unique_file_name(os.path.join(
+        get_config().paths.screenshot_destination, f"{obs.get_current_game(sanitize=True)}.{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
@@ -59,7 +64,7 @@ def get_screenshot_time(video_path, line_time):
 
 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}")
+        os.path.join(get_config().paths.screenshot_destination, f"{obs.get_current_game(sanitize=True)}.{get_config().screenshot.extension}"))
 
     # FFmpeg command to process the input image
     ffmpeg_command = ffmpeg_base_command_list + [
@@ -88,7 +93,7 @@ def process_image(image_file):
 
 def get_audio_codec(video_path):
     command = [
-        "ffprobe",
+        f"{get_ffprobe_path()}",
         "-v", "error",
         "-select_streams", "a:0",
         "-show_entries", "stream=codec_name",
@@ -112,7 +117,7 @@ def get_audio_codec(video_path):
 
 def get_audio_and_trim(video_path, line_time, next_line_time):
     supported_formats = {
-        'opus': 'opus',
+        'opus': 'libopus',
         'mp3': 'libmp3lame',
         'ogg': 'libvorbis',
         'aac': 'aac',
@@ -139,7 +144,7 @@ def get_audio_and_trim(video_path, line_time, next_line_time):
 
     # 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("Doing initial audio extraction")
     logger.debug(" ".join(command))
 
     subprocess.run(command)
@@ -149,12 +154,13 @@ def get_audio_and_trim(video_path, line_time, next_line_time):
 
 def get_video_duration(file_path):
     ffprobe_command = [
-        "ffprobe",
+        f"{get_ffprobe_path()}",
         "-v", "error",
         "-show_entries", "format=duration",
         "-of", "json",
         file_path
     ]
+    logger.debug(" ".join(ffprobe_command))
     result = subprocess.run(ffprobe_command, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
     duration_info = json.loads(result.stdout)
     return float(duration_info["format"]["duration"])  # Return the duration in seconds
@@ -295,3 +301,4 @@ def is_video_big_enough(file_path, min_size_kb=250):
     except Exception as e:
         logger.error(f"Error: {e}")
         return False
+

{GameSentenceMiner → src}/gametext.py

@@ -7,10 +7,10 @@ from datetime import datetime
 import pyperclip
 import websockets
 
-from . import util
-from .configuration import *
-from .configuration import get_config, logger
-from .util import remove_html_tags
+from src import util
+from src.configuration import *
+from src.configuration import get_config, logger
+from src.util import remove_html_tags
 from difflib import SequenceMatcher
 
 
@@ -51,7 +51,7 @@ async def listen_websocket():
         try:
             async with websockets.connect(f'ws://{get_config().general.websocket_uri}', ping_interval=None) as websocket:
                 if reconnecting:
-                    print(f"Texthooker WebSocket connected Successfully!")
+                    logger.info(f"Texthooker WebSocket connected Successfully!")
                     reconnecting = False
                 while True:
                     message = await websocket.recv()
@@ -71,7 +71,7 @@ async def listen_websocket():
 
         except (websockets.ConnectionClosed, ConnectionError) as e:
             if not reconnecting:
-                print(f"Texthooker WebSocket connection lost: {e}. Attempting to Reconnect...")
+                logger.warning(f"Texthooker WebSocket connection lost: {e}. Attempting to Reconnect...")
             reconnecting = True
             await asyncio.sleep(5)
 

{GameSentenceMiner → src}/gsm.py

@@ -1,8 +1,8 @@
-import shutil
 import signal
+import subprocess
 import sys
-import tempfile
 import time
+from subprocess import Popen
 
 import keyboard
 import psutil
@@ -12,21 +12,23 @@ from pystray import Icon, Menu, MenuItem
 from watchdog.events import FileSystemEventHandler
 from watchdog.observers import Observer
 
-from . import anki
-from . import config_gui
-from . import configuration
-from . import ffmpeg
-from . import gametext
-from . import notification
-from . import obs
-from . import util
-from .vad import vosk_helper, silero_trim, whisper_helper
-from .configuration import *
-from .ffmpeg import get_audio_and_trim
-from .gametext import get_line_timing
-from .util import *
-
-config_pids = []
+from src import anki
+from src import config_gui
+from src import configuration
+from src import ffmpeg
+from src import gametext
+from src import notification
+from src import obs
+from src import util
+from src.downloader.download_tools import download_obs_if_needed, download_ffmpeg_if_needed
+from src.vad import vosk_helper, silero_trim, whisper_helper
+from src.configuration import *
+from src.ffmpeg import get_audio_and_trim
+from src.gametext import get_line_timing
+from src.util import *
+
+obs_process: Popen
+procs_to_close = []
 settings_window: config_gui.ConfigApp = None
 obs_paused = False
 icon: Icon
@@ -35,7 +37,7 @@ menu: Menu
 
 class VideoToAudioHandler(FileSystemEventHandler):
     def on_created(self, event):
-        if event.is_directory or "Replay" not in event.src_path:
+        if event.is_directory or ("Replay" not in event.src_path and "GSM" not in event.src_path):
             return
         if event.src_path.endswith(".mkv") or event.src_path.endswith(".mp4"):  # Adjust based on your OBS output format
             logger.info(f"MKV {event.src_path} FOUND, RUNNING LOGIC")
@@ -46,14 +48,19 @@ class VideoToAudioHandler(FileSystemEventHandler):
     def convert_to_audio(video_path):
         try:
             with util.lock:
+                if os.path.exists(video_path) and os.access(video_path, os.R_OK):
+                    logger.debug(f"Video found and is readable: {video_path}")
+
                 if get_config().obs.minimum_replay_size and not ffmpeg.is_video_big_enough(video_path,
                                                                                            get_config().obs.minimum_replay_size):
+                    logger.debug("Checking if video is big enough")
                     notification.send_check_obs_notification(reason="Video may be empty, check scene in OBS.")
                     logger.error(
                         f"Video was unusually small, potentially empty! Check OBS for Correct Scene Settings! Path: {video_path}")
                     return
                 util.use_previous_audio = True
                 last_note = None
+                logger.debug("Attempting to get last anki card")
                 if get_config().anki.update_anki:
                     last_note = anki.get_last_anki_card()
                 if get_config().features.backfill_audio:
@@ -70,6 +77,7 @@ class VideoToAudioHandler(FileSystemEventHandler):
                 tango = last_note['fields'][get_config().anki.word_field]['value'] if last_note else ''
 
                 if get_config().anki.sentence_audio_field:
+                    logger.debug("Attempting to get audio from video")
                     final_audio_output, should_update_audio, vad_trimmed_audio = VideoToAudioHandler.get_audio(
                         line_time,
                         next_line_time,
@@ -92,10 +100,9 @@ class VideoToAudioHandler(FileSystemEventHandler):
                     except Exception as e:
                         logger.error(f"Card failed to update! Maybe it was removed? {e}")
                 except FileNotFoundError as f:
-                    print(f)
-                    print("Something went wrong with processing, anki card not updated")
+                    logger.error("Something went wrong with processing, anki card not updated")
         except Exception as e:
-            logger.error(f"Some error was hit catching to allow further work to be done: {e}")
+            logger.error(f"Some error was hit catching to allow further work to be done: {e}", exc_info=1)
         if get_config().paths.remove_video and os.path.exists(video_path):
             os.remove(video_path)  # Optionally remove the video after conversion
         if get_config().paths.remove_audio and os.path.exists(vad_trimmed_audio):
@@ -106,8 +113,7 @@ class VideoToAudioHandler(FileSystemEventHandler):
         trimmed_audio = get_audio_and_trim(video_path, line_time, next_line_time)
         vad_trimmed_audio = make_unique_file_name(
             f"{os.path.abspath(configuration.get_temporary_directory())}/{obs.get_current_game(sanitize=True)}.{get_config().audio.extension}")
-        final_audio_output = make_unique_file_name(
-            f"{get_config().paths.audio_destination}{obs.get_current_game(sanitize=True)}.{get_config().audio.extension}")
+        final_audio_output = make_unique_file_name(os.path.join(get_config().paths.audio_destination, f"{obs.get_current_game(sanitize=True)}.{get_config().audio.extension}"))
         should_update_audio = True
         if get_config().vad.do_vad_postprocessing:
             match get_config().vad.selected_vad_model:
@@ -139,26 +145,33 @@ class VideoToAudioHandler(FileSystemEventHandler):
 
 
 def initialize(reloading=False):
+    global obs_process
     if not reloading:
+        if is_windows():
+            download_obs_if_needed()
+            download_ffmpeg_if_needed()
         if get_config().obs.enabled:
+            obs_process = obs.start_obs()
             obs.connect_to_obs(start_replay=True)
             anki.start_monitoring_anki()
-        if get_config().general.open_config_on_startup:
-            proc = subprocess.Popen([sys.executable, "config_gui.py"])
-            config_pids.append(proc.pid)
         gametext.start_text_monitor()
-        if not os.path.exists(get_config().paths.folder_to_watch):
-            os.mkdir(get_config().paths.folder_to_watch)
-        if not os.path.exists(get_config().paths.screenshot_destination):
-            os.mkdir(get_config().paths.screenshot_destination)
-        if not os.path.exists(get_config().paths.audio_destination):
-            os.mkdir(get_config().paths.audio_destination)
+        os.makedirs(get_config().paths.folder_to_watch, exist_ok=True)
+        os.makedirs(get_config().paths.screenshot_destination, exist_ok=True)
+        os.makedirs(get_config().paths.audio_destination, exist_ok=True)
     if get_config().vad.do_vad_postprocessing:
         if VOSK in (get_config().vad.backup_vad_model, get_config().vad.selected_vad_model):
             vosk_helper.get_vosk_model()
         if WHISPER in (get_config().vad.backup_vad_model, get_config().vad.selected_vad_model):
             whisper_helper.initialize_whisper_model()
 
+def initial_checks():
+    try:
+        subprocess.run(ffmpeg.ffmpeg_base_command_list)
+        logger.debug("FFMPEG is installed and accessible.")
+    except FileNotFoundError:
+        logger.error("FFmpeg not found, please install it and add it to your PATH.")
+        raise
+
 
 def register_hotkeys():
     keyboard.add_hotkey(get_config().hotkeys.reset_line, gametext.reset_line_hotkey_pressed)
@@ -216,9 +229,9 @@ def open_settings():
 def open_log():
     """Function to handle opening log."""
     """Open log file with the default application."""
-    log_file_path = "../../gamesentenceminer.log"
+    log_file_path = get_log_path()
     if not os.path.exists(log_file_path):
-        print("Log file not found!")
+        logger.error("Log file not found!")
         return
 
     if sys.platform.startswith("win"):  # Windows
@@ -228,30 +241,22 @@ def open_log():
     elif sys.platform.startswith("linux"):  # Linux
         subprocess.call(["xdg-open", log_file_path])
     else:
-        print("Unsupported platform!")
-    print("Log opened.")
+        logger.error("Unsupported platform!")
+    logger.info("Log opened.")
 
 
 def exit_program(icon, item):
     """Exit the application."""
-    print("Exiting...")
+    logger.info("Exiting...")
     icon.stop()
     cleanup()
 
 
 def play_pause(icon, item):
     global obs_paused, menu
-    if obs_paused:
-        obs.start_replay_buffer()
-    else:
-        obs.stop_replay_buffer()
-
-    obs_paused = not obs_paused
+    obs.toggle_replay_buffer()
     update_icon()
 
-def get_obs_icon_text():
-    return "Pause OBS" if obs_paused else "Resume OBS"
-
 
 def update_icon():
     global menu, icon
@@ -264,7 +269,8 @@ def update_icon():
     menu = Menu(
         MenuItem("Open Settings", open_settings),
         MenuItem("Open Log", open_log),
-        MenuItem(get_obs_icon_text(), play_pause),
+        MenuItem("Toggle Replay Buffer", play_pause),
+        MenuItem("Restart OBS", restart_obs),
         MenuItem("Switch Profile", profile_menu),
         MenuItem("Exit", exit_program)
     )
@@ -295,7 +301,8 @@ def run_tray():
     menu = Menu(
         MenuItem("Open Settings", open_settings),
         MenuItem("Open Log", open_log),
-        MenuItem(get_obs_icon_text(), play_pause),
+        MenuItem("Toggle Replay Buffer", play_pause),
+        MenuItem("Restart OBS", restart_obs),
         MenuItem("Switch Profile", profile_menu),
         MenuItem("Exit", exit_program)
     )
@@ -303,24 +310,43 @@ def run_tray():
     icon = Icon("TrayApp", create_image(), "Game Sentence Miner", menu)
     icon.run()
 
+def close_obs():
+    if obs_process:
+        logger.info("Closing OBS")
+        obs_process.terminate()
+        obs_process.wait()
+
+def restart_obs():
+    global obs_process
+    close_obs()
+    time.sleep(2)
+    obs_process = obs.start_obs()
+    obs.connect_to_obs(start_replay=True)
 
 def cleanup():
     logger.info("Performing cleanup...")
     util.keep_running = False
 
-    for pid in config_pids:
+    if get_config().obs.enabled:
+        if get_config().obs.start_buffer:
+            obs.stop_replay_buffer()
+    obs.disconnect_from_obs()
+    close_obs()
+
+    proc: Popen
+    for proc in procs_to_close:
         try:
-            p = psutil.Process(pid)
-            p.terminate()  # Gracefully terminate the process
+            logger.info(f"Terminating process {proc.args[0]}")
+            proc.terminate()
+            proc.wait()  # Wait for OBS to fully close
+            logger.info(f"Process {proc.args[0]} terminated.")
         except psutil.NoSuchProcess:
-            logger.info("Config process already closed.")
+            logger.info("PID already closed.")
         except Exception as e:
-            logger.error(f"Error terminating process {pid}: {e}")
+            proc.kill()
+            logger.error(f"Error terminating process {proc}: {e}")
+
 
-    if get_config().obs.enabled:
-        if get_config().obs.start_buffer:
-            obs.stop_replay_buffer()
-        obs.disconnect_from_obs()
     settings_window.window.destroy()
     logger.info("Cleanup complete.")
 
@@ -340,6 +366,7 @@ def main(reloading=False, do_config_input=True):
     global settings_window
     logger.info("Script started.")
     initialize(reloading)
+    initial_checks()
     event_handler = VideoToAudioHandler()
     observer = Observer()
     observer.schedule(event_handler, get_config().paths.folder_to_watch, recursive=False)
@@ -360,6 +387,8 @@ def main(reloading=False, do_config_input=True):
         settings_window = config_gui.ConfigApp()
         if get_config().general.check_for_update_on_startup:
             settings_window.window.after(0, settings_window.check_update)
+        if get_config().general.open_config_on_startup:
+            settings_window.window.after(0, settings_window.show)
         settings_window.add_save_hook(update_icon)
         settings_window.window.mainloop()
     except KeyboardInterrupt:

{GameSentenceMiner → src}/notification.py

@@ -1,6 +1,8 @@
 import requests
 from plyer import notification
 
+from src.configuration import logger
+
 
 def open_anki_card(note_id):
     url = "http://localhost:8765"
@@ -17,11 +19,11 @@ def open_anki_card(note_id):
     try:
         response = requests.post(url, json=data, headers=headers)
         if response.status_code == 200:
-            print(f"Opened Anki note with ID {note_id}")
+            logger.info(f"Opened Anki note with ID {note_id}")
         else:
-            print(f"Failed to open Anki note with ID {note_id}")
+            logger.error(f"Failed to open Anki note with ID {note_id}")
     except Exception as e:
-        print(f"Error connecting to AnkiConnect: {e}")
+        logger.info(f"Error connecting to AnkiConnect: {e}")
 
 
 def send_notification(tango):

{GameSentenceMiner → src}/obs.py

@@ -1,18 +1,37 @@
+import subprocess
 import time
-from sys import platform
 
 from obswebsocket import obsws, requests
 
-from . import util
-from . import configuration
-from .configuration import *
-from .model import *
+from src import util, configuration
+from src.configuration import *
+from src.model import *
 
 client: obsws = None
 
 # REFERENCE: https://github.com/obsproject/obs-websocket/blob/master/docs/generated/protocol.md
 
 
+def get_obs_path():
+    return os.path.join(configuration.get_app_directory(), 'obs-studio/bin/64bit/obs64.exe')
+
+def start_obs():
+    obs_path = get_obs_path()
+    if not os.path.exists(obs_path):
+        logger.error(f"OBS not found at {obs_path}. Please install OBS.")
+        return None
+
+    try:
+        # process = subprocess.Popen([obs_path], cwd=os.path.dirname(obs_path))
+        # process = subprocess.Popen([obs_path, '--minimize-to-tray'], cwd=os.path.dirname(obs_path))
+        process = subprocess.Popen([obs_path, '--disable-shutdown-check'], cwd=os.path.dirname(obs_path))
+        logger.info("OBS launched")
+        return process
+    except Exception as e:
+        logger.error(f"Error launching OBS: {e}")
+        return None
+
+
 def get_obs_websocket_config_values():
     if platform == "win32":
         config_path = os.path.expanduser(r"~\AppData\Roaming\obs-studio\plugin_config\obs-websocket\config.json")
@@ -89,30 +108,43 @@ def disconnect_from_obs():
         logger.info("Disconnected from OBS WebSocket.")
 
 
+def toggle_replay_buffer():
+    try:
+        client.call(requests.ToggleReplayBuffer())
+        logger.info("Replay buffer Toggled.")
+    except Exception as e:
+        logger.error(f"Error toggling buffer: {e}")
+
+
 # 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}")
+        logger.error(f"Error starting replay buffer: {e}")
 
 
 # Stop replay buffer
 def stop_replay_buffer():
     try:
         client.call(requests.StopReplayBuffer())
-        print("Replay buffer stopped.")
+        logger.error("Replay buffer stopped.")
     except Exception as e:
-        print(f"Error stopping replay buffer: {e}")
+        logger.error(f"Error stopping replay buffer: {e}")
 
 
 # Save the current replay buffer
 def save_replay_buffer():
     try:
-        client.call(requests.SaveReplayBuffer())
+        replay_buffer_started = client.call(requests.GetReplayBufferStatus()).datain['outputActive']
+        if replay_buffer_started:
+            client.call(requests.SaveReplayBuffer())
+            logger.info("Replay buffer saved.")
+        else:
+            logger.error("Replay Buffer is not active, could not save Replay Buffer!")
     except Exception as e:
-        print(f"Error saving replay buffer: {e}")
+        logger.error(f"Error saving replay buffer: {e}")
 
 
 def get_current_scene():
@@ -121,7 +153,7 @@ def get_current_scene():
         scene_info = SceneInfo.from_dict(response.datain)
         return scene_info.sceneName
     except Exception as e:
-        print(f"Couldn't get scene: {e}")
+        logger.error(f"Couldn't get scene: {e}")
     return ''
 
 
@@ -129,27 +161,27 @@ 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}")
+        logger.error(f"Error getting source from scene: {e}")
         return ''
 
 
 def get_screenshot():
     try:
-        screenshot = util.make_unique_file_name(os.path.abspath(configuration.get_temporary_directory()) + '/screenshot.png')
+        screenshot = util.make_unique_file_name(os.path.abspath(
+            configuration.get_temporary_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.")
+            logger.error("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}")
+        logger.error(f"Error getting screenshot: {e}")
 
 
 def update_current_game():

{GameSentenceMiner → src}/package_updater.py

@@ -5,7 +5,7 @@ import sys
 import pyperclip
 import requests
 
-from .configuration import logger, get_app_directory
+from src.configuration import logger, get_app_directory
 
 PACKAGE_NAME = "GameSentenceMiner"
 VERSION_FILE_PATH = os.path.join(get_app_directory(), 'version.txt')

{GameSentenceMiner → src}/util.py

@@ -9,6 +9,8 @@ from sys import platform
 
 from rapidfuzz import process
 
+from src.configuration import logger
+
 SCRIPTS_DIR = r"E:\Japanese Stuff\agent-v0.1.4-win32-x64\data\scripts"
 
 # Global variables to control script execution
@@ -56,7 +58,7 @@ def get_file_modification_time(file_path):
 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}")
+    logger.info(f"Process ID for {game_title}: {process_id}")
     return process_id
 
 
@@ -101,21 +103,21 @@ def find_script_for_game(game_title):
     best_script, matched_game_name, confidence = find_most_similar_script(game_title, steam_scripts)
 
     if best_script:
-        print(f"Found Script: {best_script}")
+        logger.info(f"Found Script: {best_script}")
         return best_script
     else:
-        print("No similar script found.")
+        logger.warning("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!")
+    logger.info("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.")
+        logger.info("Agent script finished or closed.")
     except Exception as e:
-        print(f"Error occurred while running agent script: {e}")
+        logger.error(f"Error occurred while running agent script: {e}")
 
     keep_running = False
 
@@ -123,6 +125,9 @@ def run_agent_and_hook(pname, agent_script):
 def is_linux():
     return platform == 'linux'
 
+def is_windows():
+    return platform == 'win32'
+
 # 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():

{GameSentenceMiner → src}/vad/silero_trim.py

@@ -2,8 +2,8 @@ import tempfile
 
 from silero_vad import load_silero_vad, read_audio, get_speech_timestamps
 
-from .. import configuration, ffmpeg
-from ..configuration import *
+from src  import configuration, ffmpeg
+from src.configuration import *
 
 # Silero VAD setup
 vad_model = load_silero_vad()

{GameSentenceMiner → src}/vad/vosk_helper.py

@@ -7,8 +7,8 @@ import requests
 import soundfile as sf
 import vosk
 
-from .. import ffmpeg, configuration
-from ..configuration import *
+from src  import configuration, ffmpeg
+from src.configuration import *
 
 ffmpeg_base_command_list = ["ffmpeg", "-hide_banner", "-loglevel", "error"]
 vosk.SetLogLevel(-1)

{GameSentenceMiner → src}/vad/whisper_helper.py

@@ -4,8 +4,8 @@ import warnings
 import stable_whisper as whisper
 from stable_whisper import WhisperResult
 
-from .. import ffmpeg, configuration
-from ..configuration import *
+from src  import configuration, ffmpeg
+from src.configuration import *
 
 ffmpeg_base_command_list = ["ffmpeg", "-hide_banner", "-loglevel", "error"]
 whisper_model = None