GameSentenceMiner 2.2.4__py3-none-any.whl → 2.3.1__py3-none-any.whl

GameSentenceMiner/anki.py

@@ -6,12 +6,13 @@ import urllib.request
 
 import requests as req
 
-from GameSentenceMiner import obs, util, notification, ffmpeg
+from GameSentenceMiner import obs, util, notification, ffmpeg, gametext
 
 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
+from util import remove_html_tags
 
 audio_in_anki = None
 screenshot_in_anki = None
@@ -69,6 +70,8 @@ def update_anki_card(last_note, note=None, audio_path='', video_path='', tango='
     if get_config().features.open_anki_edit:
         notification.open_anki_card(last_note['noteId'])
 
+    util.set_last_mined_line(get_sentence(last_note))
+
     if get_config().audio.external_tool:
         open_audio_in_external(f"{get_config().audio.anki_media_collection}/{audio_in_anki}")
 
@@ -103,14 +106,21 @@ def add_image_to_card(last_note, image_path):
     logger.info(f"UPDATED IMAGE FOR ANKI CARD {last_note['noteId']}")
 
 
-def get_initial_card_info(last_note):
+def get_initial_card_info(last_note, selected_lines):
     note = {'id': last_note['noteId'], 'fields': {}}
     if not last_note:
         return note
     current_line, previous_line = get_last_two_sentences(last_note)
     logger.debug(f"Previous Sentence {previous_line}")
     logger.debug(f"Current Sentence {current_line}")
-    util.use_previous_audio = True
+
+    if get_config().audio.mining_from_history_grab_all_audio and get_config().anki.multi_overwrites_sentence:
+        lines = gametext.get_line_and_future_lines(last_note)
+        if lines:
+            note['fields'][get_config().anki.sentence_field] = "".join(lines)
+
+    if selected_lines and get_config().anki.multi_overwrites_sentence:
+        note['fields'][get_config().anki.sentence_field] = "".join(selected_lines)
 
     logger.debug(
         f"Adding Previous Sentence: {get_config().anki.previous_sentence_field and previous_line and not last_note['fields'][get_config().anki.previous_sentence_field]['value']}")
@@ -202,20 +212,27 @@ def update_new_card():
     if not check_tags_for_should_update(last_card):
         return
 
-    use_prev_audio = util.use_previous_audio
     if util.lock.locked():
         logger.info("Audio still being Trimmed, Card Queued!")
-        use_prev_audio = True
     with util.lock:
+        use_prev_audio = sentence_is_same_as_previous(last_card)
+        logger.info(f"last mined line: {util.get_last_mined_line()}, current sentence: {get_sentence(last_card)}")
         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)
+            update_anki_card(last_card, note=get_initial_card_info(last_card, []), reuse_audio=True)
         else:
             logger.info("New card(s) detected!")
             obs.save_replay_buffer()
 
+def sentence_is_same_as_previous(last_card):
+    if not util.get_last_mined_line():
+        return False
+    return remove_html_tags(get_sentence(last_card)) == remove_html_tags(util.get_last_mined_line())
+
+def get_sentence(card):
+    return card['fields'][get_config().anki.sentence_field]['value']
 
 def check_tags_for_should_update(last_card):
     if get_config().anki.tags_to_check:

GameSentenceMiner/config_gui.py

@@ -49,8 +49,9 @@ class HoverInfoWidget:
 
 
 class ConfigApp:
-    def __init__(self):
-        self.window = ttk.Window(themename='darkly')
+    def __init__(self, root):
+        self.window = root
+        # self.window = ttk.Window(themename='darkly')
         self.window.title('GameSentenceMiner Configuration')
         self.window.protocol("WM_DELETE_WINDOW", self.hide)
 
@@ -125,7 +126,8 @@ class ConfigApp:
                 use_websocket=self.websocket_enabled.get(),
                 websocket_uri=self.websocket_uri.get(),
                 open_config_on_startup=self.open_config_on_startup.get(),
-                check_for_update_on_startup=self.check_for_update_on_startup.get()
+                check_for_update_on_startup=self.check_for_update_on_startup.get(),
+                texthook_replacement_regex=self.texthook_replacement_regex.get()
             ),
             paths=Paths(
                 folder_to_watch=self.folder_to_watch.get(),
@@ -150,6 +152,7 @@ class ConfigApp:
                 polling_rate=int(self.polling_rate.get()),
                 overwrite_audio=self.overwrite_audio.get(),
                 overwrite_picture=self.overwrite_picture.get(),
+                multi_overwrites_sentence=self.multi_overwrites_sentence.get(),
                 anki_custom_fields={
                     key_entry.get(): value_entry.get() for key_entry, value_entry, delete_button in
                     self.custom_field_entries if key_entry.get()
@@ -176,10 +179,13 @@ class ConfigApp:
                 end_offset=float(self.end_offset.get()),
                 ffmpeg_reencode_options=self.ffmpeg_reencode_options.get(),
                 external_tool = self.external_tool.get(),
-                anki_media_collection=self.anki_media_collection.get()
+                anki_media_collection=self.anki_media_collection.get(),
+                mining_from_history_grab_all_audio=self.mining_from_history_grab_all_audio.get()
             ),
             obs=OBS(
                 enabled=self.obs_enabled.get(),
+                open_obs=self.open_obs.get(),
+                close_obs=self.close_obs.get(),
                 host=self.obs_host.get(),
                 port=int(self.obs_port.get()),
                 password=self.obs_password.get(),
@@ -189,7 +195,8 @@ class ConfigApp:
             ),
             hotkeys=Hotkeys(
                 reset_line=self.reset_line_hotkey.get(),
-                take_screenshot=self.take_screenshot_hotkey.get()
+                take_screenshot=self.take_screenshot_hotkey.get(),
+                open_utility=self.open_utility_hotkey.get()
             ),
             vad=VAD(
                 whisper_model=self.whisper_model.get(),
@@ -262,11 +269,11 @@ class ConfigApp:
         general_frame = ttk.Frame(self.notebook)
         self.notebook.add(general_frame, text='General')
 
-        ttk.Label(general_frame, text="Websocket Enabled:").grid(row=self.current_row, column=0, sticky='W')
+        ttk.Label(general_frame, text="Websocket Enabled (Clipboard Disabled):").grid(row=self.current_row, column=0, sticky='W')
         self.websocket_enabled = tk.BooleanVar(value=self.settings.general.use_websocket)
         ttk.Checkbutton(general_frame, variable=self.websocket_enabled).grid(row=self.current_row, column=1,
                                                                              sticky='W')
-        self.add_label_and_increment_row(general_frame, "Enable or disable WebSocket communication.",
+        self.add_label_and_increment_row(general_frame, "Enable or disable WebSocket communication. Enabling this will disable the clipboard monitor. RESTART REQUIRED.",
                                          row=self.current_row, column=2)
 
         ttk.Label(general_frame, text="Websocket URI:").grid(row=self.current_row, column=0, sticky='W')
@@ -276,6 +283,13 @@ class ConfigApp:
         self.add_label_and_increment_row(general_frame, "WebSocket URI for connecting.", row=self.current_row,
                                          column=2)
 
+        ttk.Label(general_frame, text="TextHook Replacement Regex:").grid(row=self.current_row, column=0, sticky='W')
+        self.texthook_replacement_regex = ttk.Entry(general_frame)
+        self.texthook_replacement_regex.insert(0, self.settings.general.texthook_replacement_regex)
+        self.texthook_replacement_regex.grid(row=self.current_row, column=1)
+        self.add_label_and_increment_row(general_frame, "Regex to run replacement on texthook input, set this to the same as what you may have in your texthook page.", row=self.current_row,
+                                         column=2)
+
         ttk.Label(general_frame, text="Open Config on Startup:").grid(row=self.current_row, column=0, sticky='W')
         self.open_config_on_startup = tk.BooleanVar(value=self.settings.general.open_config_on_startup)
         ttk.Checkbutton(general_frame, variable=self.open_config_on_startup).grid(row=self.current_row, column=1,
@@ -532,6 +546,13 @@ class ConfigApp:
         self.add_label_and_increment_row(anki_frame, "Overwrite existing pictures in Anki cards.", row=self.current_row,
                                          column=2)
 
+        ttk.Label(anki_frame, text="Multi-line Mining Overwrite Sentence:").grid(row=self.current_row, column=0, sticky='W')
+        self.multi_overwrites_sentence = tk.BooleanVar(
+            value=self.settings.anki.multi_overwrites_sentence)
+        ttk.Checkbutton(anki_frame, variable=self.multi_overwrites_sentence).grid(row=self.current_row, column=1, sticky='W')
+        self.add_label_and_increment_row(anki_frame, "When using Multi-line Mining, overrwrite the sentence with a concatenation of the lines selected.", row=self.current_row,
+                                         column=2)
+
         self.anki_custom_fields = self.settings.anki.anki_custom_fields
         self.custom_field_entries = []
 
@@ -729,6 +750,13 @@ class ConfigApp:
                                          row=self.current_row,
                                          column=2)
 
+        ttk.Label(audio_frame, text="Grab all Future Audio when Mining from History:").grid(row=self.current_row, column=0, sticky='W')
+        self.mining_from_history_grab_all_audio = tk.BooleanVar(
+            value=self.settings.audio.mining_from_history_grab_all_audio)
+        ttk.Checkbutton(audio_frame, variable=self.mining_from_history_grab_all_audio).grid(row=self.current_row, column=1, sticky='W')
+        self.add_label_and_increment_row(audio_frame, "When mining from History, this option will allow the script to get all audio from that line to the current time.", row=self.current_row,
+                                         column=2)
+
     @new_tab
     def create_obs_tab(self):
         obs_frame = ttk.Frame(self.notebook)
@@ -740,6 +768,18 @@ class ConfigApp:
         self.add_label_and_increment_row(obs_frame, "Enable or disable OBS integration.", row=self.current_row,
                                          column=2)
 
+        ttk.Label(obs_frame, text="Open OBS:").grid(row=self.current_row, column=0, sticky='W')
+        self.open_obs = tk.BooleanVar(value=self.settings.obs.open_obs)
+        ttk.Checkbutton(obs_frame, variable=self.open_obs).grid(row=self.current_row, column=1, sticky='W')
+        self.add_label_and_increment_row(obs_frame, "Open OBS when the GSM starts.", row=self.current_row,
+                                         column=2)
+
+        ttk.Label(obs_frame, text="Close OBS:").grid(row=self.current_row, column=0, sticky='W')
+        self.close_obs = tk.BooleanVar(value=self.settings.obs.close_obs)
+        ttk.Checkbutton(obs_frame, variable=self.close_obs).grid(row=self.current_row, column=1, sticky='W')
+        self.add_label_and_increment_row(obs_frame, "Close OBS when the GSM closes.", row=self.current_row,
+                                         column=2)
+
         ttk.Label(obs_frame, text="Host:").grid(row=self.current_row, column=0, sticky='W')
         self.obs_host = ttk.Entry(obs_frame)
         self.obs_host.insert(0, self.settings.obs.host)
@@ -800,6 +840,12 @@ class ConfigApp:
         self.take_screenshot_hotkey.grid(row=self.current_row, column=1)
         self.add_label_and_increment_row(hotkeys_frame, "Hotkey to take a screenshot.", row=self.current_row, column=2)
 
+        ttk.Label(hotkeys_frame, text="Open Utility Hotkey:").grid(row=self.current_row, column=0, sticky='W')
+        self.open_utility_hotkey = ttk.Entry(hotkeys_frame)
+        self.open_utility_hotkey.insert(0, self.settings.hotkeys.open_utility)
+        self.open_utility_hotkey.grid(row=self.current_row, column=1)
+        self.add_label_and_increment_row(hotkeys_frame, "Hotkey to open the text utility.", row=self.current_row, column=2)
+
 
     @new_tab
     def create_profiles_tab(self):

GameSentenceMiner/configuration.py

@@ -41,6 +41,7 @@ class General:
     websocket_uri: str = 'localhost:6677'
     open_config_on_startup: bool = False
     check_for_update_on_startup: bool = False
+    texthook_replacement_regex: str = ""
 
 
 @dataclass_json
@@ -71,6 +72,7 @@ class Anki:
     polling_rate: int = 200
     overwrite_audio: bool = False
     overwrite_picture: bool = True
+    multi_overwrites_sentence: bool = True
     anki_custom_fields: Dict[str, str] = None  # Initialize to None and set it in __post_init__
 
     def __post_init__(self):
@@ -112,12 +114,15 @@ class Audio:
     ffmpeg_reencode_options: str = ''
     external_tool: str = ""
     anki_media_collection: str = ""
+    mining_from_history_grab_all_audio: bool = False
 
 
 @dataclass_json
 @dataclass
 class OBS:
     enabled: bool = True
+    open_obs: bool = True
+    close_obs: bool = False
     host: str = "localhost"
     port: int = 4455
     password: str = "your_password"
@@ -131,6 +136,7 @@ class OBS:
 class Hotkeys:
     reset_line: str = 'f5'
     take_screenshot: str = 'f6'
+    open_utility: str = 'ctrl+m'
 
 
 @dataclass_json

GameSentenceMiner/ffmpeg.py

@@ -185,14 +185,14 @@ def trim_audio_based_on_last_line(untrimmed_audio, video_path, line_time, next_l
     ffmpeg_command = ffmpeg_base_command_list + [
         "-i", untrimmed_audio,
         "-ss", start_trim_time]
-    if next_line and next_line > line_time:
+    if next_line and next_line > line_time and not get_config().audio.mining_from_history_grab_all_audio:
         end_total_seconds = total_seconds + (next_line - line_time).total_seconds() + 1
         hours, remainder = divmod(end_total_seconds, 3600)
         minutes, seconds = divmod(remainder, 60)
         end_trim_time = "{:02}:{:02}:{:06.3f}".format(int(hours), int(minutes), seconds)
         ffmpeg_command.extend(['-to', end_trim_time])
         logger.info(
-            f"Looks like Clipboard/Websocket was modified before the script knew about the anki card! Trimming end of video to {end_trim_time}")
+            f"Looks Like this is mining from History, or Multiple Lines were selected Trimming end of audio to {end_trim_time}")
 
     ffmpeg_command.extend([
         "-c", "copy",  # Using copy to avoid re-encoding, adjust if needed

GameSentenceMiner/gametext.py

@@ -1,24 +1,27 @@
 import asyncio
+import re
 import threading
 import time
 from collections import OrderedDict
 from datetime import datetime
+from typing import Callable
 
 import pyperclip
 import websockets
 
-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
 
 
-previous_line = ''
-previous_line_time = datetime.now()
+current_line = ''
+current_line_after_regex = ''
+current_line_time = datetime.now()
 
 line_history = OrderedDict()
 reconnecting = False
+multi_mine_event_bus: Callable[[str, datetime], None] = None
 
 
 class ClipboardMonitor(threading.Thread):
@@ -28,25 +31,22 @@ class ClipboardMonitor(threading.Thread):
         self.daemon = True
 
     def run(self):
-        global previous_line_time, previous_line, line_history
+        global current_line_time, current_line, line_history
 
         # Initial clipboard content
-        previous_line = pyperclip.paste()
+        current_line = pyperclip.paste()
 
         while True:
             current_clipboard = pyperclip.paste()
 
-            if current_clipboard != previous_line:
-                previous_line = current_clipboard
-                previous_line_time = datetime.now()
-                line_history[previous_line] = previous_line_time
-                util.use_previous_audio = False
+            if current_clipboard != current_line:
+                handle_new_text_event(current_clipboard)
 
             time.sleep(0.05)
 
 
 async def listen_websocket():
-    global previous_line, previous_line_time, line_history, reconnecting
+    global current_line, current_line_time, line_history, reconnecting
     while True:
         try:
             async with websockets.connect(f'ws://{get_config().general.websocket_uri}', ping_interval=None) as websocket:
@@ -62,33 +62,41 @@ async def listen_websocket():
                             current_clipboard = data["sentence"]
                     except json.JSONDecodeError:
                         current_clipboard = message
-
-                    if current_clipboard != previous_line:
-                        previous_line = current_clipboard
-                        previous_line_time = datetime.now()
-                        line_history[previous_line] = previous_line_time
-                        util.use_previous_audio = False
-
+                    if current_clipboard != current_line:
+                        handle_new_text_event(current_clipboard)
         except (websockets.ConnectionClosed, ConnectionError) as e:
             if not reconnecting:
                 logger.warning(f"Texthooker WebSocket connection lost: {e}. Attempting to Reconnect...")
             reconnecting = True
             await asyncio.sleep(5)
 
+def handle_new_text_event(current_clipboard):
+    global current_line, current_line_time, line_history, 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_time = datetime.now()
+    line_history[current_line_after_regex] = current_line_time
+    multi_mine_event_bus(current_line_after_regex, current_line_time)
+    logger.debug(f"New Line: {current_clipboard}")
+
 
 def reset_line_hotkey_pressed():
-    global previous_line_time
+    global current_line_time
     logger.info("LINE RESET HOTKEY PRESSED")
-    previous_line_time = datetime.now()
-    line_history[previous_line] = previous_line_time
-    util.use_previous_audio = False
+    current_line_time = datetime.now()
+    line_history[current_line_after_regex] = current_line_time
 
 
 def run_websocket_listener():
     asyncio.run(listen_websocket())
 
 
-def start_text_monitor():
+def start_text_monitor(send_to_mine_event_bus):
+    global multi_mine_event_bus
+    multi_mine_event_bus = send_to_mine_event_bus
     if get_config().general.use_websocket:
         text_thread = threading.Thread(target=run_websocket_listener, daemon=True)
     else:
@@ -101,9 +109,9 @@ def get_line_timing(last_note):
         return SequenceMatcher(None, a, b).ratio()
 
     if not last_note:
-        return previous_line_time, 0
+        return current_line_time, 0
 
-    line_time = previous_line_time
+    line_time = current_line_time
     next_line = 0
     prev_clip_time = 0
 
@@ -154,4 +162,27 @@ def get_last_two_sentences(last_note):
         logger.debug("Couldn't find lines in history, using last two lines")
         return lines[-1][0] if lines else '', lines[-2][0] if len(lines) > 1 else ''
 
-    return current_line, prev_line
+    return current_line, prev_line
+
+
+def get_line_and_future_lines(last_note):
+    def similar(a, b):
+        return SequenceMatcher(None, a, b).ratio()
+    lines = list(line_history.items())
+
+    if not last_note:
+        return []
+
+    sentence = last_note['fields'][get_config().anki.sentence_field]['value']
+    found_lines = []
+    if sentence:
+        found = False
+        for i, (line, clip_time) in enumerate(lines):
+            similarity = similar(remove_html_tags(sentence), line)
+            logger.debug(f"Comparing: {remove_html_tags(sentence)} with {line} - Similarity: {similarity}")
+            if found:
+                found_lines.append(line)
+            if similarity >= 0.60 or line in remove_html_tags(sentence):  # 80% similarity threshold
+                found = True
+                found_lines.append(line)
+    return found_lines

GameSentenceMiner/gsm.py

@@ -2,6 +2,7 @@ import signal
 import subprocess
 import sys
 import time
+import ttkbootstrap as ttk
 from subprocess import Popen
 
 import keyboard
@@ -11,6 +12,7 @@ from pystray import Icon, Menu, MenuItem
 from watchdog.events import FileSystemEventHandler
 from watchdog.observers import Observer
 
+from GameSentenceMiner import utility_gui
 from GameSentenceMiner import anki
 from GameSentenceMiner import config_gui
 from GameSentenceMiner import configuration
@@ -32,9 +34,11 @@ if is_windows():
 obs_process: Popen = None
 procs_to_close = []
 settings_window: config_gui.ConfigApp = None
+utility_window: utility_gui.UtilityApp = None
 obs_paused = False
 icon: Icon
 menu: Menu
+root = None
 
 
 class VideoToAudioHandler(FileSystemEventHandler):
@@ -60,21 +64,22 @@ class VideoToAudioHandler(FileSystemEventHandler):
                     logger.error(
                         f"Video was unusually small, potentially empty! Check OBS for Correct Scene Settings! Path: {video_path}")
                     return
-                util.use_previous_audio = True
                 last_note = None
                 logger.debug("Attempting to get last anki card")
                 if get_config().anki.update_anki:
                     last_note = anki.get_last_anki_card()
                 if get_config().features.backfill_audio:
-                    last_note = anki.get_cards_by_sentence(gametext.previous_line)
+                    last_note = anki.get_cards_by_sentence(gametext.current_line)
                 line_time, next_line_time = get_line_timing(last_note)
+                if utility_window.lines_selected():
+                    line_time, next_line_time = utility_window.get_selected_times()
                 ss_timing = 0
                 if line_time and next_line_time:
                     ss_timing = ffmpeg.get_screenshot_time(video_path, line_time)
                 if last_note:
                     logger.debug(json.dumps(last_note))
 
-                note = anki.get_initial_card_info(last_note)
+                note = anki.get_initial_card_info(last_note, utility_window.get_selected_lines())
 
                 tango = last_note['fields'][get_config().anki.word_field]['value'] if last_note else ''
 
@@ -106,6 +111,7 @@ class VideoToAudioHandler(FileSystemEventHandler):
             os.remove(video_path)  # Optionally remove the video after conversion
         if get_config().paths.remove_audio and os.path.exists(vad_trimmed_audio):
             os.remove(vad_trimmed_audio)  # Optionally remove the screenshot after conversion
+        utility_window.reset_checkboxes()
 
     @staticmethod
     def get_audio(line_time, next_line_time, video_path):
@@ -150,10 +156,11 @@ def initialize(reloading=False):
             download_obs_if_needed()
             download_ffmpeg_if_needed()
         if get_config().obs.enabled:
-            obs_process = obs.start_obs()
+            if get_config().obs.open_obs:
+                obs_process = obs.start_obs()
             obs.connect_to_obs(start_replay=True)
             anki.start_monitoring_anki()
-        gametext.start_text_monitor()
+        gametext.start_text_monitor(utility_window.add_text)
         os.makedirs(get_config().paths.folder_to_watch, exist_ok=True)
         os.makedirs(get_config().paths.screenshot_destination, exist_ok=True)
         os.makedirs(get_config().paths.audio_destination, exist_ok=True)
@@ -175,6 +182,7 @@ def initial_checks():
 def register_hotkeys():
     keyboard.add_hotkey(get_config().hotkeys.reset_line, gametext.reset_line_hotkey_pressed)
     keyboard.add_hotkey(get_config().hotkeys.take_screenshot, get_screenshot)
+    keyboard.add_hotkey(get_config().hotkeys.open_utility, open_multimine)
 
 
 def get_screenshot():
@@ -189,7 +197,7 @@ def get_screenshot():
             if last_note:
                 logger.debug(json.dumps(last_note))
             if get_config().features.backfill_audio:
-                last_note = anki.get_cards_by_sentence(gametext.previous_line)
+                last_note = anki.get_cards_by_sentence(gametext.current_line)
             if last_note:
                 anki.add_image_to_card(last_note, encoded_image)
                 notification.send_screenshot_updated(last_note['fields'][get_config().anki.word_field]['value'])
@@ -219,11 +227,14 @@ def create_image():
 
     return image
 
-
 def open_settings():
     obs.update_current_game()
     settings_window.show()
 
+def open_multimine():
+    obs.update_current_game()
+    utility_window.show()
+
 
 def open_log():
     """Function to handle opening log."""
@@ -267,6 +278,7 @@ def update_icon():
 
     menu = Menu(
         MenuItem("Open Settings", open_settings),
+        MenuItem("Open Multi-Mine GUI", open_multimine),
         MenuItem("Open Log", open_log),
         MenuItem("Toggle Replay Buffer", play_pause),
         MenuItem("Restart OBS", restart_obs),
@@ -299,6 +311,7 @@ def run_tray():
 
     menu = Menu(
         MenuItem("Open Settings", open_settings),
+        MenuItem("Open Multi-Mine GUI", open_multimine),
         MenuItem("Open Log", open_log),
         MenuItem("Toggle Replay Buffer", play_pause),
         MenuItem("Restart OBS", restart_obs),
@@ -331,7 +344,8 @@ def cleanup():
         if get_config().obs.start_buffer:
             obs.stop_replay_buffer()
     obs.disconnect_from_obs()
-    close_obs()
+    if get_config().obs.close_obs:
+        close_obs()
 
     proc: Popen
     for proc in procs_to_close:
@@ -363,8 +377,11 @@ def handle_exit():
 
 
 def main(reloading=False, do_config_input=True):
-    global settings_window
+    global root, settings_window, utility_window
     logger.info("Script started.")
+    root = ttk.Window(themename='darkly')
+    settings_window = config_gui.ConfigApp(root)
+    utility_window = utility_gui.UtilityApp(root)
     initialize(reloading)
     initial_checks()
     event_handler = VideoToAudioHandler()
@@ -385,14 +402,13 @@ def main(reloading=False, do_config_input=True):
     util.run_new_thread(run_tray)
 
     try:
-        settings_window = config_gui.ConfigApp()
         if get_config().general.check_for_update_on_startup:
-            settings_window.window.after(0, settings_window.check_update)
+            root.after(0, settings_window.check_update)
         if get_config().general.open_config_on_startup:
-            settings_window.window.after(0, settings_window.show)
+            root.after(0, settings_window.show)
         settings_window.add_save_hook(update_icon)
         settings_window.on_exit = exit_program
-        settings_window.window.mainloop()
+        root.mainloop()
     except KeyboardInterrupt:
         cleanup()
 

GameSentenceMiner/util.py

@@ -14,10 +14,16 @@ 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
-use_previous_audio = False
 keep_running = True
 lock = threading.Lock()
+last_mined_line = None
 
+def get_last_mined_line():
+    return last_mined_line
+
+def set_last_mined_line(line):
+    global last_mined_line
+    last_mined_line = line
 
 def run_new_thread(func):
     thread = threading.Thread(target=func, daemon=True)

GameSentenceMiner/utility_gui.py

@@ -0,0 +1,127 @@
+import tkinter as tk
+from tkinter import ttk
+
+from GameSentenceMiner.configuration import logger
+
+
+class UtilityApp:
+    def __init__(self, root):
+        self.root = root
+
+        self.items = []
+        self.checkboxes = []
+        self.multi_mine_window = None  # Store the multi-mine window reference
+        self.checkbox_frame = None
+
+        style = ttk.Style()
+        style.configure("TCheckbutton", font=("Arial", 20))  # Change the font and size
+
+    # def show(self):
+    #     if self.multi_mine_window is None or not tk.Toplevel.winfo_exists(self.multi_mine_window):
+    #         self.multi_mine_window = tk.Toplevel(self.root)
+    #         self.multi_mine_window.title("Multi-Mine Window")
+    #         self.update_multi_mine_window()
+    #
+    def show(self):
+        """ Open the multi-mine window only if it doesn't exist. """
+        if not self.multi_mine_window or not tk.Toplevel.winfo_exists(self.multi_mine_window):
+            logger.info("opening multi-mine_window")
+            self.multi_mine_window = tk.Toplevel(self.root)
+            self.multi_mine_window.title("Multi Mine Window")
+
+            self.multi_mine_window.minsize(800, 400)  # Set a minimum size to prevent shrinking too
+
+            self.checkbox_frame = ttk.Frame(self.multi_mine_window)
+            self.checkbox_frame.pack(padx=10, pady=10, fill="both", expand=True)
+
+            # Add existing items
+            for text, var, time in self.items:
+                self.add_checkbox_to_gui(text, var, time)
+        else:
+            self.multi_mine_window.deiconify()
+            self.multi_mine_window.lift()
+
+    def add_text(self, text, time):
+        if text:
+            var = tk.BooleanVar()
+            self.items.append((text, var, time))
+
+            # Remove the first checkbox if there are more than 10
+            if len(self.items) > 10:
+                self.checkboxes[0].destroy()
+                self.checkboxes.pop(0)
+                self.items.pop(0)
+
+            if self.multi_mine_window and tk.Toplevel.winfo_exists(self.multi_mine_window):
+                self.add_checkbox_to_gui(text, var, time)
+
+    def add_checkbox_to_gui(self, text, var, time):
+        """ Add a single checkbox without repainting everything. """
+        if self.checkbox_frame:
+            chk = ttk.Checkbutton(self.checkbox_frame, text=f"{time.strftime('%H:%M:%S')} - {text}", variable=var)
+            chk.pack(anchor='w')
+            self.checkboxes.append(chk)
+
+
+    # def update_multi_mine_window(self):
+    #     for widget in self.multi_mine_window.winfo_children():
+    #         widget.destroy()
+    #
+    #     for i, (text, var, time) in enumerate(self.items):
+    #         time: datetime
+    #         chk = ttk.Checkbutton(self.checkbox_frame, text=f"{time.strftime('%H:%M:%S')} - {text}", variable=var)
+    #         chk.pack(anchor='w')
+
+    def get_selected_lines(self):
+        filtered_items = [text for text, var, _ in self.items if var.get()]
+        return filtered_items if len(filtered_items) >= 2 else []
+
+    def get_selected_times(self):
+        filtered_times = [time for _, var, time in self.items if var.get()]
+
+        if len(filtered_times) >= 2:
+            logger.info(filtered_times)
+            # Find the index of the last checked checkbox
+            last_checked_index = max(i for i, (_, var, _) in enumerate(self.items) if var.get())
+
+            # Get the time AFTER the last checked checkbox, if it exists
+            if last_checked_index + 1 < len(self.items):
+                next_time = self.items[last_checked_index + 1][2]
+            else:
+                next_time = 0
+
+            return filtered_times[0], next_time
+
+        return None
+
+    def lines_selected(self):
+        filter_times = [time for _, var, time in self.items if var.get()]
+        if len(filter_times) >= 2:
+            return True
+        return False
+
+    # def validate_checkboxes(self, *args):
+    #     logger.debug("Validating checkboxes")
+    #     found_checked = False
+    #     found_unchecked = False
+    #     for _, var in self.items:
+    #         if var.get():
+    #             if found_unchecked:
+    #                 messagebox.showinfo("Invalid", "Can only select neighboring checkboxes.")
+    #                 break
+    #             found_checked = True
+    #         if found_checked and not var.get():
+    #             found_unchecked = True
+
+    def reset_checkboxes(self):
+        for _, var, _ in self.items:
+            var.set(False)
+        # if self.multi_mine_window:
+        #     for checkbox in self.checkboxes:
+        #         checkbox.set(False)
+
+
+if __name__ == "__main__":
+    root = tk.Tk()
+    app = UtilityApp(root)
+    root.mainloop()

{GameSentenceMiner-2.2.4.dist-info → GameSentenceMiner-2.3.1.dist-info}/METADATA

@@ -1,7 +1,7 @@
 Metadata-Version: 2.2
 Name: GameSentenceMiner
-Version: 2.2.4
-Summary: A tool for mining sentences from games. Update: Fix Previous Sentence When Mining from History
+Version: 2.3.1
+Summary: A tool for mining sentences from games. Update: Multi-Line Mining! Fixed!
 Author-email: Beangate <bpwhelan95@gmail.com>
 License: MIT License
 Project-URL: Homepage, https://github.com/bpwhelan/GameSentenceMiner

{GameSentenceMiner-2.2.4.dist-info → GameSentenceMiner-2.3.1.dist-info}/RECORD

@@ -1,15 +1,16 @@
 GameSentenceMiner/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-GameSentenceMiner/anki.py,sha256=urgly10zM7etTXfagK327TKWXVq146jqkpTmewoim7s,9238
-GameSentenceMiner/config_gui.py,sha256=EBl5TuzyqXUovq4YF-UQsl4W7DAzIpdzANI52AiTyoU,49743
-GameSentenceMiner/configuration.py,sha256=Wd4Cozdus_Tl33_Qz4twibBx6p_3_mHMzdZfZ-B1qI4,14124
-GameSentenceMiner/ffmpeg.py,sha256=txTpco-IGWtfF8vIiWUzrtgI5TA1xPVIK-WJWxU02mM,10878
-GameSentenceMiner/gametext.py,sha256=QQbZnV1eZ1DxwJl9fwfn8p6z1UjpSk6JRpxKmJ4CrUw,5210
-GameSentenceMiner/gsm.py,sha256=qDa8Q8bjBNnmVGLDqiEYLTC_ZyBkS3zw2SmP4Tc_h0o,16375
+GameSentenceMiner/anki.py,sha256=gpd_af7zrwuGyIfMAPvunZW1I0mVG2MBemVnikTVp5c,10151
+GameSentenceMiner/config_gui.py,sha256=B37GPeGtGNTJgFTor3M01Tw2iZYRRtHLYck6Q83-JRg,53460
+GameSentenceMiner/configuration.py,sha256=x50-InaGl70dHpWhdOAZJTIKj84EtVfTqEmIFCnDcvw,14348
+GameSentenceMiner/ffmpeg.py,sha256=VExJYWSFhYuWukIXgOiHufsoSROEDA8LnVQFG8srRGc,10924
+GameSentenceMiner/gametext.py,sha256=ckZGOHpGuvFE2zDNdaASSaMYi4JCFsyG2kYKCbZIQPo,6463
+GameSentenceMiner/gsm.py,sha256=l92vu9P06v5crBfka-TGjlSyqM7WG2ND4ZzWQVTY7ws,17103
 GameSentenceMiner/model.py,sha256=oh8VVT8T1UKekbmP6MGNgQ8jIuQ_7Rg4GPzDCn2kJo8,1999
 GameSentenceMiner/notification.py,sha256=WBaQWoPNhW4XqdPBUmxPBgjk0ngzH_4v9zMQ-XQAKC8,2010
 GameSentenceMiner/obs.py,sha256=3Flcjxy812VpF78EPI7sxlGx6yyM3GfqzlinW17SK20,6231
 GameSentenceMiner/package_updater.py,sha256=0uaLAp0WrWqostNTBWRS0laITjI9aN9Yt_6GXosS4NQ,1278
-GameSentenceMiner/util.py,sha256=cgKpPfRpouWI6tjE_35MWp8nXqRzXs3LvsYXWm5_DOg,4584
+GameSentenceMiner/util.py,sha256=MITweiFYaefWQF5nR8tZ9yE6vd_b-fLuP0MP1Y1U4K0,4720
+GameSentenceMiner/utility_gui.py,sha256=-T5b14Nx6KvNnBEmdVz0mWkXoYi-bZzHIce6ADwfVEQ,4701
 GameSentenceMiner/downloader/Untitled_json.py,sha256=RUUl2bbbCpUDUUS0fP0tdvf5FngZ7ILdA_J5TFYAXUQ,15272
 GameSentenceMiner/downloader/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 GameSentenceMiner/downloader/download_tools.py,sha256=M7vLo6_0QMuk1Ji4CsZqk1C2g7Bq6PyM29r7XNoP6Rw,6406
@@ -17,8 +18,8 @@ GameSentenceMiner/vad/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3h
 GameSentenceMiner/vad/silero_trim.py,sha256=syDJX_KbFmdyFFtnQqYTD0tICsUCJizYhs-atPgXtxA,1549
 GameSentenceMiner/vad/vosk_helper.py,sha256=-AAwK0cgOC5rK3_gL0sQgrPJ75E49g_PxZR4d5ckwc4,5826
 GameSentenceMiner/vad/whisper_helper.py,sha256=bpR1HVnJRn9H5u8XaHBqBJ6JwIjzqn-Fajps8QmQ4zc,3411
-GameSentenceMiner-2.2.4.dist-info/METADATA,sha256=-S903oxc3YHCUd7s_F97f0CARKRJgk3E-yZ5AZ2u8pQ,10141
-GameSentenceMiner-2.2.4.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-GameSentenceMiner-2.2.4.dist-info/entry_points.txt,sha256=2APEP25DbfjSxGeHtwBstMH8mulVhLkqF_b9bqzU6vQ,65
-GameSentenceMiner-2.2.4.dist-info/top_level.txt,sha256=V1hUY6xVSyUEohb0uDoN4UIE6rUZ_JYx8yMyPGX4PgQ,18
-GameSentenceMiner-2.2.4.dist-info/RECORD,,
+GameSentenceMiner-2.3.1.dist-info/METADATA,sha256=UN9Pn6JrUpTuIeMRBT3CAizAUNmVM9aTKw6DCBwxTOg,10120
+GameSentenceMiner-2.3.1.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+GameSentenceMiner-2.3.1.dist-info/entry_points.txt,sha256=2APEP25DbfjSxGeHtwBstMH8mulVhLkqF_b9bqzU6vQ,65
+GameSentenceMiner-2.3.1.dist-info/top_level.txt,sha256=V1hUY6xVSyUEohb0uDoN4UIE6rUZ_JYx8yMyPGX4PgQ,18
+GameSentenceMiner-2.3.1.dist-info/RECORD,,