GameSentenceMiner 2.2.0__tar.gz → 2.2.2__tar.gz

{gamesentenceminer-2.2.0/src → gamesentenceminer-2.2.2/GameSentenceMiner}/anki.py

@@ -6,12 +6,12 @@ import urllib.request
 
 import requests as req
 
-from src import obs, util, notification, ffmpeg
+from GameSentenceMiner import obs, util, notification, ffmpeg
 
-from src.configuration import *
-from src.configuration import get_config
-from src.gametext import get_last_two_sentences
-from src.obs import get_current_game
+from GameSentenceMiner.configuration import *
+from GameSentenceMiner.configuration import get_config
+from GameSentenceMiner.gametext import get_last_two_sentences
+from GameSentenceMiner.obs import get_current_game
 
 audio_in_anki = None
 screenshot_in_anki = None
@@ -168,15 +168,15 @@ def get_cards_by_sentence(sentence):
     card_ids = invoke("findCards", query=query)
 
     if not card_ids:
-        print(f"Didn't find any cards matching query:\n{query}")
+        logger.warning(f"Didn't find any cards matching query:\n{query}")
         return {}
     if len(card_ids) > 1:
-        print(f'Found more than 1, and not updating cards for query: \n{query}')
+        logger.warning(f'Found more than 1, and not updating cards for query: \n{query}')
         return {}
 
     last_notes = invoke('notesInfo', notes=[card_ids[0]])[0]
 
-    print(f"Found Card to backfill!: {card_ids[0]}")
+    logger.info(f"Found Card to backfill!: {card_ids[0]}")
 
     return last_notes
 
@@ -188,7 +188,7 @@ def check_for_new_cards():
     try:
         current_note_ids = get_note_ids()
     except Exception as e:
-        print(f"Error fetching Anki notes: {e}")
+        logger.error(f"Error fetching Anki notes: {e}")
         return
     new_card_ids = current_note_ids - previous_note_ids
     if new_card_ids and not first_run:
@@ -205,16 +205,16 @@ def update_new_card():
 
     use_prev_audio = util.use_previous_audio
     if util.lock.locked():
-        print("Audio still being Trimmed, Card Queued!")
+        logger.info("Audio still being Trimmed, Card Queued!")
         use_prev_audio = True
     with util.lock:
-        print(f"use previous audio: {use_prev_audio}")
+        logger.info(f"use previous audio: {use_prev_audio}")
         if get_config().obs.get_game_from_scene:
             obs.update_current_game()
         if use_prev_audio:
             update_anki_card(last_card, note=get_initial_card_info(last_card), reuse_audio=True)
         else:
-            print("New card(s) detected!")
+            logger.info("New card(s) detected!")
             obs.save_replay_buffer()
 
 

{gamesentenceminer-2.2.0/src → gamesentenceminer-2.2.2/GameSentenceMiner}/config_gui.py

@@ -3,9 +3,9 @@ from tkinter import filedialog, messagebox, simpledialog
 
 import ttkbootstrap as ttk
 
-from src.package_updater import check_for_updates, get_latest_version, update, get_current_version
-from src import obs, configuration
-from src.configuration import *
+from GameSentenceMiner.package_updater import check_for_updates, get_latest_version, update, get_current_version
+from GameSentenceMiner import obs, configuration
+from GameSentenceMiner.configuration import *
 
 settings_saved = False
 on_save = []

{gamesentenceminer-2.2.0/src → gamesentenceminer-2.2.2/GameSentenceMiner}/configuration.py

@@ -305,13 +305,11 @@ def load_config():
                     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}")
+            logger.error(f"Error parsing config.json: {e}")
             return None
     elif os.path.exists('config.toml'):
         config = ProfileConfig().load_from_toml('config.toml')
@@ -334,7 +332,7 @@ def get_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!")
+            logger.error("Cannot have backfill_audio and obs_full_auto_mode turned on at the same time!")
             exit(1)
 
     # print(config_instance.get_config())

{gamesentenceminer-2.2.0/src → gamesentenceminer-2.2.2/GameSentenceMiner}/downloader/download_tools.py

@@ -6,8 +6,8 @@ import urllib.request
 import platform
 import zipfile
 
-from src.downloader.Untitled_json import scenes
-from src.configuration import get_app_directory, logger
+from GameSentenceMiner.downloader.Untitled_json import scenes
+from GameSentenceMiner.configuration import get_app_directory, logger
 
 script_dir = os.path.dirname(os.path.abspath(__file__))
 

{gamesentenceminer-2.2.0/src → gamesentenceminer-2.2.2/GameSentenceMiner}/ffmpeg.py

@@ -2,13 +2,16 @@ import subprocess
 import tempfile
 import time
 
-from src import obs, util, configuration
-from src.configuration import *
-from src.util import *
+from GameSentenceMiner import obs, util, configuration
+from GameSentenceMiner.configuration import *
+from GameSentenceMiner.util import *
 
 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']
 
 
@@ -90,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",
@@ -151,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

{gamesentenceminer-2.2.0/src → gamesentenceminer-2.2.2/GameSentenceMiner}/gametext.py

@@ -7,10 +7,10 @@ from datetime import datetime
 import pyperclip
 import websockets
 
-from src import util
-from src.configuration import *
-from src.configuration import get_config, logger
-from src.util import remove_html_tags
+from GameSentenceMiner import util
+from GameSentenceMiner.configuration import *
+from GameSentenceMiner.configuration import get_config, logger
+from GameSentenceMiner.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-2.2.0/src → gamesentenceminer-2.2.2/GameSentenceMiner}/gsm.py

@@ -12,20 +12,20 @@ from pystray import Icon, Menu, MenuItem
 from watchdog.events import FileSystemEventHandler
 from watchdog.observers import Observer
 
-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 *
+from GameSentenceMiner import anki
+from GameSentenceMiner import config_gui
+from GameSentenceMiner import configuration
+from GameSentenceMiner import ffmpeg
+from GameSentenceMiner import gametext
+from GameSentenceMiner import notification
+from GameSentenceMiner import obs
+from GameSentenceMiner import util
+from GameSentenceMiner.downloader.download_tools import download_obs_if_needed, download_ffmpeg_if_needed
+from GameSentenceMiner.vad import vosk_helper, silero_trim, whisper_helper
+from GameSentenceMiner.configuration import *
+from GameSentenceMiner.ffmpeg import get_audio_and_trim
+from GameSentenceMiner.gametext import get_line_timing
+from GameSentenceMiner.util import *
 
 obs_process: Popen
 procs_to_close = []
@@ -100,8 +100,7 @@ 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}", exc_info=1)
         if get_config().paths.remove_video and os.path.exists(video_path):
@@ -232,7 +231,7 @@ def open_log():
     """Open log file with the default application."""
     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
@@ -242,13 +241,13 @@ 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()
 

{gamesentenceminer-2.2.0/src → gamesentenceminer-2.2.2/GameSentenceMiner}/notification.py

@@ -1,6 +1,8 @@
 import requests
 from plyer import notification
 
+from GameSentenceMiner.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-2.2.0/src → gamesentenceminer-2.2.2/GameSentenceMiner}/obs.py

@@ -3,9 +3,9 @@ import time
 
 from obswebsocket import obsws, requests
 
-from src import util, configuration
-from src.configuration import *
-from src.model import *
+from GameSentenceMiner import util, configuration
+from GameSentenceMiner.configuration import *
+from GameSentenceMiner.model import *
 
 client: obsws = None
 
@@ -33,15 +33,7 @@ def start_obs():
 
 
 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")
-    elif platform == "darwin":  # macOS
-        config_path = os.path.expanduser(
-            "~/Library/Application Support/obs-studio/plugin_config/obs-websocket/config.json")
-    elif platform == "linux":
-        config_path = os.path.expanduser("~/.config/obs-studio/plugin_config/obs-websocket/config.json")
-    else:
-        raise Exception("Unsupported operating system.")
+    config_path = os.path.join(get_app_directory(), 'obs-studio', 'config', 'obs-studio', 'plugin_config', 'obs-websocket', 'config.json')
 
         # Check if config file exists
     if not os.path.isfile(config_path):
@@ -111,9 +103,9 @@ def disconnect_from_obs():
 def toggle_replay_buffer():
     try:
         client.call(requests.ToggleReplayBuffer())
-        print("Replay buffer Toggled.")
+        logger.info("Replay buffer Toggled.")
     except Exception as e:
-        print(f"Error toggling buffer: {e}")
+        logger.error(f"Error toggling buffer: {e}")
 
 
 # Start replay buffer
@@ -122,16 +114,16 @@ def start_replay_buffer():
         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
@@ -144,7 +136,7 @@ def save_replay_buffer():
         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():
@@ -153,7 +145,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 ''
 
 
@@ -161,10 +153,9 @@ 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 ''
 
 
@@ -176,13 +167,13 @@ def get_screenshot():
         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-2.2.0/src → gamesentenceminer-2.2.2/GameSentenceMiner}/package_updater.py

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

{gamesentenceminer-2.2.0/src → gamesentenceminer-2.2.2/GameSentenceMiner}/util.py

@@ -9,6 +9,8 @@ from sys import platform
 
 from rapidfuzz import process
 
+from GameSentenceMiner.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
 
 
@@ -100,22 +102,23 @@ 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
 

{gamesentenceminer-2.2.0/src → gamesentenceminer-2.2.2/GameSentenceMiner}/vad/silero_trim.py

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

{gamesentenceminer-2.2.0/src → gamesentenceminer-2.2.2/GameSentenceMiner}/vad/vosk_helper.py

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

{gamesentenceminer-2.2.0/src → gamesentenceminer-2.2.2/GameSentenceMiner}/vad/whisper_helper.py

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