GameSentenceMiner 2.7.16__py3-none-any.whl → 2.8.0__py3-none-any.whl

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/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/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/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/gametext.py

@@ -1,24 +1,19 @@
 import asyncio
-import difflib
 import re
 import threading
 import time
-from datetime import datetime, timedelta
 
 import pyperclip
 import websockets
 from websockets import InvalidStatus
 
 from GameSentenceMiner import util
-from GameSentenceMiner.model import AnkiCard
 from GameSentenceMiner.configuration import *
-from GameSentenceMiner.configuration import get_config, logger
-from GameSentenceMiner.util import remove_html_and_cloze_tags
-from difflib import SequenceMatcher
+from GameSentenceMiner.text_log import *
+from GameSentenceMiner.util import do_text_replacements, TEXT_REPLACEMENTS_FILE
 
-from GameSentenceMiner.utility_gui import get_utility_window
+from GameSentenceMiner.web.texthooking_page import add_event_to_texthooker
 
-initial_time = datetime.now()
 current_line = ''
 current_line_after_regex = ''
 current_line_time = datetime.now()
@@ -26,72 +21,9 @@ current_line_time = datetime.now()
 reconnecting = False
 websocket_connected = False
 
-@dataclass
-class GameLine:
-    text: str
-    time: datetime
-    prev: 'GameLine'
-    next: 'GameLine'
-    index: int = 0
-
-    def get_previous_time(self):
-        if self.prev:
-            return self.prev.time
-        return initial_time
-
-    def get_next_time(self):
-        if self.next:
-            return self.next.time
-        return 0
-
-    def __str__(self):
-        return str({"text": self.text, "time": self.time})
-
-@dataclass
-class GameText:
-    values: list[GameLine]
-    game_line_index = 0
-
-    def __init__(self):
-        self.values = []
-
-    def __getitem__(self, key):
-        return self.values[key]
-
-    def get_time(self, line_text: str, occurrence: int = -1) -> datetime:
-        matches = [line for line in self.values if line.text == line_text]
-        if matches:
-            return matches[occurrence].time  # Default to latest
-        return initial_time
-
-    def get_event(self, line_text: str, occurrence: int = -1) -> GameLine | None:
-        matches = [line for line in self.values if line.text == line_text]
-        if matches:
-            return matches[occurrence]
-        return None
-
-    def add_line(self, line_text, line_time=None):
-        if not line_text:
-            return
-        new_line = GameLine(line_text, line_time if line_time else datetime.now(), self.values[-1] if self.values else None, None, self.game_line_index)
-        logger.debug(f"Adding line: {new_line}")
-        self.game_line_index += 1
-        if self.values:
-            self.values[-1].next = new_line
-        self.values.append(new_line)
-        # self.remove_old_events(datetime.now() - timedelta(minutes=10))
-
-    def has_line(self, line_text) -> bool:
-        for game_line in self.values:
-            if game_line.text == line_text:
-                return True
-        return False
-
     # def remove_old_events(self, cutoff_time: datetime):
     #     self.values = [line for line in self.values if line.time >= cutoff_time]
 
-line_history = GameText()
-
 class ClipboardMonitor(threading.Thread):
 
     def __init__(self):
@@ -99,14 +31,14 @@ class ClipboardMonitor(threading.Thread):
         self.daemon = True
 
     def run(self):
-        global current_line_time, current_line, line_history
+        global current_line_time, current_line
 
         # Initial clipboard content
         current_line = pyperclip.paste()
 
         skip_next_clipboard = False
         while True:
-            if websocket_connected:
+            if not get_config().general.use_both_clipboard_and_websocket and websocket_connected:
                 time.sleep(1)
                 skip_next_clipboard = True
                 continue
@@ -120,7 +52,7 @@ class ClipboardMonitor(threading.Thread):
 
 
 async def listen_websocket():
-    global current_line, current_line_time, line_history, reconnecting, websocket_connected
+    global current_line, current_line_time, reconnecting, websocket_connected
     try_other = False
     websocket_url = f'ws://{get_config().general.websocket_uri}/gsm'
     while True:
@@ -130,7 +62,7 @@ async def listen_websocket():
             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 else "")
+                    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
@@ -164,18 +96,17 @@ async def listen_websocket():
             await asyncio.sleep(5)
 
 def handle_new_text_event(current_clipboard, line_time=None):
-    global current_line, current_line_time, line_history, current_line_after_regex
+    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()
-    line_history.add_line(current_line_after_regex, line_time)
-    if get_utility_window():
-        get_utility_window().add_text(line_history[-1])
-
+    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
@@ -193,78 +124,8 @@ def start_text_monitor():
         threading.Thread(target=run_websocket_listener, daemon=True).start()
     if get_config().general.use_clipboard:
         if get_config().general.use_websocket:
-            logger.info("Both WebSocket and Clipboard monitoring are enabled. WebSocket will take precedence if connected.")
-        ClipboardMonitor().start()
-
-
-def similar(a, b):
-    return SequenceMatcher(None, a, b).ratio()
-
-def one_contains_the_other(a, b):
-    return a in b or b in a
-
-def lines_match(a, b):
-    similarity = similar(a, b)
-    logger.debug(f"Comparing: {a} with {b} - Similarity: {similarity}, Or One contains the other: {one_contains_the_other(a, b)}")
-    return similar(a, b) >= 0.60 or one_contains_the_other(a, b)
-
-def get_text_event(last_note) -> GameLine:
-    lines = line_history.values
-
-    if not lines:
-        raise Exception("No lines in history. Text is required from either clipboard or websocket for GSM to work. Please check your setup/config.")
-
-    if not last_note:
-        return lines[-1]
-
-    sentence = last_note.get_field(get_config().anki.sentence_field)
-    if not sentence:
-        return lines[-1]
-
-    for line in reversed(lines):
-        if lines_match(line.text, remove_html_and_cloze_tags(sentence)):
-            return line
-
-    logger.debug("Couldn't find a match in history, using last event")
-    return lines[-1]
-
-
-def get_line_and_future_lines(last_note):
-    if not last_note:
-        return []
-
-    sentence = last_note.get_field(get_config().anki.sentence_field)
-    found_lines = []
-    if sentence:
-        found = False
-        for line in line_history.values:
-            if found:
-                found_lines.append(line.text)
-            if lines_match(line.text, remove_html_and_cloze_tags(sentence)):  # 80% similarity threshold
-                found = True
-                found_lines.append(line.text)
-    return found_lines
-
-def get_mined_line(last_note: AnkiCard, lines):
-    if not last_note:
-        return lines[-1]
-    if not lines:
-        lines = get_all_lines()
-
-    sentence = last_note.get_field(get_config().anki.sentence_field)
-    for line in lines:
-        if lines_match(line.text, remove_html_and_cloze_tags(sentence)):
-            return line
-    return lines[-1]
-
-
-def get_time_of_line(line):
-    return line_history.get_time(line)
-
-
-def get_all_lines():
-    return line_history.values
-
-
-def get_line_history():
-    return line_history
+            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/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()

GameSentenceMiner/obs.py

@@ -1,10 +1,7 @@
-import logging
 import os.path
 import subprocess
-import tempfile
 import time
 
-import psutil
 from obswebsocket import obsws, requests
 
 from GameSentenceMiner import util, configuration

GameSentenceMiner/ocr/ocrconfig.py

@@ -1,6 +1,5 @@
 import configparser
 import os
-import re
 
 class OCRConfig:
     def __init__(self, config_file=os.path.expanduser("~/.config/owocr_config.ini")):