GameSentenceMiner 2.7.17__tar.gz → 2.8.1__tar.gz

{gamesentenceminer-2.7.17 → gamesentenceminer-2.8.1}/GameSentenceMiner/anki.py

@@ -7,16 +7,15 @@ import urllib.request
 from datetime import datetime, timedelta
 from requests import post
 
-from GameSentenceMiner import obs, util, notification, ffmpeg, gametext
+from GameSentenceMiner import obs, util, notification, ffmpeg
 from GameSentenceMiner.ai.gemini import translate_with_context
 from GameSentenceMiner.configuration import *
 from GameSentenceMiner.configuration import get_config
-from GameSentenceMiner.gametext import get_text_event, get_all_lines
 from GameSentenceMiner.model import AnkiCard
-from GameSentenceMiner.utility_gui import get_utility_window
+from GameSentenceMiner.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
-
+from GameSentenceMiner.web import texthooking_page
 
 audio_in_anki = None
 screenshot_in_anki = None
@@ -171,7 +170,7 @@ def get_initial_card_info(last_note: AnkiCard, selected_lines):
             last_note.get_field(get_config().anki.previous_sentence_field):
         logger.debug(
             f"Adding Previous Sentence: {get_config().anki.previous_sentence_field and game_line.prev.text and not last_note.get_field(get_config().anki.previous_sentence_field)}")
-        if selected_lines:
+        if selected_lines and selected_lines[0].prev:
             note['fields'][get_config().anki.previous_sentence_field] = selected_lines[0].prev.text
         else:
             note['fields'][get_config().anki.previous_sentence_field] = game_line.prev.text
@@ -277,10 +276,10 @@ def update_new_card():
     if get_config().obs.get_game_from_scene:
         obs.update_current_game()
     if use_prev_audio:
-        lines = get_utility_window().get_selected_lines()
+        lines = texthooking_page.get_selected_lines()
         with util.lock:
-            update_anki_card(last_card, note=get_initial_card_info(last_card, lines), game_line=gametext.get_mined_line(last_card, lines), reuse_audio=True)
-        get_utility_window().reset_checkboxes()
+            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:
         logger.info("New card(s) detected! Added to Processing Queue!")
         card_queue.append(last_card)

{gamesentenceminer-2.7.17 → gamesentenceminer-2.8.1}/GameSentenceMiner/config_gui.py

@@ -110,7 +110,8 @@ class ConfigApp:
                 websocket_uri=self.websocket_uri.get(),
                 open_config_on_startup=self.open_config_on_startup.get(),
                 open_multimine_on_startup=self.open_multimine_on_startup.get(),
-                texthook_replacement_regex=self.texthook_replacement_regex.get()
+                texthook_replacement_regex=self.texthook_replacement_regex.get(),
+                use_both_clipboard_and_websocket=self.use_both_clipboard_and_websocket.get()
             ),
             paths=Paths(
                 folder_to_watch=self.folder_to_watch.get(),
@@ -308,6 +309,13 @@ class ConfigApp:
         self.add_label_and_increment_row(general_frame, "Enable to allow GSM to see clipboard for text and line timing.",
                                          row=self.current_row, column=2)
 
+        ttk.Label(general_frame, text="Allow Both:").grid(row=self.current_row, column=0, sticky='W')
+        self.use_both_clipboard_and_websocket = tk.BooleanVar(value=self.settings.general.use_both_clipboard_and_websocket)
+        ttk.Checkbutton(general_frame, variable=self.use_both_clipboard_and_websocket).grid(row=self.current_row, column=1,
+                                                                                            sticky='W')
+        self.add_label_and_increment_row(general_frame, "Enable to allow GSM to accept both clipboard and websocket input at the same time.",
+                                            row=self.current_row, column=2)
+
         ttk.Label(general_frame, text="Websocket URI:").grid(row=self.current_row, column=0, sticky='W')
         self.websocket_uri = ttk.Entry(general_frame)
         self.websocket_uri.insert(0, self.settings.general.websocket_uri)
@@ -329,13 +337,21 @@ class ConfigApp:
         self.add_label_and_increment_row(general_frame, "Whether to open config when the script starts.",
                                          row=self.current_row, column=2)
 
-        ttk.Label(general_frame, text="Open Multimine on Startup:").grid(row=self.current_row, column=0, sticky='W')
+        ttk.Label(general_frame, text="Open GSM Texthooker on Startup:").grid(row=self.current_row, column=0, sticky='W')
         self.open_multimine_on_startup = tk.BooleanVar(value=self.settings.general.open_multimine_on_startup)
         ttk.Checkbutton(general_frame, variable=self.open_multimine_on_startup).grid(row=self.current_row, column=1,
                                                                                   sticky='W')
-        self.add_label_and_increment_row(general_frame, "Whether to open multimining window when the script starts.",
+        self.add_label_and_increment_row(general_frame, "Whether to open Texthooking page when the script starts.",
                                          row=self.current_row, column=2)
 
+        ttk.Label(general_frame, text="GSM Texthooker Port:").grid(row=self.current_row, column=0, sticky='W')
+        self.texthooker_port = ttk.Entry(general_frame)
+        self.texthooker_port.insert(0, str(self.settings.general.texthooker_port))
+        self.texthooker_port.grid(row=self.current_row, column=1)
+        self.add_label_and_increment_row(general_frame, "Port for the Texthooker to run on. Only change if you know what you are doing", row=self.current_row,
+                                            column=2)
+
+
         ttk.Label(general_frame, text="Current Version:").grid(row=self.current_row, column=0, sticky='W')
         self.current_version = ttk.Label(general_frame, text=get_current_version())
         self.current_version.grid(row=self.current_row, column=1)

{gamesentenceminer-2.7.17 → gamesentenceminer-2.8.1}/GameSentenceMiner/configuration.py

@@ -2,6 +2,7 @@ import json
 import logging
 import os
 import shutil
+import socket
 from dataclasses import dataclass, field
 from logging.handlers import RotatingFileHandler
 from os.path import expanduser
@@ -36,16 +37,17 @@ DEFAULT_CONFIG = 'Default'
 
 current_game = ''
 
-
 @dataclass_json
 @dataclass
 class General:
     use_websocket: bool = True
     use_clipboard: bool = True
+    use_both_clipboard_and_websocket: bool = False
     websocket_uri: str = 'localhost:6677'
     open_config_on_startup: bool = False
     open_multimine_on_startup: bool = False
     texthook_replacement_regex: str = ""
+    texthooker_port: int = 55000
 
 
 @dataclass_json
@@ -344,11 +346,16 @@ class Config:
             self.sync_shared_field(config.general, profile.general, "open_config_on_startup")
             self.sync_shared_field(config.general, profile.general, "open_multimine_on_startup")
             self.sync_shared_field(config.general, profile.general, "websocket_uri")
+            self.sync_shared_field(config.general, profile.general, "texthooker_port")
             self.sync_shared_field(config.audio, profile.audio, "external_tool")
             self.sync_shared_field(config.audio, profile.audio, "anki_media_collection")
             self.sync_shared_field(config, profile, "advanced")
             self.sync_shared_field(config, profile, "paths")
             self.sync_shared_field(config, profile, "obs")
+            self.sync_shared_field(config.ai, profile.ai, "anki_field")
+            self.sync_shared_field(config.ai, profile.ai, "provider")
+            self.sync_shared_field(config.ai, profile.ai, "api_key")
+
 
         return self
 

gamesentenceminer-2.8.1/GameSentenceMiner/downloader/oneocr_dl.py

@@ -0,0 +1,243 @@
+import os
+import zipfile
+import shutil
+from os.path import expanduser
+
+import requests
+import re
+import tempfile
+
+# Placeholder functions/constants for removed proprietary ones
+# In a real application, you would replace these with appropriate logic
+# or standard library equivalents.
+
+def checkdir(d):
+    """Checks if a directory exists and contains the expected files."""
+    flist = ["oneocr.dll", "oneocr.onemodel", "onnxruntime.dll"]
+    return os.path.isdir(d) and all((os.path.isfile(os.path.join(d, _)) for _ in flist))
+
+def selectdir():
+    """Attempts to find the SnippingTool directory, prioritizing cache."""
+    cachedir = "cache/SnippingTool"
+    packageFamilyName = "Microsoft.ScreenSketch_8wekyb3d8bbwe"
+
+    if checkdir(cachedir):
+        return cachedir
+    # This part needs NativeUtils.GetPackagePathByPackageFamily, which is proprietary.
+    # We'll skip this part for simplification as requested.
+    # path = NativeUtils.GetPackagePathByPackageFamily(packageFamilyName)
+    # if not path:
+    #     return None
+    # path = os.path.join(path, "SnippingTool")
+    # if not checkdir(path):
+    #     return None
+    # return path
+    return None # Return None if not found in cache
+
+def getproxy():
+    """Placeholder for proxy retrieval."""
+    # Replace with actual proxy retrieval logic or return None
+    return None
+
+def stringfyerror(e):
+    """Placeholder for error stringification."""
+    return str(e)
+
+def dynamiclink(path):
+    """Placeholder for dynamic link resolution."""
+    # This would likely map a resource path to a local file path.
+    # For simplification, we'll just use the provided path string.
+    return path # Assuming path is a URL here based on usage
+
+# Simplified download logic extracted from the question class
+class Downloader:
+    def __init__(self):
+        self.oneocr_dir = expanduser("~/.config/oneocr")
+        self.packageFamilyName = "Microsoft.ScreenSketch_8wekyb3d8bbwe"
+        self.flist = ["oneocr.dll", "oneocr.onemodel", "onnxruntime.dll"]
+
+    def download_and_extract(self):
+        """
+        Main function to attempt download and extraction.
+        Tries official source first, then a fallback URL.
+        """
+        if checkdir(self.oneocr_dir):
+            print("Files already exist in cache.")
+            return True
+
+        try:
+            print("Attempting to download from official source...")
+            self.downloadofficial()
+            print("Download and extraction from official source successful.")
+            return True
+        except Exception as e:
+            print(f"Download from official source failed: {stringfyerror(e)}")
+            print("Attempting to download from fallback URL...")
+            try:
+                fallback_url = dynamiclink("/Resource/SnippingTool") # Assuming this resolves to a URL
+                self.downloadx(fallback_url)
+                print("Download and extraction from fallback URL successful.")
+                return True
+            except Exception as e_fallback:
+                print(f"Download from fallback URL failed: {stringfyerror(e_fallback)}")
+                print("All download attempts failed.")
+                return False
+
+
+    def downloadofficial(self):
+        """Downloads the latest SnippingTool MSIX bundle from a store API."""
+        headers = {
+            "accept": "*/*",
+            # Changed accept-language to prioritize US English
+            "accept-language": "en-US,en;q=0.9",
+            "cache-control": "no-cache",
+            "origin": "https://store.rg-adguard.net",
+            "pragma": "no-cache",
+            "priority": "u=1, i",
+            "referer": "https://store.rg-adguard.net/",
+            "sec-ch-ua": '"Chromium";v="134", "Not:A-Brand";v="24", "Google Chrome";v="134"',
+            "sec-ch-ua-mobile": "?0",
+            "sec-ch-ua-platform": '"Windows"',
+            "sec-fetch-dest": "empty",
+            "sec-fetch-mode": "cors",
+            "sec-fetch-site": "same-origin",
+            "user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/134.0.0.0 Safari/537.36",
+        }
+
+        data = dict(type="PackageFamilyName", url=self.packageFamilyName)
+
+        response = requests.post(
+            "https://store.rg-adguard.net/api/GetFiles",
+            headers=headers,
+            data=data,
+            proxies=getproxy(),
+        )
+        response.raise_for_status() # Raise an exception for bad status codes
+
+        saves = []
+        for link, package in re.findall('<a href="(.*?)".*?>(.*?)</a>', response.text):
+            if not package.startswith("Microsoft.ScreenSketch"):
+                continue
+            if not package.endswith(".msixbundle"):
+                continue
+            version = re.search(r"\d+\.\d+\.\d+\.\d+", package)
+            if not version:
+                continue
+            version = tuple(int(_) for _ in version.group().split("."))
+            saves.append((version, link, package))
+
+        if not saves:
+            raise Exception("Could not find suitable download link from official source.")
+
+        saves.sort(key=lambda _: _[0])
+        url = saves[-1][1]
+        package_name = saves[-1][2]
+
+        print(f"Downloading {package_name} from {url}")
+        req = requests.get(url, stream=True, proxies=getproxy())
+        req.raise_for_status()
+
+        total_size_in_bytes = int(req.headers.get('content-length', 0))
+        block_size = 1024 * 32 # 32 Kibibytes
+        temp_msixbundle_path = os.path.join(tempfile.gettempdir(), package_name)
+
+        with open(temp_msixbundle_path, "wb") as ff:
+            downloaded_size = 0
+            for chunk in req.iter_content(chunk_size=block_size):
+                ff.write(chunk)
+                downloaded_size += len(chunk)
+                # Basic progress reporting (can be removed)
+                if total_size_in_bytes:
+                    progress = (downloaded_size / total_size_in_bytes) * 100
+                    print(f"Downloaded {downloaded_size}/{total_size_in_bytes} bytes ({progress:.2f}%)", end='\r')
+        print("\nDownload complete. Extracting...")
+
+        namemsix = None
+        with zipfile.ZipFile(temp_msixbundle_path) as ff:
+            for name in ff.namelist():
+                if name.startswith("SnippingTool") and name.endswith("_x64.msix"):
+                    namemsix = name
+                    break
+            if not namemsix:
+                raise Exception("Could not find MSIX file within MSIXBUNDLE.")
+            temp_msix_path = os.path.join(tempfile.gettempdir(), namemsix)
+            ff.extract(namemsix, tempfile.gettempdir())
+
+        print(f"Extracted {namemsix}. Extracting components...")
+        if os.path.exists(self.oneocr_dir):
+             shutil.rmtree(self.oneocr_dir)
+        os.makedirs(self.oneocr_dir, exist_ok=True)
+
+        with zipfile.ZipFile(temp_msix_path) as ff:
+            collect = []
+            for name in ff.namelist():
+                # Extract only the files within the "SnippingTool/" directory
+                if name.startswith("SnippingTool/") and any(name.endswith(f) for f in self.flist):
+                     # Construct target path relative to cachedir
+                    target_path = os.path.join(self.oneocr_dir, os.path.relpath(name, "SnippingTool/"))
+                    # Ensure parent directories exist
+                    os.makedirs(os.path.dirname(target_path), exist_ok=True)
+                    # Extract the file
+                    with ff.open(name) as source, open(target_path, "wb") as target:
+                        shutil.copyfileobj(source, target)
+                    collect.append(name)
+            if not collect:
+                 raise Exception("Could not find required files within MSIX.")
+
+
+        if not checkdir(self.oneocr_dir):
+            raise Exception("Extraction failed: Required files not found in cache directory.")
+
+        # Clean up temporary files
+        os.remove(temp_msixbundle_path)
+        os.remove(temp_msix_path)
+
+
+    def downloadx(self, url: str):
+        """Downloads a zip file from a URL and extracts it."""
+        print(f"Downloading from fallback URL: {url}")
+        # Added accept-language to the fallback download as well for consistency
+        headers = {
+             "accept-language": "en-US,en;q=0.9",
+             # Add other relevant headers if necessary for the fallback URL
+             "user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/134.0.0.0 Safari/537.36",
+             "accept": "*/*",
+        }
+        req = requests.get(url, verify=False, proxies=getproxy(), stream=True, headers=headers)
+        req.raise_for_status()
+
+        total_size_in_bytes = int(req.headers.get('content-length', 0))
+        block_size = 1024 * 32 # 32 Kibibytes
+        temp_zip_path = os.path.join(tempfile.gettempdir(), url.split("/")[-1])
+
+        with open(temp_zip_path, "wb") as ff:
+            downloaded_size = 0
+            for chunk in req.iter_content(chunk_size=block_size):
+                ff.write(chunk)
+                downloaded_size += len(chunk)
+                 # Basic progress reporting (can be removed)
+                if total_size_in_bytes:
+                    progress = (downloaded_size / total_size_in_bytes) * 100
+                    print(f"Downloaded {downloaded_size}/{total_size_in_bytes} bytes ({progress:.2f}%)", end='\r')
+        print("\nDownload complete. Extracting...")
+
+        if os.path.exists(self.oneocr_dir):
+             shutil.rmtree(self.oneocr_dir)
+        os.makedirs(self.oneocr_dir, exist_ok=True)
+
+        with zipfile.ZipFile(temp_zip_path) as zipf:
+            zipf.extractall(self.oneocr_dir)
+
+        if not checkdir(self.oneocr_dir):
+            raise Exception("Extraction failed: Required files not found in cache directory.")
+
+        # Clean up temporary files
+        os.remove(temp_zip_path)
+
+# Example usage:
+if __name__ == "__main__":
+    downloader = Downloader()
+    if downloader.download_and_extract():
+        print("SnippingTool files are ready.")
+    else:
+        print("Failed to obtain SnippingTool files.")

{gamesentenceminer-2.7.17 → gamesentenceminer-2.8.1}/GameSentenceMiner/ffmpeg.py

@@ -1,11 +1,9 @@
-import subprocess
 import tempfile
-import time
 
 from GameSentenceMiner import obs, util, configuration
 from GameSentenceMiner.configuration import *
+from GameSentenceMiner.text_log import initial_time
 from GameSentenceMiner.util import *
-from GameSentenceMiner.gametext import initial_time
 
 
 def get_ffmpeg_path():

gamesentenceminer-2.8.1/GameSentenceMiner/gametext.py

@@ -0,0 +1,131 @@
+import asyncio
+import re
+import threading
+import time
+
+import pyperclip
+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.web.texthooking_page import add_event_to_texthooker
+
+current_line = ''
+current_line_after_regex = ''
+current_line_time = datetime.now()
+
+reconnecting = False
+websocket_connected = False
+
+    # def remove_old_events(self, cutoff_time: datetime):
+    #     self.values = [line for line in self.values if line.time >= cutoff_time]
+
+class ClipboardMonitor(threading.Thread):
+
+    def __init__(self):
+        threading.Thread.__init__(self)
+        self.daemon = True
+
+    def run(self):
+        global current_line_time, current_line
+
+        # Initial clipboard content
+        current_line = pyperclip.paste()
+
+        skip_next_clipboard = False
+        while True:
+            if not get_config().general.use_both_clipboard_and_websocket and websocket_connected:
+                time.sleep(1)
+                skip_next_clipboard = True
+                continue
+            current_clipboard = pyperclip.paste()
+
+            if current_clipboard != current_line and not skip_next_clipboard:
+                handle_new_text_event(current_clipboard)
+                skip_next_clipboard = False
+
+            time.sleep(0.05)
+
+
+async def listen_websocket():
+    global current_line, current_line_time, reconnecting, websocket_connected
+    try_other = False
+    websocket_url = f'ws://{get_config().general.websocket_uri}/gsm'
+    while True:
+        if try_other:
+            websocket_url = f'ws://{get_config().general.websocket_uri}/api/ws/text/origin'
+        try:
+            async with websockets.connect(websocket_url, ping_interval=None) as websocket:
+                logger.info("TextHooker Websocket Connected!")
+                if reconnecting:
+                    logger.info(f"Texthooker WebSocket connected Successfully!" + " Disabling Clipboard Monitor." if (get_config().general.use_clipboard and not get_config().general.use_both_clipboard_and_websocket) else "")
+                    reconnecting = False
+                websocket_connected = True
+                try_other = True
+                line_time = None
+                while True:
+                    message = await websocket.recv()
+                    logger.debug(message)
+                    try:
+                        data = json.loads(message)
+                        if "sentence" in data:
+                            current_clipboard = data["sentence"]
+                        if "time" in data:
+                            line_time = datetime.fromisoformat(data["time"])
+                            print(line_time)
+                    except json.JSONDecodeError or TypeError:
+                        current_clipboard = message
+                    if current_clipboard != current_line:
+                        handle_new_text_event(current_clipboard, line_time if line_time else None)
+        except (websockets.ConnectionClosed, ConnectionError, InvalidStatus) as e:
+            if isinstance(e, InvalidStatus):
+                e: InvalidStatus
+                if e.response.status_code == 404:
+                    logger.info("Texthooker WebSocket connection failed. Attempting some fixes...")
+                    try_other = True
+
+                logger.error(f"Texthooker WebSocket connection failed. Please check if the Texthooker is running and the WebSocket URI is correct.")
+            websocket_connected = False
+            if not reconnecting:
+                logger.warning(f"Texthooker WebSocket connection lost, Defaulting to clipboard if enabled. Attempting to Reconnect...")
+            reconnecting = True
+            await asyncio.sleep(5)
+
+def handle_new_text_event(current_clipboard, line_time=None):
+    global current_line, current_line_time, current_line_after_regex
+    current_line = current_clipboard
+    if get_config().general.texthook_replacement_regex:
+        current_line_after_regex = re.sub(get_config().general.texthook_replacement_regex, '', current_line)
+    else:
+        current_line_after_regex = current_line
+    current_line_after_regex = do_text_replacements(current_line, TEXT_REPLACEMENTS_FILE)
+    logger.info(f"Line Received: {current_line_after_regex}")
+    current_line_time = line_time if line_time else datetime.now()
+    add_line(current_line_after_regex, line_time)
+    add_event_to_texthooker(get_text_log()[-1])
+
+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("")
+
+
+def run_websocket_listener():
+    asyncio.run(listen_websocket())
+
+
+def start_text_monitor():
+    if get_config().general.use_websocket:
+        threading.Thread(target=run_websocket_listener, daemon=True).start()
+    if get_config().general.use_clipboard:
+        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.")
+            else:
+                logger.info("Both WebSocket and Clipboard monitoring are enabled. WebSocket will take precedence if connected.")
+        ClipboardMonitor().start()

{gamesentenceminer-2.7.17 → gamesentenceminer-2.8.1}/GameSentenceMiner/gsm.py

@@ -10,7 +10,6 @@ from pystray import Icon, Menu, MenuItem
 from watchdog.events import FileSystemEventHandler
 from watchdog.observers import Observer
 
-import time
 
 from GameSentenceMiner import anki
 from GameSentenceMiner import config_gui
@@ -27,10 +26,11 @@ from GameSentenceMiner.communication.websocket import connect_websocket, registe
 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.gametext import get_text_event, get_mined_line, GameLine
 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 import *
-from GameSentenceMiner.utility_gui import init_utility_window, get_utility_window
+from GameSentenceMiner.web import texthooking_page
+from GameSentenceMiner.web.texthooking_page import start_web_server
 
 if is_windows():
     import win32api
@@ -57,9 +57,9 @@ class VideoToAudioHandler(FileSystemEventHandler):
     @staticmethod
     def convert_to_audio(video_path):
         try:
-            if get_utility_window().line_for_audio:
-                line: GameLine = get_utility_window().line_for_audio
-                get_utility_window().line_for_audio = None
+            if texthooking_page.event_manager.line_for_audio:
+                line: GameLine = texthooking_page.event_manager.line_for_audio
+                texthooking_page.event_manager.line_for_audio = None
                 if get_config().advanced.audio_player_path:
                     audio = VideoToAudioHandler.get_audio(line, line.next.time if line.next else None, video_path, temporary=True)
                     play_audio_in_external(audio)
@@ -67,9 +67,9 @@ class VideoToAudioHandler(FileSystemEventHandler):
                 elif get_config().advanced.video_player_path:
                     play_video_in_external(line, video_path)
                 return
-            if get_utility_window().line_for_screenshot:
-                line: GameLine = get_utility_window().line_for_screenshot
-                get_utility_window().line_for_screenshot = None
+            if texthooking_page.event_manager.line_for_screenshot:
+                line: GameLine = texthooking_page.event_manager.line_for_screenshot
+                texthooking_page.event_manager.line_for_screenshot = None
                 screenshot = ffmpeg.get_screenshot_for_line(video_path, line)
                 os.startfile(screenshot)
                 os.remove(video_path)
@@ -109,18 +109,18 @@ class VideoToAudioHandler(FileSystemEventHandler):
                     if mined_line.next:
                         line_cutoff = mined_line.next.time
 
-                if get_utility_window().lines_selected():
-                    lines = get_utility_window().get_selected_lines()
-                    start_line = lines[0]
-                    mined_line = get_mined_line(last_note, lines)
-                    line_cutoff = get_utility_window().get_next_line_timing()
+                selected_lines = []
+                if texthooking_page.are_lines_selected():
+                    selected_lines = texthooking_page.get_selected_lines()
+                    start_line = selected_lines[0]
+                    mined_line = get_mined_line(last_note, selected_lines)
+                    line_cutoff = selected_lines[-1].get_next_time()
 
                 if last_note:
                     logger.debug(last_note.to_json())
-                selected_lines = get_utility_window().get_selected_lines()
                 note = anki.get_initial_card_info(last_note, selected_lines)
                 tango = last_note.get_field(get_config().anki.word_field) if last_note else ''
-                get_utility_window().reset_checkboxes()
+                texthooking_page.reset_checked_lines()
 
                 if get_config().anki.sentence_audio_field and get_config().audio.enabled:
                     logger.debug("Attempting to get audio from video")
@@ -268,10 +268,10 @@ def register_hotkeys():
         keyboard.add_hotkey(get_config().hotkeys.reset_line, gametext.reset_line_hotkey_pressed)
     if get_config().hotkeys.take_screenshot:
         keyboard.add_hotkey(get_config().hotkeys.take_screenshot, get_screenshot)
-    if get_config().hotkeys.open_utility:
-        keyboard.add_hotkey(get_config().hotkeys.open_utility, open_multimine)
     if get_config().hotkeys.play_latest_audio:
         keyboard.add_hotkey(get_config().hotkeys.play_latest_audio, play_most_recent_audio)
+    if get_config().hotkeys.open_utility:
+        keyboard.add_hotkey(get_config().hotkeys.open_utility, texthooking_page.open_texthooker)
 
 
 def get_screenshot():
@@ -322,13 +322,10 @@ def open_settings():
     settings_window.show()
 
 
-def open_multimine():
-    obs.update_current_game()
-    get_utility_window().show()
-
 def play_most_recent_audio():
-    if get_config().advanced.audio_player_path or get_config().advanced.video_player_path and len(gametext.line_history.values) > 0:
-        get_utility_window().line_for_audio = gametext.line_history.values[-1]
+    if get_config().advanced.audio_player_path or get_config().advanced.video_player_path and len(
+            get_all_lines()) > 0:
+        texthooking_page.event_manager.line_for_audio = get_all_lines()[-1]
         obs.save_replay_buffer()
     else:
         logger.error("Feature Disabled. No audio or video player path set in config!")
@@ -368,6 +365,10 @@ def play_pause(icon, item):
     update_icon()
 
 
+def open_multimine(icon, item):
+    texthooking_page.open_texthooker()
+
+
 def update_icon():
     global menu, icon
     # Recreate the menu with the updated button text
@@ -416,7 +417,7 @@ def run_tray():
 
     menu = Menu(
         MenuItem("Open Settings", open_settings),
-        MenuItem("Open Multi-Mine GUI", open_multimine),
+        MenuItem("Open Texthooker", texthooking_page.open_texthooker),
         MenuItem("Open Log", open_log),
         MenuItem("Toggle Replay Buffer", play_pause),
         MenuItem("Restart OBS", restart_obs),
@@ -554,6 +555,7 @@ def post_init():
                 whisper_helper.initialize_whisper_model()
             if get_config().vad.is_silero():
                 from GameSentenceMiner.vad import silero_trim
+        start_web_server()
 
     util.run_new_thread(do_post_init)
 
@@ -576,7 +578,6 @@ def main(reloading=False):
     logger.info("Script started.")
     root = ttk.Window(themename='darkly')
     settings_window = config_gui.ConfigApp(root)
-    init_utility_window(root)
     initialize(reloading)
     initialize_async()
     observer = Observer()
@@ -594,9 +595,7 @@ def main(reloading=False):
     try:
         # if get_config().general.open_config_on_startup:
         #     root.after(0, settings_window.show)
-        if get_config().general.open_multimine_on_startup:
-            root.after(0, get_utility_window().show)
-        root.after(0, post_init)
+        root.after(50, post_init)
         settings_window.add_save_hook(update_icon)
         settings_window.on_exit = exit_program
         root.mainloop()