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

GameSentenceMiner/ai/ai_prompting.py

@@ -3,14 +3,14 @@ import textwrap
 from abc import ABC, abstractmethod
 from dataclasses import dataclass
 from enum import Enum
-from typing import List, Any, Optional
+from typing import List, Optional
 
 import google.generativeai as genai
 from google.generativeai import GenerationConfig
 from groq import Groq
 
-from GameSentenceMiner.configuration import get_config, Ai, logger
-from GameSentenceMiner.text_log import GameLine
+from GameSentenceMiner.util.configuration import get_config, Ai, logger
+from GameSentenceMiner.util.text_log import GameLine
 
 # Suppress debug logs from httpcore
 logging.getLogger("httpcore").setLevel(logging.WARNING)

GameSentenceMiner/anki.py

@@ -2,19 +2,19 @@ import time
 
 import base64
 import subprocess
-import threading
 import urllib.request
 from datetime import datetime, timedelta
 from requests import post
 
-from GameSentenceMiner import obs, util, notification, ffmpeg
+from GameSentenceMiner import obs
 from GameSentenceMiner.ai.ai_prompting import get_ai_prompt_result
-from GameSentenceMiner.configuration import *
-from GameSentenceMiner.configuration import get_config
-from GameSentenceMiner.model import AnkiCard
-from GameSentenceMiner.text_log import get_all_lines, get_text_event, get_mined_line
+from GameSentenceMiner.util.gsm_utils import wait_for_stable_file, remove_html_and_cloze_tags, combine_dialogue
+from GameSentenceMiner.util import ffmpeg, notification
+from GameSentenceMiner.util.configuration import *
+from GameSentenceMiner.util.configuration import get_config
+from GameSentenceMiner.util.model import AnkiCard
+from GameSentenceMiner.util.text_log import get_all_lines, get_text_event, get_mined_line
 from GameSentenceMiner.obs import get_current_game
-from GameSentenceMiner.util import remove_html_and_cloze_tags, combine_dialogue, wait_for_stable_file
 from GameSentenceMiner.web import texthooking_page
 
 audio_in_anki = None
@@ -82,8 +82,9 @@ def update_anki_card(last_note: AnkiCard, note=None, audio_path='', video_path='
         for key, value in get_config().anki.anki_custom_fields.items():
             note['fields'][key] = str(value)
 
-
-    notification.open_browser_window(1)
+    selected_notes = invoke("guiSelectedNotes")
+    if last_note.noteId in selected_notes:
+        notification.open_browser_window(1)
     invoke("updateNoteFields", note=note)
     tags = []
     if get_config().anki.custom_tags:
@@ -96,7 +97,8 @@ def update_anki_card(last_note: AnkiCard, note=None, audio_path='', video_path='
     logger.info(f"UPDATED ANKI CARD FOR {last_note.noteId}")
     if get_config().features.notify_on_update:
         notification.send_note_updated(tango)
-    notification.open_browser_window(last_note.noteId)
+    if last_note.noteId in selected_notes or get_config().features.open_anki_in_browser:
+        notification.open_browser_window(last_note.noteId, get_config().features.browser_query)
     if get_config().features.open_anki_edit:
         notification.open_anki_card(last_note.noteId)
 
@@ -282,13 +284,13 @@ def update_new_card():
     if not last_card or not check_tags_for_should_update(last_card):
         return
     use_prev_audio = sentence_is_same_as_previous(last_card)
-    logger.debug(f"last mined line: {util.get_last_mined_line()}, current sentence: {get_sentence(last_card)}")
+    logger.debug(f"last mined line: {gsm_state.last_mined_line}, current sentence: {get_sentence(last_card)}")
     logger.info(f"New card using previous audio: {use_prev_audio}")
     if get_config().obs.get_game_from_scene:
         obs.update_current_game()
     if use_prev_audio:
         lines = texthooking_page.get_selected_lines()
-        with util.lock:
+        with gsm_state.lock:
             update_anki_card(last_card, note=get_initial_card_info(last_card, lines), game_line=get_mined_line(last_card, lines), reuse_audio=True)
         texthooking_page.reset_checked_lines()
     else:
@@ -303,9 +305,9 @@ def update_new_card():
 
 
 def sentence_is_same_as_previous(last_card):
-    if not util.get_last_mined_line():
+    if not gsm_state.last_mined_line:
         return False
-    return remove_html_and_cloze_tags(get_sentence(last_card)) == remove_html_and_cloze_tags(util.get_last_mined_line())
+    return remove_html_and_cloze_tags(get_sentence(last_card)) == remove_html_and_cloze_tags(gsm_state.last_mined_line)
 
 def get_sentence(card):
     return card.get_field(get_config().anki.sentence_field)

GameSentenceMiner/config_gui.py

@@ -4,12 +4,12 @@ from tkinter import filedialog, messagebox, simpledialog, scrolledtext
 
 import ttkbootstrap as ttk
 
-from GameSentenceMiner import obs, configuration
-from GameSentenceMiner.communication.send import send_restart_signal
-from GameSentenceMiner.configuration import *
-from GameSentenceMiner.downloader.download_tools import download_ocenaudio_if_needed
-from GameSentenceMiner.model import SceneItem, SceneInfo
-from GameSentenceMiner.package import get_current_version, get_latest_version
+from GameSentenceMiner import obs
+from GameSentenceMiner.util import configuration
+from GameSentenceMiner.util.communication.send import send_restart_signal
+from GameSentenceMiner.util.configuration import *
+from GameSentenceMiner.util.downloader.download_tools import download_ocenaudio_if_needed
+from GameSentenceMiner.util.package import get_current_version, get_latest_version
 
 settings_saved = False
 on_save = []
@@ -172,7 +172,9 @@ class ConfigApp:
                 full_auto=self.full_auto.get(),
                 notify_on_update=self.notify_on_update.get(),
                 open_anki_edit=self.open_anki_edit.get(),
-                backfill_audio=self.backfill_audio.get()
+                open_anki_in_browser=self.open_anki_browser.get(),
+                backfill_audio=self.backfill_audio.get(),
+                browser_query=self.browser_query.get(),
             ),
             screenshot=Screenshot(
                 enabled=self.screenshot_enabled.get(),
@@ -753,6 +755,19 @@ class ConfigApp:
         self.add_label_and_increment_row(features_frame, "Automatically open Anki for editing after updating.",
                                          row=self.current_row, column=2)
 
+        ttk.Label(features_frame, text="Open Anki Note in Browser:").grid(row=self.current_row, column=0, sticky='W')
+        self.open_anki_browser = tk.BooleanVar(value=self.settings.features.open_anki_in_browser)
+        ttk.Checkbutton(features_frame, variable=self.open_anki_browser).grid(row=self.current_row, column=1, sticky='W')
+        self.add_label_and_increment_row(features_frame, "Open Anki note in browser after updating.", row=self.current_row,
+                                            column=2)
+
+        ttk.Label(features_frame, text="Browser Query:").grid(row=self.current_row, column=0, sticky='W')
+        self.browser_query = ttk.Entry(features_frame, width=50)
+        self.browser_query.insert(0, self.settings.features.browser_query)
+        self.browser_query.grid(row=self.current_row, column=1)
+        self.add_label_and_increment_row(features_frame, "Query to use when opening Anki notes in the browser. Ex: 'Added:1'", row=self.current_row,
+                                            column=2)
+
         ttk.Label(features_frame, text="Backfill Audio:").grid(row=self.current_row, column=0, sticky='W')
         self.backfill_audio = tk.BooleanVar(value=self.settings.features.backfill_audio)
         ttk.Checkbutton(features_frame, variable=self.backfill_audio).grid(row=self.current_row, column=1, sticky='W')

GameSentenceMiner/gametext.py

@@ -6,9 +6,9 @@ import websockets
 from websockets import InvalidStatus
 
 from GameSentenceMiner import util
-from GameSentenceMiner.configuration import *
-from GameSentenceMiner.text_log import *
-from GameSentenceMiner.util import do_text_replacements, TEXT_REPLACEMENTS_FILE
+from GameSentenceMiner.util.gsm_utils import do_text_replacements, TEXT_REPLACEMENTS_FILE, run_new_thread
+from GameSentenceMiner.util.configuration import *
+from GameSentenceMiner.util.text_log import *
 
 from GameSentenceMiner.web.texthooking_page import add_event_to_texthooker
 
@@ -121,7 +121,7 @@ def reset_line_hotkey_pressed():
     global current_line_time
     logger.info("LINE RESET HOTKEY PRESSED")
     current_line_time = datetime.now()
-    util.set_last_mined_line("")
+    gsm_state.last_mined_line = ""
 
 
 def run_websocket_listener():
@@ -129,7 +129,7 @@ def run_websocket_listener():
 
 
 async def start_text_monitor():
-    util.run_new_thread(run_websocket_listener)
+    run_new_thread(run_websocket_listener)
     if get_config().general.use_websocket:
         if get_config().general.use_both_clipboard_and_websocket:
             logger.info("Listening for Text on both WebSocket and Clipboard.")

GameSentenceMiner/gsm.py

@@ -1,7 +1,12 @@
 import asyncio
+import subprocess
 import sys
+import threading
 
-from GameSentenceMiner.vad.result import VADResult
+from GameSentenceMiner.util.gsm_utils import wait_for_stable_file, make_unique_file_name, run_new_thread
+from GameSentenceMiner.util.communication.send import send_restart_signal
+from GameSentenceMiner.util.downloader.download_tools import download_obs_if_needed, download_ffmpeg_if_needed
+from GameSentenceMiner.vad import vad_processor, VADResult
 
 try:
     import os.path
@@ -19,26 +24,21 @@ try:
 
     from GameSentenceMiner import anki
     from GameSentenceMiner import config_gui
-    from GameSentenceMiner import configuration
-    from GameSentenceMiner import ffmpeg
+    from GameSentenceMiner.util import configuration, notification, ffmpeg
     from GameSentenceMiner import gametext
-    from GameSentenceMiner import notification
     from GameSentenceMiner import obs
-    from GameSentenceMiner import util
-    from GameSentenceMiner.communication import Message
-    from GameSentenceMiner.communication.send import send_restart_signal
-    from GameSentenceMiner.communication.websocket import connect_websocket, register_websocket_message_handler, \
+    from GameSentenceMiner.util.communication import Message
+    from GameSentenceMiner.util.communication.websocket import connect_websocket, register_websocket_message_handler, \
         FunctionName
-    from GameSentenceMiner.configuration import *
-    from GameSentenceMiner.downloader.download_tools import download_obs_if_needed, download_ffmpeg_if_needed
-    from GameSentenceMiner.ffmpeg import get_audio_and_trim, get_video_timings
+    from GameSentenceMiner.util.configuration import *
+    from GameSentenceMiner.util.ffmpeg import get_audio_and_trim, get_video_timings
     from GameSentenceMiner.obs import check_obs_folder_is_correct
-    from GameSentenceMiner.text_log import GameLine, get_text_event, get_mined_line, get_all_lines
+    from GameSentenceMiner.util.text_log import GameLine, get_text_event, get_mined_line, get_all_lines
     from GameSentenceMiner.util import *
     from GameSentenceMiner.web import texthooking_page
     from GameSentenceMiner.web.texthooking_page import run_text_hooker_page
 except Exception as e:
-    from GameSentenceMiner.configuration import logger, is_linux, is_windows
+    from GameSentenceMiner.util.configuration import logger, is_linux, is_windows
     import time
     logger.info("Something bad happened during import/initialization, closing in 5 seconds")
     logger.exception(e)
@@ -48,7 +48,6 @@ except Exception as e:
 if is_windows():
     import win32api
 
-silero_trim, whisper_helper, vosk_helper = None, None, None
 procs_to_close = []
 settings_window: config_gui.ConfigApp = None
 obs_paused = False
@@ -87,11 +86,10 @@ class VideoToAudioHandler(FileSystemEventHandler):
             else:
                 logger.info("Replay buffer initiated externally. Skipping processing.")
                 return
-            with util.lock:
-                util.set_last_mined_line(anki.get_sentence(last_note))
+            with gsm_state.lock:
+                gsm_state.last_mined_line = anki.get_sentence(last_note)
                 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")
@@ -212,7 +210,6 @@ class VideoToAudioHandler(FileSystemEventHandler):
 
     @staticmethod
     def get_audio(game_line, next_line_time, video_path, anki_card_creation_time=None, temporary=False, timing_only=False, mined_line=None):
-        logger.info("Getting audio from video...")
         trimmed_audio = get_audio_and_trim(video_path, game_line, next_line_time, anki_card_creation_time)
         if temporary:
             return trimmed_audio
@@ -220,47 +217,16 @@ class VideoToAudioHandler(FileSystemEventHandler):
             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(os.path.join(get_config().paths.audio_destination,
                                                                 f"{obs.get_current_game(sanitize=True)}.{get_config().audio.extension}"))
-        result = VADResult(False, 0, 0, "")
-        if get_config().vad.do_vad_postprocessing:
-            result = do_vad_processing(get_config().vad.selected_vad_model, trimmed_audio, vad_trimmed_audio, game_line=mined_line)
-            if not result.success:
-                result = do_vad_processing(get_config().vad.selected_vad_model, trimmed_audio,
-                                                        vad_trimmed_audio, game_line=mined_line)
-            if not result.success:
-                if get_config().vad.add_audio_on_no_results:
-                    logger.info("No voice activity detected, using full audio.")
-                    vad_trimmed_audio = trimmed_audio
-                else:
-                    logger.info("No voice activity detected.")
-                    return None, result, None
-            else:
-                logger.info(result.trim_successful_string())
+
+        vad_result = vad_processor.trim_audio_with_vad(trimmed_audio, vad_trimmed_audio, game_line)
         if timing_only:
-            return result
+            return vad_result
         if get_config().audio.ffmpeg_reencode_options and os.path.exists(vad_trimmed_audio):
             ffmpeg.reencode_file_with_user_config(vad_trimmed_audio, final_audio_output,
                                                   get_config().audio.ffmpeg_reencode_options)
         elif os.path.exists(vad_trimmed_audio):
             shutil.move(vad_trimmed_audio, final_audio_output)
-        return final_audio_output, result, vad_trimmed_audio
-
-
-def do_vad_processing(model, trimmed_audio, vad_trimmed_audio, game_line=None, second_pass=False):
-    match model:
-        case configuration.OFF:
-            pass
-        case configuration.GROQ:
-            from GameSentenceMiner.vad import groq_trim
-            return groq_trim.process_audio_with_groq(trimmed_audio, vad_trimmed_audio, game_line)
-        case configuration.SILERO:
-            from GameSentenceMiner.vad import silero_trim
-            return silero_trim.process_audio_with_silero(trimmed_audio, vad_trimmed_audio, game_line)
-        case configuration.VOSK:
-            from GameSentenceMiner.vad import vosk_helper
-            return vosk_helper.process_audio_with_vosk(trimmed_audio, vad_trimmed_audio, game_line)
-        case configuration.WHISPER:
-            from GameSentenceMiner.vad import whisper_helper
-            return whisper_helper.process_audio_with_whisper(trimmed_audio, vad_trimmed_audio, game_line)
+        return final_audio_output, vad_result, vad_trimmed_audio
 
 
 def play_audio_in_external(filepath):
@@ -535,7 +501,7 @@ def restart_obs():
 
 def cleanup():
     logger.info("Performing cleanup...")
-    util.keep_running = False
+    gsm_state.keep_running = False
 
     if get_config().obs.enabled:
         obs.stop_replay_buffer()
@@ -567,7 +533,7 @@ def cleanup():
 def handle_exit():
     """Signal handler for graceful termination."""
 
-    def _handle_exit(signum):
+    def _handle_exit(signum, *args):
         logger.info(f"Received signal {signum}. Exiting gracefully...")
         cleanup()
         sys.exit(0)
@@ -602,7 +568,7 @@ def initialize_async():
     threads = []
     tasks.append(anki.start_monitoring_anki)
     for task in tasks:
-        threads.append(util.run_new_thread(task))
+        threads.append(run_new_thread(task))
     return threads
 
 def handle_websocket_message(message: Message):
@@ -640,14 +606,7 @@ def async_loop():
             await register_scene_switcher_callback()
             await check_obs_folder_is_correct()
         logger.info("Post-Initialization started.")
-        if get_config().vad.is_vosk():
-            from GameSentenceMiner.vad import vosk_helper
-            vosk_helper.get_vosk_model()
-        if get_config().vad.is_whisper():
-            from GameSentenceMiner.vad import whisper_helper
-            whisper_helper.initialize_whisper_model()
-        if get_config().vad.is_silero():
-            from GameSentenceMiner.vad import silero_trim
+        vad_processor.init()
 
     asyncio.run(loop())
 
@@ -693,9 +652,9 @@ async def async_main(reloading=False):
     if not is_linux():
         register_hotkeys()
 
-    util.run_new_thread(post_init2)
-    util.run_new_thread(run_text_hooker_page)
-    util.run_new_thread(async_loop)
+    run_new_thread(post_init2)
+    run_new_thread(run_text_hooker_page)
+    run_new_thread(async_loop)
 
     # Register signal handlers for graceful shutdown
     signal.signal(signal.SIGTERM, handle_exit())  # Handle `kill` commands

GameSentenceMiner/obs.py

@@ -7,10 +7,9 @@ import psutil
 
 import obsws_python as obs
 
-import GameSentenceMiner.configuration
-from GameSentenceMiner import util, configuration
-from GameSentenceMiner.configuration import *
-from GameSentenceMiner.model import *
+from GameSentenceMiner.util import configuration
+from GameSentenceMiner.util.configuration import *
+from GameSentenceMiner.util.gsm_utils import sanitize_filename, make_unique_file_name
 
 client: obs.ReqClient = None
 event_client: obs.EventClient = None
@@ -140,7 +139,7 @@ async def connect_to_obs(retry_count=0):
     if not get_config().obs.enabled:
         return
 
-    if GameSentenceMiner.configuration.is_windows():
+    if is_windows():
         get_obs_websocket_config_values()
 
     while True:
@@ -174,7 +173,7 @@ def connect_to_obs_sync(retry_count=0):
     if not get_config().obs.enabled or client:
         return
 
-    if GameSentenceMiner.configuration.is_windows():
+    if is_windows():
         get_obs_websocket_config_values()
 
     while True:
@@ -314,7 +313,7 @@ async def register_scene_change_callback(callback):
 
 def get_screenshot(compression=-1):
     try:
-        screenshot = util.make_unique_file_name(os.path.abspath(
+        screenshot = make_unique_file_name(os.path.abspath(
             configuration.get_temporary_directory()) + '/screenshot.png')
         update_current_game()
         if not configuration.current_game:
@@ -367,7 +366,7 @@ def get_current_game(sanitize=False):
         update_current_game()
 
     if sanitize:
-        return util.sanitize_filename(configuration.current_game)
+        return sanitize_filename(configuration.current_game)
     return configuration.current_game
 
 

GameSentenceMiner/ocr/owocr_area_selector.py

@@ -9,7 +9,7 @@ from PIL import Image, ImageTk, ImageDraw
 
 from GameSentenceMiner import obs  # Import your actual obs module
 from GameSentenceMiner.ocr.gsm_ocr_config import set_dpi_awareness
-from GameSentenceMiner.util import sanitize_filename  # Import your actual util module
+from GameSentenceMiner.util.gsm_utils import sanitize_filename
 
 try:
     import pygetwindow as gw

GameSentenceMiner/ocr/owocr_helper.py

@@ -1,10 +1,8 @@
 import asyncio
-import ctypes
 import json
 import logging
 import os
 import queue
-import re
 import threading
 import time
 from datetime import datetime
@@ -16,13 +14,12 @@ import mss
 import websockets
 from rapidfuzz import fuzz
 
-from GameSentenceMiner import obs, util
-from GameSentenceMiner.configuration import get_config, get_app_directory, get_temporary_directory
-from GameSentenceMiner.electron_config import get_ocr_scan_rate, get_requires_open_window
-from GameSentenceMiner.ocr.gsm_ocr_config import OCRConfig, Rectangle, set_dpi_awareness
+from GameSentenceMiner import obs
+from GameSentenceMiner.util.configuration import get_config, get_app_directory, get_temporary_directory
+from GameSentenceMiner.util.electron_config import get_ocr_scan_rate, get_requires_open_window
+from GameSentenceMiner.ocr.gsm_ocr_config import OCRConfig, set_dpi_awareness
 from GameSentenceMiner.owocr.owocr import screen_coordinate_picker, run
-from GameSentenceMiner.owocr.owocr.run import TextFiltering
-from GameSentenceMiner.util import do_text_replacements, OCR_REPLACEMENTS_FILE
+from GameSentenceMiner.util.gsm_utils import sanitize_filename, do_text_replacements, OCR_REPLACEMENTS_FILE
 
 CONFIG_FILE = Path("ocr_config.json")
 DEFAULT_IMAGE_PATH = r"C:\Users\Beangate\Pictures\msedge_acbl8GL7Ax.jpg"  # CHANGE THIS
@@ -66,7 +63,7 @@ def get_new_game_cords():
     ocr_config_dir = app_dir / "ocr_config"
     ocr_config_dir.mkdir(parents=True, exist_ok=True)
     obs.connect_to_obs_sync()
-    scene = util.sanitize_filename(obs.get_current_scene())
+    scene = sanitize_filename(obs.get_current_scene())
     config_path = ocr_config_dir / f"{scene}.json"
     with open(config_path, 'w') as f:
         json.dump({"scene": scene, "window": None, "rectangles": coords_list}, f, indent=4)
@@ -80,7 +77,7 @@ def get_ocr_config() -> OCRConfig:
     ocr_config_dir = app_dir / "ocr_config"
     os.makedirs(ocr_config_dir, exist_ok=True)
     obs.connect_to_obs_sync()
-    scene = util.sanitize_filename(obs.get_current_scene())
+    scene = sanitize_filename(obs.get_current_scene())
     config_path = ocr_config_dir / f"{scene}.json"
     if not config_path.exists():
         config_path.touch()
@@ -214,11 +211,11 @@ def do_second_ocr(ocr1_text, time, img, filtering, scrolling=False):
                                                         engine=ocr2)
         if scrolling:
             return text
-        if fuzz.ratio(last_ocr2_result, orig_text) >= 80:
+        if fuzz.ratio(last_ocr2_result, text) >= 80:
             logger.info("Seems like the same text from previous ocr2 result, not sending")
             return
         save_result_image(img)
-        last_ocr2_result = orig_text
+        last_ocr2_result = text
         asyncio.run(send_result(text, time))
     except json.JSONDecodeError:
         print("Invalid JSON received.")
@@ -289,13 +286,15 @@ def text_callback(text, orig_text, time, img=None, came_from_ss=False, filtering
             previous_img_local = previous_img
             if previous_text and fuzz.ratio(orig_text_string, previous_orig_text) >= 90:
                 logger.info("Seems like Text we already sent, not doing anything.")
+                previous_text = None
                 return
             previous_orig_text = orig_text_string
             previous_ocr1_result = previous_text
             if crop_coords:
                 previous_img_local.save(os.path.join(get_temporary_directory(), "pre_oneocrcrop.png"))
                 previous_img_local = previous_img_local.crop(crop_coords)
-            do_second_ocr(previous_text, stable_time, previous_img_local, filtering)
+            second_ocr_queue.put((previous_text, stable_time, previous_img_local, filtering))
+            # threading.Thread(target=do_second_ocr, args=(previous_text, stable_time, previous_img_local, filtering), daemon=True).start()
             previous_img = None
             previous_text = None
             text_stable_start_time = None
@@ -312,6 +311,22 @@ def text_callback(text, orig_text, time, img=None, came_from_ss=False, filtering
 
 done = False
 
+# Create a queue for tasks
+second_ocr_queue = queue.Queue()
+
+def process_task_queue():
+    while True:
+        try:
+            task = second_ocr_queue.get()
+            if task is None:  # Exit signal
+                break
+            ocr1_text, stable_time, previous_img_local, filtering = task
+            do_second_ocr(ocr1_text, stable_time, previous_img_local, filtering)
+        except Exception as e:
+            logger.exception(f"Error processing task: {e}")
+        finally:
+            second_ocr_queue.task_done()
+
 
 def run_oneocr(ocr_config: OCRConfig, rectangles):
     global done
@@ -420,6 +435,8 @@ if __name__ == "__main__":
         ocr_thread = threading.Thread(target=run_oneocr, args=(ocr_config,rectangles ), daemon=True)
         ocr_thread.start()
         if not ssonly:
+            worker_thread = threading.Thread(target=process_task_queue, daemon=True)
+            worker_thread.start()
             websocket_server_thread = WebsocketServerThread(read=True)
             websocket_server_thread.start()
         try:

GameSentenceMiner/owocr/owocr/ocr.py

@@ -17,8 +17,6 @@ from google.generativeai import GenerationConfig
 from loguru import logger
 import requests
 
-from ...configuration import get_temporary_directory
-
 try:
     from manga_ocr import MangaOcr as MOCR
 except ImportError:

GameSentenceMiner/owocr/owocr/run.py

@@ -55,7 +55,7 @@ except ImportError:
     pass
 from .config import Config
 from .screen_coordinate_picker import get_screen_selection
-from ...configuration import get_temporary_directory, get_app_directory
+from GameSentenceMiner.util.configuration import get_temporary_directory
 
 config = None
 

GameSentenceMiner/{communication → util/communication}/__init__.py

@@ -5,7 +5,7 @@ from typing import Dict, Optional, Any
 from dataclasses_json import dataclass_json, Undefined
 from websocket import WebSocket
 
-from GameSentenceMiner.configuration import get_app_directory
+from GameSentenceMiner.util.configuration import get_app_directory
 
 CONFIG_FILE = os.path.join(get_app_directory(), "shared_config.json")
 websocket: WebSocket = None

GameSentenceMiner/{communication → util/communication}/send.py

@@ -1,6 +1,6 @@
 import json
 
-from GameSentenceMiner.communication.websocket import websocket, Message
+from GameSentenceMiner.util.communication.websocket import websocket, Message
 
 async def send_restart_signal():
     if websocket:

GameSentenceMiner/{communication → util/communication}/websocket.py

@@ -7,8 +7,8 @@ from enum import Enum
 
 from websocket import WebSocket
 
-from GameSentenceMiner.communication import Message
-from GameSentenceMiner.configuration import get_app_directory, logger
+from GameSentenceMiner.util.communication import Message
+from GameSentenceMiner.util.configuration import get_app_directory, logger
 
 CONFIG_FILE = os.path.join(get_app_directory(), "shared_config.json")
 websocket: WebSocket = None

GameSentenceMiner/{downloader → util/downloader}/download_tools.py

@@ -6,9 +6,9 @@ import urllib.request
 import platform
 import zipfile
 
-from GameSentenceMiner.downloader.Untitled_json import scenes
-from GameSentenceMiner.configuration import get_app_directory, logger
-from GameSentenceMiner.ffmpeg import get_ffmpeg_path, get_ffprobe_path
+from GameSentenceMiner.util.downloader.Untitled_json import scenes
+from GameSentenceMiner.util.configuration import get_app_directory, logger
+from GameSentenceMiner.util.ffmpeg import get_ffmpeg_path, get_ffprobe_path
 from GameSentenceMiner.obs import get_obs_path
 
 script_dir = os.path.dirname(os.path.abspath(__file__))