GameSentenceMiner 2.3.7__py3-none-any.whl → 2.3.8__py3-none-any.whl

GameSentenceMiner/anki.py

@@ -1,5 +1,4 @@
 import base64
-import queue
 import subprocess
 import threading
 import time
@@ -11,7 +10,7 @@ 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.gametext import get_text_event
 from GameSentenceMiner.obs import get_current_game
 from GameSentenceMiner.util import remove_html_tags
 
@@ -26,7 +25,7 @@ card_queue = []
 
 
 def update_anki_card(last_note, note=None, audio_path='', video_path='', tango='', reuse_audio=False,
-                     should_update_audio=True, ss_time=0):
+                     should_update_audio=True, ss_time=0, game_line=None):
     global audio_in_anki, screenshot_in_anki, prev_screenshot_in_anki
     update_audio = should_update_audio and (get_config().anki.sentence_audio_field and not
     last_note['fields'][get_config().anki.sentence_audio_field][
@@ -44,12 +43,10 @@ def update_anki_card(last_note, note=None, audio_path='', video_path='', tango='
             if get_config().paths.remove_screenshot:
                 os.remove(screenshot)
         if get_config().anki.previous_image_field:
-            _, previous_sentence = get_last_two_sentences(last_note)
-            prev_screenshot = ffmpeg.get_screenshot(video_path, ffmpeg.get_screenshot_time(video_path, gametext.get_time_of_line(previous_sentence)))
+            prev_screenshot = ffmpeg.get_screenshot(video_path, ffmpeg.get_screenshot_time(video_path, game_line.prev))
             prev_screenshot_in_anki = store_media_file(prev_screenshot)
             if get_config().paths.remove_screenshot:
                 os.remove(prev_screenshot)
-        util.set_last_mined_line(get_sentence(last_note))
     audio_html = f"[sound:{audio_in_anki}]"
     image_html = f"<img src=\"{screenshot_in_anki}\">"
     prev_screenshot_html = f"<img src=\"{prev_screenshot_in_anki}\">"
@@ -122,7 +119,7 @@ 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)
+    game_line = get_text_event(last_note)
 
     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)
@@ -130,13 +127,13 @@ def get_initial_card_info(last_note, selected_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)
+        note['fields'][get_config().anki.sentence_field] = "".join([line.text for line in 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']}")
-    if get_config().anki.previous_sentence_field and previous_line and not \
+    if get_config().anki.previous_sentence_field and game_line.prev and not \
             last_note['fields'][get_config().anki.previous_sentence_field]['value']:
-        note['fields'][get_config().anki.previous_sentence_field] = previous_line
+        logger.debug(
+            f"Adding Previous Sentence: {get_config().anki.previous_sentence_field and game_line.prev.text and not last_note['fields'][get_config().anki.previous_sentence_field]['value']}")
+        note['fields'][get_config().anki.previous_sentence_field] = game_line.prev.text
     return note
 
 
@@ -227,7 +224,8 @@ def update_new_card():
     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)
+        with util.lock:
+            update_anki_card(last_card, note=get_initial_card_info(last_card, []), reuse_audio=True)
     else:
         logger.info("New card(s) detected! Added to Processing Queue!")
         card_queue.append(last_card)

GameSentenceMiner/config_gui.py

@@ -51,6 +51,7 @@ class HoverInfoWidget:
 class ConfigApp:
     def __init__(self, root):
         self.window = root
+        self.on_exit = None
         # self.window = ttk.Window(themename='darkly')
         self.window.title('GameSentenceMiner Configuration')
         self.window.protocol("WM_DELETE_WINDOW", self.hide)
@@ -82,10 +83,6 @@ class ConfigApp:
     def add_save_hook(self, func):
         on_save.append(func)
 
-    def add_exit_hook(self, func):
-        global exit_func
-        exit_func = func
-
     def show(self):
         obs.update_current_game()
         self.reload_settings()
@@ -103,7 +100,7 @@ class ConfigApp:
         if update_available:
             messagebox.showinfo("Update", "GSM Will Copy the Update Command to your clipboard, please run it in a terminal.")
             pyperclip.copy("pip install --upgrade GameSentenceMiner")
-            exit_func(None, None)
+            self.on_exit(None, None)
         else:
             messagebox.showinfo("No Update Found", "No update found.")
 

GameSentenceMiner/ffmpeg.py

@@ -5,6 +5,8 @@ import time
 from GameSentenceMiner import obs, util, configuration
 from GameSentenceMiner.configuration import *
 from GameSentenceMiner.util import *
+from GameSentenceMiner.gametext import initial_time
+
 
 def get_ffmpeg_path():
     return os.path.join(get_app_directory(), "ffmpeg", "ffmpeg.exe") if util.is_windows() else "ffmpeg"
@@ -47,7 +49,12 @@ def get_screenshot(video_file, time_from_end):
     return output_image
 
 
-def get_screenshot_time(video_path, line_time):
+def get_screenshot_time(video_path, game_line):
+    if game_line:
+        line_time = game_line.time
+    else:
+        line_time = initial_time
+
     file_length = get_video_duration(video_path)
     file_mod_time = get_file_modification_time(video_path)
 
@@ -115,7 +122,7 @@ def get_audio_codec(video_path):
         return None
 
 
-def get_audio_and_trim(video_path, line_time, next_line_time):
+def get_audio_and_trim(video_path, game_line, next_line_time):
     supported_formats = {
         'opus': 'libopus',
         'mp3': 'libmp3lame',
@@ -149,7 +156,7 @@ def get_audio_and_trim(video_path, line_time, next_line_time):
 
     subprocess.run(command)
 
-    return trim_audio_based_on_last_line(untrimmed_audio, video_path, line_time, next_line_time)
+    return trim_audio_based_on_last_line(untrimmed_audio, video_path, game_line, next_line_time)
 
 
 def get_video_duration(file_path):
@@ -167,12 +174,12 @@ def get_video_duration(file_path):
     return float(duration_info["format"]["duration"])  # Return the duration in seconds
 
 
-def trim_audio_based_on_last_line(untrimmed_audio, video_path, line_time, next_line):
+def trim_audio_based_on_last_line(untrimmed_audio, video_path, game_line, next_line):
     trimmed_audio = tempfile.NamedTemporaryFile(dir=configuration.get_temporary_directory(),
                                                 suffix=f".{get_config().audio.extension}").name
     file_mod_time = get_file_modification_time(video_path)
     file_length = get_video_duration(video_path)
-    time_delta = file_mod_time - line_time
+    time_delta = file_mod_time - game_line.time
     # Convert time_delta to FFmpeg-friendly format (HH:MM:SS.milliseconds)
     total_seconds = file_length - time_delta.total_seconds() + get_config().audio.beginning_offset
     if total_seconds < 0 or total_seconds >= file_length:
@@ -186,8 +193,8 @@ 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 and not get_config().audio.mining_from_history_grab_all_audio:
-        end_total_seconds = total_seconds + (next_line - line_time).total_seconds() + 1
+    if next_line and next_line > game_line.time and not get_config().audio.mining_from_history_grab_all_audio:
+        end_total_seconds = total_seconds + (next_line - game_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)

GameSentenceMiner/gametext.py

@@ -2,7 +2,6 @@ import asyncio
 import re
 import threading
 import time
-from collections import OrderedDict
 from datetime import datetime
 from typing import Callable
 
@@ -21,10 +20,61 @@ 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
 
+@dataclass
+class GameLine:
+    text: str
+    time: datetime
+    prev: 'GameLine'
+    next: 'GameLine'
+
+    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
+
+@dataclass
+class GameText:
+    values: list[GameLine]
+
+    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):
+        new_line = GameLine(line_text, datetime.now(), self.values[-1] if self.values else None, None)
+        if self.values:
+            self.values[-1].next = new_line
+        self.values.append(new_line)
+
+    def has_line(self, line_text) -> bool:
+        for game_line in self.values:
+            if game_line.text == line_text:
+                return True
+        return False
+
+line_history = GameText()
 
 class ClipboardMonitor(threading.Thread):
 
@@ -80,8 +130,8 @@ def handle_new_text_event(current_clipboard):
     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)
+    line_history.add_line(current_line_after_regex)
+    multi_mine_event_bus(line_history[-1])
     logger.debug(f"New Line: {current_clipboard}")
 
 
@@ -89,7 +139,6 @@ def reset_line_hotkey_pressed():
     global current_line_time
     logger.info("LINE RESET HOTKEY PRESSED")
     current_line_time = datetime.now()
-    line_history[current_line_after_regex] = current_line_time
     util.set_last_mined_line("")
 
 
@@ -107,72 +156,91 @@ def start_text_monitor(send_to_mine_event_bus):
     text_thread.start()
 
 
-def get_line_timing(last_note):
-    def similar(a, b):
-        return SequenceMatcher(None, a, b).ratio()
+# def get_line_timing(last_note):
+#     def similar(a, b):
+#         return SequenceMatcher(None, a, b).ratio()
+#
+#     if not last_note:
+#         return current_line_time, 0
+#
+#     lines = line_history.values
+#
+#     line_time = current_line_time
+#     next_line = 0
+#     prev_clip_time = 0
+#
+#     try:
+#         sentence = last_note['fields'][get_config().anki.sentence_field]['value']
+#         if sentence:
+#             for line in reversed(lines):
+#                 similarity = similar(remove_html_tags(sentence), line.text)
+#                 if similarity >= 0.60 or line.text in remove_html_tags(sentence):  # 80% similarity threshold
+#                     line_time = line.time
+#                     next_line = prev_clip_time
+#                     break
+#                 prev_clip_time = line.time
+#     except Exception as e:
+#         logger.error(f"Using Default clipboard/websocket timing - reason: {e}")
+#
+#     return line_time, next_line
+#
+#
+# def get_last_two_sentences(last_note) -> (str, str):
+#     def similar(a, b):
+#         return SequenceMatcher(None, a, b).ratio()
+#
+#     lines = line_history.values
+#
+#     if not last_note:
+#         return lines[-1].text if lines else '', lines[-2].text if len(lines) > 1 else ''
+#
+#     sentence = last_note['fields'][get_config().anki.sentence_field]['value']
+#     if not sentence:
+#         return lines[-1].text if lines else '', lines[-2].text if len(lines) > 1 else ''
+#
+#     current, previous = "", ""
+#     found = False
+#
+#     for line in reversed(lines):
+#         similarity = similar(remove_html_tags(sentence), line.text)
+#         logger.debug(f"Comparing: {remove_html_tags(sentence)} with {line.text} - Similarity: {similarity}")
+#         if found:
+#             previous = line.text
+#             break
+#         if similarity >= 0.60 or line.text in remove_html_tags(sentence):
+#             found = True
+#             current = line.text
+#
+#     if not current or not previous:
+#         logger.debug("Couldn't find lines in history, using last two lines")
+#         return lines[-1].text if lines else '', lines[-2].text if len(lines) > 1 else ''
+#
+#     return current, previous
+
+def similar(a, b):
+    return SequenceMatcher(None, a, b).ratio()
+
+def get_text_event(last_note) -> GameLine:
+    lines = line_history.values
 
     if not last_note:
-        return current_line_time, 0
-
-    line_time = current_line_time
-    next_line = 0
-    prev_clip_time = 0
-
-    try:
-        sentence = last_note['fields'][get_config().anki.sentence_field]['value']
-        if sentence:
-            for i, (line, clip_time) in enumerate(reversed(line_history.items())):
-                similarity = similar(remove_html_tags(sentence), line)
-                if similarity >= 0.60 or line in remove_html_tags(sentence):  # 80% similarity threshold
-                    line_time = clip_time
-                    next_line = prev_clip_time
-                    break
-                prev_clip_time = clip_time
-    except Exception as e:
-        logger.error(f"Using Default clipboard/websocket timing - reason: {e}")
-
-    return line_time, next_line
-
-
-def get_last_two_sentences(last_note):
-    def similar(a, b):
-        return SequenceMatcher(None, a, b).ratio()
-    lines = list(line_history.items())
-
-    if not last_note:
-        return lines[-1][0] if lines else '', lines[-2][0] if len(lines) > 1 else ''
-
-    current = ""
-    previous = ""
+        return lines[-1]
 
     sentence = last_note['fields'][get_config().anki.sentence_field]['value']
-    if sentence:
-        found = False
-        for i, (line, clip_time) in enumerate(reversed(lines)):
-            similarity = similar(remove_html_tags(sentence), line)
-            logger.debug(f"Comparing: {remove_html_tags(sentence)} with {line} - Similarity: {similarity}")
-            if found:
-                previous = line
-                break
-            if similarity >= 0.60 or line in remove_html_tags(sentence):  # 80% similarity threshold
-                found = True
-                current = line
-
-    logger.debug(f"Current Line: {current}")
-    logger.debug(f"Previous Line: {previous}")
+    if not sentence:
+        return lines[-1]
 
-    if not current or not previous:
-        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 ''
+    for line in reversed(lines):
+        similarity = similar(remove_html_tags(sentence), line.text)
+        logger.debug(f"Comparing: {remove_html_tags(sentence)} with {line.text} - Similarity: {similarity}")
+        if similarity >= 0.60 or line.text in remove_html_tags(sentence):
+            return line
 
-    return current, previous
+    logger.debug("Couldn't find a match in history, using last event")
+    return lines[-1]
 
 
 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 []
 
@@ -180,18 +248,27 @@ def get_line_and_future_lines(last_note):
     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}")
+        for line in line_history.values:
+            similarity = similar(remove_html_tags(sentence), line.text)
+            logger.debug(f"Comparing: {remove_html_tags(sentence)} with {line.text} - Similarity: {similarity}")
             if found:
-                found_lines.append(line)
-            if similarity >= 0.60 or line in remove_html_tags(sentence):  # 80% similarity threshold
+                found_lines.append(line.text)
+            if similarity >= 0.60 or line.text in remove_html_tags(sentence):  # 80% similarity threshold
                 found = True
-                found_lines.append(line)
+                found_lines.append(line.text)
     return found_lines
 
+def get_mined_line(last_note, lines):
+    if not last_note:
+        return lines[0]
+
+    sentence = last_note['fields'][get_config().anki.sentence_field]['value']
+    for line2 in lines:
+        similarity = similar(remove_html_tags(sentence), line2.text)
+        if similarity >= 0.60 or line2.text in remove_html_tags(sentence):
+            return line2
+    return lines[0]
+
 
 def get_time_of_line(line):
-    if line and line in line_history:
-        return line_history[line]
-    return initial_time
+    return line_history.get_time(line)

GameSentenceMiner/gsm.py

@@ -25,7 +25,7 @@ from GameSentenceMiner.downloader.download_tools import download_obs_if_needed,
 from GameSentenceMiner.vad import vosk_helper, silero_trim, whisper_helper
 from GameSentenceMiner.configuration import *
 from GameSentenceMiner.ffmpeg import get_audio_and_trim
-from GameSentenceMiner.gametext import get_line_timing
+from GameSentenceMiner.gametext import get_text_event, get_mined_line
 from GameSentenceMiner.util import *
 
 if is_windows():
@@ -57,6 +57,7 @@ class VideoToAudioHandler(FileSystemEventHandler):
             if anki.card_queue and len(anki.card_queue) > 0:
                 last_note = anki.card_queue.pop(0)
             with util.lock:
+                util.set_last_mined_line(anki.get_sentence(last_note))
                 if os.path.exists(video_path) and os.access(video_path, os.R_OK):
                     logger.debug(f"Video found and is readable: {video_path}")
 
@@ -73,12 +74,23 @@ class VideoToAudioHandler(FileSystemEventHandler):
                         last_note = anki.get_last_anki_card()
                     if get_config().features.backfill_audio:
                         last_note = anki.get_cards_by_sentence(gametext.current_line)
-                line_time, next_line_time = get_line_timing(last_note)
+                line_cutoff = None
+                start_line = None
+                mined_line = get_text_event(last_note)
+                if mined_line:
+                    start_line = mined_line
+                    if mined_line.next:
+                        line_cutoff = mined_line.next.time
+
                 if utility_window.lines_selected():
-                    line_time, next_line_time = utility_window.get_selected_times()
+                    lines = utility_window.get_selected_lines()
+                    start_line = lines[0]
+                    mined_line = get_mined_line(last_note, lines)
+                    line_cutoff = utility_window.get_next_line_timing()
+
                 ss_timing = 0
-                if line_time and next_line_time or line_time and get_config().screenshot.use_beginning_of_line_as_screenshot:
-                    ss_timing = ffmpeg.get_screenshot_time(video_path, line_time)
+                if mined_line and line_cutoff or mined_line and get_config().screenshot.use_beginning_of_line_as_screenshot:
+                    ss_timing = ffmpeg.get_screenshot_time(video_path, mined_line)
                 if last_note:
                     logger.debug(json.dumps(last_note))
 
@@ -89,8 +101,8 @@ class VideoToAudioHandler(FileSystemEventHandler):
                 if get_config().anki.sentence_audio_field:
                     logger.debug("Attempting to get audio from video")
                     final_audio_output, should_update_audio, vad_trimmed_audio = VideoToAudioHandler.get_audio(
-                        line_time,
-                        next_line_time,
+                        start_line,
+                        line_cutoff,
                         video_path)
                 else:
                     final_audio_output = ""
@@ -103,7 +115,8 @@ class VideoToAudioHandler(FileSystemEventHandler):
                         anki.update_anki_card(last_note, note, audio_path=final_audio_output, video_path=video_path,
                                               tango=tango,
                                               should_update_audio=should_update_audio,
-                                              ss_time=ss_timing)
+                                              ss_time=ss_timing,
+                                              game_line=start_line)
                     elif get_config().features.notify_on_update and should_update_audio:
                         notification.send_audio_generated_notification(vad_trimmed_audio)
                 except Exception as e:
@@ -118,8 +131,8 @@ class VideoToAudioHandler(FileSystemEventHandler):
         utility_window.reset_checkboxes()
 
     @staticmethod
-    def get_audio(line_time, next_line_time, video_path):
-        trimmed_audio = get_audio_and_trim(video_path, line_time, next_line_time)
+    def get_audio(game_line, next_line_time, video_path):
+        trimmed_audio = get_audio_and_trim(video_path, game_line, next_line_time)
         vad_trimmed_audio = make_unique_file_name(
             f"{os.path.abspath(configuration.get_temporary_directory())}/{obs.get_current_game(sanitize=True)}.{get_config().audio.extension}")
         final_audio_output = make_unique_file_name(os.path.join(get_config().paths.audio_destination, f"{obs.get_current_game(sanitize=True)}.{get_config().audio.extension}"))
@@ -259,10 +272,12 @@ def open_log():
     logger.info("Log opened.")
 
 
-def exit_program(icon, item):
+def exit_program(passed_icon, item):
     """Exit the application."""
+    if not passed_icon:
+        passed_icon = icon
     logger.info("Exiting...")
-    icon.stop()
+    passed_icon.stop()
     cleanup()
 
 

GameSentenceMiner/utility_gui.py

@@ -35,16 +35,16 @@ class UtilityApp:
             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)
+            for line, var in self.items:
+                self.add_checkbox_to_gui(line, var)
         else:
             self.multi_mine_window.deiconify()
             self.multi_mine_window.lift()
 
-    def add_text(self, text, time):
-        if text:
+    def add_text(self, line):
+        if line.text:
             var = tk.BooleanVar()
-            self.items.append((text, var, time))
+            self.items.append((line, var))
 
             if len(self.items) > 10:
                 if self.checkboxes:
@@ -53,12 +53,12 @@ class UtilityApp:
                 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)
+                self.add_checkbox_to_gui(line, var)
 
-    def add_checkbox_to_gui(self, text, var, time):
+    def add_checkbox_to_gui(self, line, var):
         """ 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 = ttk.Checkbutton(self.checkbox_frame, text=f"{line.time.strftime('%H:%M:%S')} - {line.text}", variable=var)
             chk.pack(anchor='w')
             self.checkboxes.append(chk)
 
@@ -73,30 +73,31 @@ class UtilityApp:
     #         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 []
+        filtered_items = [line for line, var in self.items if var.get()]
+        return filtered_items if len(filtered_items) > 0 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())
+    def get_next_line_timing(self):
+        selected_lines = [line for line, var in self.items if var.get()]
+
+        if len(selected_lines) >= 2:
+            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]
+                next_time = self.items[last_checked_index + 1][0].time
             else:
                 next_time = 0
 
-            return filtered_times[0], next_time
+            return next_time
+        if len(selected_lines) == 1:
+            return selected_lines[0].get_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:
+        filter_times = [line.time for line, var in self.items if var.get()]
+        if len(filter_times) > 0:
             return True
         return False
 
@@ -114,7 +115,7 @@ class UtilityApp:
     #             found_unchecked = True
 
     def reset_checkboxes(self):
-        for _, var, _ in self.items:
+        for _, var in self.items:
             var.set(False)
         # if self.multi_mine_window:
         #     for checkbox in self.checkboxes:

{GameSentenceMiner-2.3.7.dist-info → gamesentenceminer-2.3.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: GameSentenceMiner
-Version: 2.3.7
+Version: 2.3.8
 Summary: A tool for mining sentences from games. Update: Multi-Line Mining! Fixed!
 Author-email: Beangate <bpwhelan95@gmail.com>
 License: MIT License

{GameSentenceMiner-2.3.7.dist-info → gamesentenceminer-2.3.8.dist-info}/RECORD

@@ -1,16 +1,16 @@
 GameSentenceMiner/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-GameSentenceMiner/anki.py,sha256=bg_RKaY8bT19hfQQ6BJoPp5G634-xDqTryONLUoK6Z8,10691
-GameSentenceMiner/config_gui.py,sha256=-Jq3ZZZxsLyIaXkQtYVvDeiH3PC4PnrYHxh_wD22174,54270
+GameSentenceMiner/anki.py,sha256=QBrA-WVQfK4KjKB2Wm1WDW7BlVy8MF6-1ByTApVzPVA,10576
+GameSentenceMiner/config_gui.py,sha256=nk0-aFTrqtygbLOqnQMSUqHQFda4bRhFG18Tz3Ansn4,54215
 GameSentenceMiner/configuration.py,sha256=_nS-9sWNn97Zdv2V4Ypt_hf4PL6oLa5oK2Z7rWrqEmc,14405
-GameSentenceMiner/ffmpeg.py,sha256=RN3XlO5uPmD-76wvMZi1CIom0aTq8aNZSZUjLacfJbo,10977
-GameSentenceMiner/gametext.py,sha256=qK9GA9Mn081Ih6kGmunvDhG8HZ5x1RhEco81F2sK4g4,6658
-GameSentenceMiner/gsm.py,sha256=pUKOiJxxSHBqBR3v3U8YiHdwqMxAwvz5keDAGUKGQQA,18388
+GameSentenceMiner/ffmpeg.py,sha256=4nyl_kdXi_trzDyhhjSmszN0BlFF-McAFyOghvCyl34,11142
+GameSentenceMiner/gametext.py,sha256=BsVECzyh91nuQzBn9ZkdWLJXhtIekoPyKRNgsuB_wP4,8917
+GameSentenceMiner/gsm.py,sha256=dILfQrWQ-cWKRAaKswnzBMNNlBqC7_BEZUSFxe-8PMk,18994
 GameSentenceMiner/model.py,sha256=oh8VVT8T1UKekbmP6MGNgQ8jIuQ_7Rg4GPzDCn2kJo8,1999
 GameSentenceMiner/notification.py,sha256=WBaQWoPNhW4XqdPBUmxPBgjk0ngzH_4v9zMQ-XQAKC8,2010
 GameSentenceMiner/obs.py,sha256=8ImXAVUWa4JdzwcBOEFShlZRZzh1dCvdpD1aEGhQfbU,6566
 GameSentenceMiner/package_updater.py,sha256=0uaLAp0WrWqostNTBWRS0laITjI9aN9Yt_6GXosS4NQ,1278
 GameSentenceMiner/util.py,sha256=MITweiFYaefWQF5nR8tZ9yE6vd_b-fLuP0MP1Y1U4K0,4720
-GameSentenceMiner/utility_gui.py,sha256=Wa1YLitHzjbzkvvOtt3HbmFnplfajKR3N4aB2fTOlnM,4679
+GameSentenceMiner/utility_gui.py,sha256=EtQUnCgTTdzKJE0iCJiHjjc_c6tc7JtI09LRg4_iy8Y,4555
 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
@@ -18,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.3.7.dist-info/METADATA,sha256=1O5tVlKwbajXxt2uSpqH1_yOgt8zHMWo4DTyFKKc3iI,10120
-GameSentenceMiner-2.3.7.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-GameSentenceMiner-2.3.7.dist-info/entry_points.txt,sha256=2APEP25DbfjSxGeHtwBstMH8mulVhLkqF_b9bqzU6vQ,65
-GameSentenceMiner-2.3.7.dist-info/top_level.txt,sha256=V1hUY6xVSyUEohb0uDoN4UIE6rUZ_JYx8yMyPGX4PgQ,18
-GameSentenceMiner-2.3.7.dist-info/RECORD,,
+gamesentenceminer-2.3.8.dist-info/METADATA,sha256=PYvBuu_5hcR_2cEbow_2BhBjM93wjIkCl5gxfGaCGhQ,10120
+gamesentenceminer-2.3.8.dist-info/WHEEL,sha256=jB7zZ3N9hIM9adW7qlTAyycLYW9npaWKLRzaoVcLKcM,91
+gamesentenceminer-2.3.8.dist-info/entry_points.txt,sha256=2APEP25DbfjSxGeHtwBstMH8mulVhLkqF_b9bqzU6vQ,65
+gamesentenceminer-2.3.8.dist-info/top_level.txt,sha256=V1hUY6xVSyUEohb0uDoN4UIE6rUZ_JYx8yMyPGX4PgQ,18
+gamesentenceminer-2.3.8.dist-info/RECORD,,

{GameSentenceMiner-2.3.7.dist-info → gamesentenceminer-2.3.8.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.8.0)
+Generator: setuptools (75.8.2)
 Root-Is-Purelib: true
 Tag: py3-none-any