GameSentenceMiner 2.8.49__tar.gz → 2.8.51__tar.gz

{gamesentenceminer-2.8.49 → gamesentenceminer-2.8.51}/GameSentenceMiner/anki.py

@@ -40,12 +40,13 @@ def update_anki_card(last_note: AnkiCard, note=None, audio_path='', video_path='
         if update_audio:
             audio_in_anki = store_media_file(audio_path)
         if update_picture:
+            logger.info("Getting Screenshot...")
             screenshot = ffmpeg.get_screenshot(video_path, ss_time)
             wait_for_stable_file(screenshot)
             screenshot_in_anki = store_media_file(screenshot)
             if get_config().paths.remove_screenshot:
                 os.remove(screenshot)
-        if get_config().anki.previous_image_field:
+        if get_config().anki.previous_image_field and game_line.prev:
             prev_screenshot = ffmpeg.get_screenshot_for_line(video_path, selected_lines[0].prev if selected_lines else game_line.prev)
             wait_for_stable_file(prev_screenshot)
             prev_screenshot_in_anki = store_media_file(prev_screenshot)
@@ -184,7 +185,7 @@ def store_media_file(path):
         return invoke('storeMediaFile', filename=path, data=convert_to_base64(path))
     except Exception as e:
         logger.error(f"Error storing media file, check anki card for blank media fields: {e}")
-        return "None"
+        return None
 
 
 def convert_to_base64(file_path):

{gamesentenceminer-2.8.49 → gamesentenceminer-2.8.51}/GameSentenceMiner/configuration.py

@@ -46,7 +46,7 @@ class General:
     use_both_clipboard_and_websocket: bool = False
     websocket_uri: str = 'localhost:6677'
     open_config_on_startup: bool = False
-    open_multimine_on_startup: bool = False
+    open_multimine_on_startup: bool = True
     texthook_replacement_regex: str = ""
     texthooker_port: int = 55000
 

{gamesentenceminer-2.8.49 → gamesentenceminer-2.8.51}/GameSentenceMiner/ffmpeg.py

@@ -146,19 +146,19 @@ def get_screenshot_time(video_path, game_line, default_beginning=False, vad_resu
     #     logger.info(f"Using VAD result {vad_result} for screenshot time: {screenshot_time_from_beginning} seconds from beginning of replay")
     if get_config().screenshot.screenshot_timing_setting == "beginning":
         screenshot_time_from_beginning = line_timestamp_in_video + screenshot_offset
-        logger.info(f"Using 'beginning' setting for screenshot time: {screenshot_time_from_beginning} seconds from beginning of replay")
+        logger.debug(f"Using 'beginning' setting for screenshot time: {screenshot_time_from_beginning} seconds from beginning of replay")
     elif get_config().screenshot.screenshot_timing_setting == "middle":
         if game_line.next:
             screenshot_time_from_beginning = line_timestamp_in_video + ((game_line.next.time - game_line.time).total_seconds() / 2) + screenshot_offset
         else:
             screenshot_time_from_beginning = (file_length - ((file_length - line_timestamp_in_video) / 2)) + screenshot_offset
-        logger.info(f"Using 'middle' setting for screenshot time: {screenshot_time_from_beginning} seconds from beginning of replay")
+        logger.debug(f"Using 'middle' setting for screenshot time: {screenshot_time_from_beginning} seconds from beginning of replay")
     elif get_config().screenshot.screenshot_timing_setting == "end":
         if game_line.next:
             screenshot_time_from_beginning = line_timestamp_in_video + (game_line.next.time - game_line.time).total_seconds() - screenshot_offset
         else:
             screenshot_time_from_beginning = file_length - screenshot_offset
-        logger.info(f"Using 'end' setting for screenshot time: {screenshot_time_from_beginning} seconds from beginning of replay")
+        logger.debug(f"Using 'end' setting for screenshot time: {screenshot_time_from_beginning} seconds from beginning of replay")
     else:
         logger.error(f"Invalid screenshot timing setting: {get_config().screenshot.screenshot_timing_setting}")
         screenshot_time_from_beginning = line_timestamp_in_video + screenshot_offset
@@ -317,7 +317,7 @@ def trim_audio_based_on_last_line(untrimmed_audio, video_path, game_line, next_l
     logger.debug(" ".join(ffmpeg_command))
     subprocess.run(ffmpeg_command)
 
-    logger.info(f"{total_seconds_after_offset} trimmed off of beginning")
+    logger.debug(f"{total_seconds_after_offset} trimmed off of beginning")
 
     logger.debug(f"Audio trimmed and saved to {trimmed_audio}")
     return trimmed_audio
@@ -412,7 +412,7 @@ def trim_audio(input_audio, start_time, end_time, output_audio):
     command.extend(['-i', input_audio])
 
     if get_config().vad.trim_beginning and start_time > 0:
-        logger.info(f"trimming beginning to {start_time}")
+        logger.debug(f"trimming beginning to {start_time}")
         command.extend(['-ss', f"{start_time:.2f}"])
 
     command.extend([

{gamesentenceminer-2.8.49 → gamesentenceminer-2.8.51}/GameSentenceMiner/gsm.py

@@ -186,6 +186,7 @@ class VideoToAudioHandler(FileSystemEventHandler):
 
     @staticmethod
     def get_audio(game_line, next_line_time, video_path, anki_card_creation_time=None, temporary=False, timing_only=False):
+        logger.info("Getting audio from video...")
         trimmed_audio = get_audio_and_trim(video_path, game_line, next_line_time, anki_card_creation_time)
         if temporary:
             return trimmed_audio
@@ -195,13 +196,18 @@ class VideoToAudioHandler(FileSystemEventHandler):
                                                                 f"{obs.get_current_game(sanitize=True)}.{get_config().audio.extension}"))
         result = VADResult(False, 0, 0)
         if get_config().vad.do_vad_postprocessing:
-            result = do_vad_processing(get_config().vad.selected_vad_model, trimmed_audio, vad_trimmed_audio)
+            logger.info("Trimming audio with Voice Detection...")
+            result = do_vad_processing(get_config().vad.selected_vad_model, trimmed_audio, vad_trimmed_audio, game_line=game_line)
             if not result.success:
                 result = do_vad_processing(get_config().vad.selected_vad_model, trimmed_audio,
-                                                        vad_trimmed_audio)
-            if not result.success and get_config().vad.add_audio_on_no_results:
-                logger.info("No voice activity detected, using full audio.")
-                vad_trimmed_audio = trimmed_audio
+                                                        vad_trimmed_audio, game_line=game_line)
+            if not result.success:
+                if get_config().vad.add_audio_on_no_results:
+                    logger.info("No voice activity detected, using full audio.")
+                    vad_trimmed_audio = trimmed_audio
+                else:
+                    logger.info("No voice activity detected.")
+                    return None, result, None
         if timing_only:
             return result
         if get_config().audio.ffmpeg_reencode_options and os.path.exists(vad_trimmed_audio):
@@ -212,19 +218,19 @@ class VideoToAudioHandler(FileSystemEventHandler):
         return final_audio_output, result, vad_trimmed_audio
 
 
-def do_vad_processing(model, trimmed_audio, vad_trimmed_audio, second_pass=False):
+def do_vad_processing(model, trimmed_audio, vad_trimmed_audio, game_line=None, second_pass=False):
     match model:
         case configuration.OFF:
             pass
         case configuration.SILERO:
             from GameSentenceMiner.vad import silero_trim
-            return silero_trim.process_audio_with_silero(trimmed_audio, vad_trimmed_audio)
+            return silero_trim.process_audio_with_silero(trimmed_audio, vad_trimmed_audio, game_line)
         case configuration.VOSK:
             from GameSentenceMiner.vad import vosk_helper
-            return vosk_helper.process_audio_with_vosk(trimmed_audio, vad_trimmed_audio)
+            return vosk_helper.process_audio_with_vosk(trimmed_audio, vad_trimmed_audio, game_line)
         case configuration.WHISPER:
             from GameSentenceMiner.vad import whisper_helper
-            return whisper_helper.process_audio_with_whisper(trimmed_audio, vad_trimmed_audio)
+            return whisper_helper.process_audio_with_whisper(trimmed_audio, vad_trimmed_audio, game_line)
 
 
 def play_audio_in_external(filepath):

{gamesentenceminer-2.8.49 → gamesentenceminer-2.8.51}/GameSentenceMiner/ocr/owocr_helper.py

@@ -180,7 +180,7 @@ class WebsocketServerThread(threading.Thread):
         finally:
             self.clients.remove(websocket)
 
-    def send_text(self, text, line_time: datetime):
+    async def send_text(self, text, line_time: datetime):
         if text:
             return asyncio.run_coroutine_threadsafe(
                 self.send_text_coroutine(json.dumps({"sentence": text, "time": line_time.isoformat()})), self.loop)
@@ -212,8 +212,6 @@ def do_second_ocr(ocr1_text, time, img, filtering, scrolling=False):
     try:
         orig_text, text = run.process_and_write_results(img, None, last_ocr2_result, filtering, None,
                                                         engine=ocr2)
-        print(filtering)
-        print(last_ocr2_result)
         if scrolling:
             return text
         if fuzz.ratio(last_ocr2_result, orig_text) >= 80:
@@ -221,7 +219,7 @@ def do_second_ocr(ocr1_text, time, img, filtering, scrolling=False):
             return
         save_result_image(img)
         last_ocr2_result = orig_text
-        send_result(text, time)
+        asyncio.run(send_result(text, time))
     except json.JSONDecodeError:
         print("Invalid JSON received.")
     except Exception as e:
@@ -238,13 +236,17 @@ def save_result_image(img):
         img.close()
 
 
-def send_result(text, time):
+async def send_result(text, time):
     if text:
         text = do_text_replacements(text, OCR_REPLACEMENTS_FILE)
-        if get_config().advanced.ocr_sends_to_clipboard:
+        if get_config().advanced.ocr_sends_to_clipboard or ssonly:
             import pyperclip
             pyperclip.copy(text)
-        websocket_server_thread.send_text(text, time)
+        if not ssonly:
+            try:
+                await websocket_server_thread.send_text(text, time)
+            except Exception as e:
+                logger.debug(f"Error sending text to websocket: {e}")
 
 
 previous_text_list = []
@@ -253,74 +255,57 @@ previous_ocr1_result = ""  # Store last OCR1 result
 last_oneocr_time = None  # Store last OCR time
 text_stable_start_time = None  # Store the start time when text becomes stable
 previous_img = None
-orig_text_result = ""  # Store original text result
+previous_orig_text = ""  # Store original text result
 TEXT_APPEARENCE_DELAY = get_ocr_scan_rate() * 1000 + 500  # Adjust as needed
 force_stable = False
 scrolling_text_images = []
 
-def text_callback(text, orig_text, time, img=None, came_from_ss=False, filtering=None):
-    global twopassocr, ocr2, previous_text, last_oneocr_time, text_stable_start_time, orig_text_result, previous_img, force_stable, previous_ocr1_result, scrolling_text_images, previous_text_list
+def text_callback(text, orig_text, time, img=None, came_from_ss=False, filtering=None, crop_coords=None):
+    global twopassocr, ocr2, previous_text, last_oneocr_time, text_stable_start_time, previous_orig_text, previous_img, force_stable, previous_ocr1_result, scrolling_text_images, previous_text_list
     orig_text_string = ''.join([item for item in orig_text if item is not None]) if orig_text else ""
     if came_from_ss:
         save_result_image(img)
-        send_result(text, time)
+        asyncio.run(send_result(text, time))
         return
 
     line_start_time = time if time else datetime.now()
 
     if not twopassocr:
-        if previous_text and fuzz.ratio(orig_text_string, previous_text) >= 80:
+        if previous_text and fuzz.ratio(orig_text_string, previous_orig_text) >= 90:
             logger.info("Seems like Text we already sent, not doing anything.")
             return
         save_result_image(img)
-        send_result(text, time)
-        orig_text_result = orig_text_string
-        previous_text = previous_text
+        asyncio.run(send_result(text, time))
+        previous_orig_text = orig_text_string
+        previous_text = None
         previous_img = None
         text_stable_start_time = None
         last_oneocr_time = None
         return
     if not text or force_stable:
-        # if scrolling_text_images:
-        #     stable_time = text_stable_start_time
-        #     full_text = "".join([do_second_ocr(orig_text_string, line_start_time, img, filtering, True) for img in scrolling_text_images])
-        #     scrolling_text_images = []
-        #     send_result(full_text, stable_time)
-        #     orig_text_result = orig_text_string
-        #     previous_text = previous_text
-        #     previous_img = None
-        #     text_stable_start_time = None
-        #     last_oneocr_time = None
         force_stable = False
-        if previous_text:
-            if text_stable_start_time:
-                stable_time = text_stable_start_time
-                previous_img_local = previous_img
-                if fuzz.ratio(orig_text_string, previous_ocr1_result) >= 90:
-                    logger.info("Seems like Text we already sent, not doing anything.")
-                    return
-                orig_text_result = orig_text_string
-                previous_ocr1_result = previous_text
-                do_second_ocr(previous_text, stable_time, previous_img_local, filtering)
-                previous_img = None
-                text_stable_start_time = None
-                last_oneocr_time = None
-            return
+        if previous_text and text_stable_start_time:
+            stable_time = text_stable_start_time
+            previous_img_local = previous_img
+            if previous_text and fuzz.ratio(orig_text_string, previous_orig_text) >= 90:
+                logger.info("Seems like Text we already sent, not doing anything.")
+                return
+            previous_orig_text = orig_text_string
+            previous_ocr1_result = previous_text
+            if crop_coords:
+                previous_img_local.save(os.path.join(get_temporary_directory(), "pre_oneocrcrop.png"))
+                previous_img_local = previous_img_local.crop(crop_coords)
+            do_second_ocr(previous_text, stable_time, previous_img_local, filtering)
+            previous_img = None
+            previous_text = None
+            text_stable_start_time = None
+            last_oneocr_time = None
+        previous_text = None
         return
-    # elif previous_text_list and all(
-    #     fuzz.partial_ratio(token, prev_token) >= 95 for token in orig_text for prev_token in
-    #     previous_text_list[1:]):
-    #     logger.info(f"Previous text: {previous_text_list}. Current text: {orig_text}.")
-    #     logger.info("Seems like Scrolling text potentially...")
-    #     previous_img_local = previous_img
-    #     scrolling_text_images.append(previous_img_local)
-    #     previous_text_list = orig_text
-    #     previous_text = orig_text_string
-    #     return
 
     if not text_stable_start_time:
         text_stable_start_time = line_start_time
-    previous_text = orig_text_string
+    previous_text = text
     previous_text_list = orig_text
     last_oneocr_time = line_start_time
     previous_img = img
@@ -333,15 +318,17 @@ def run_oneocr(ocr_config: OCRConfig, area=False):
     print("Running OneOCR")
     screen_area = None
     screen_areas = []
-    for rect_config in ocr_config.rectangles:
-        coords = rect_config.coordinates
-        monitor_config = rect_config.monitor
-        screen_area = ",".join(str(c) for c in coords) if area else None
-        if screen_area:
-            screen_areas.append(screen_area)
+    if not ssonly:
+        for rect_config in ocr_config.rectangles:
+            coords = rect_config.coordinates
+            monitor_config = rect_config.monitor
+            screen_area = ",".join(str(c) for c in coords) if area else None
+            if screen_area:
+                screen_areas.append(screen_area)
     exclusions = list(rect.coordinates for rect in list(filter(lambda x: x.is_excluded, ocr_config.rectangles)))
-    run.run(read_from="screencapture",
-            read_from_secondary="clipboard",
+    run.init_config(False)
+    run.run(read_from="screencapture" if not ssonly else "clipboard",
+            read_from_secondary="clipboard" if not ssonly else None,
             write_to="callback",
             screen_capture_area=screen_area,
             # screen_capture_monitor=monitor_config['index'],
@@ -387,7 +374,7 @@ def set_force_stable_hotkey():
     print("Press Ctrl+Shift+F to toggle force stable mode.")
 
 if __name__ == "__main__":
-    global ocr1, ocr2, twopassocr, language
+    global ocr1, ocr2, twopassocr, language, ssonly
     import sys
 
     args = sys.argv[1:]
@@ -411,6 +398,8 @@ if __name__ == "__main__":
         ocr1 = "oneocr"
         ocr2 = "glens"
         twopassocr = True
+
+    ssonly = "--ssonly" in args
     logger.info(f"Received arguments: ocr1={ocr1}, ocr2={ocr2}, twopassocr={twopassocr}")
     # set_force_stable_hotkey()
     global ocr_config
@@ -431,15 +420,9 @@ if __name__ == "__main__":
     if ocr_config:
         rectangles = list(filter(lambda rect: not rect.is_excluded, ocr_config.rectangles))
         oneocr_threads = []
-        run.init_config(False)
-        if rectangles:
-            thread = threading.Thread(target=run_oneocr, args=(ocr_config,True, ), daemon=True)
-            oneocr_threads.append(thread)
-            thread.start()
-        else:
-            single_ocr_thread = threading.Thread(target=run_oneocr, args=(ocr_config,False, ), daemon=True)
-            oneocr_threads.append(single_ocr_thread)
-            single_ocr_thread.start()
+        single_ocr_thread = threading.Thread(target=run_oneocr, args=(ocr_config,ocr_config.rectangles ), daemon=True)
+        oneocr_threads.append(single_ocr_thread)
+        single_ocr_thread.start()
         websocket_server_thread = WebsocketServerThread(read=True)
         websocket_server_thread.start()
         try:

{gamesentenceminer-2.8.49 → gamesentenceminer-2.8.51}/GameSentenceMiner/owocr/owocr/ocr.py

@@ -17,6 +17,8 @@ from google.generativeai import GenerationConfig
 from loguru import logger
 import requests
 
+from ...configuration import get_temporary_directory
+
 try:
     from manga_ocr import MangaOcr as MOCR
 except ImportError:
@@ -765,11 +767,16 @@ class OneOCR:
         img = input_to_pil_image(img)
         if not img:
             return (False, 'Invalid image provided')
-
+        crop_coords = None
         if sys.platform == 'win32':
             try:
                 ocr_resp = self.model.recognize_pil(img)
                 # print(json.dumps(ocr_resp))
+                x_coords = [line['bounding_rect'][f'x{i}'] for line in ocr_resp['lines'] for i in range(1, 5)]
+                y_coords = [line['bounding_rect'][f'y{i}'] for line in ocr_resp['lines'] for i in range(1, 5)]
+                if x_coords and y_coords:
+                    crop_coords = (min(x_coords) - 5, min(y_coords) - 5, max(x_coords) + 5, max(y_coords) + 5)
+
                 res = ocr_resp['text']
             except RuntimeError as e:
                 return (False, e)
@@ -787,7 +794,7 @@ class OneOCR:
 
             res = res.json()['text']
 
-        x = (True, res)
+        x = (True, res, crop_coords)
 
         # img.close()
         return x

{gamesentenceminer-2.8.49 → gamesentenceminer-2.8.51}/GameSentenceMiner/owocr/owocr/run.py

@@ -381,10 +381,7 @@ class TextFiltering:
             else:
                 orig_text_filtered.append(None)
 
-        if not isinstance(last_result, tuple):
-            print(type(last_result))
         if isinstance(last_result, list):
-            print("last_result is a list")
             last_text = last_result
         elif last_result and last_result[1] == engine_index:
             last_text = last_result[0]
@@ -406,7 +403,6 @@ class TextFiltering:
                         break
         else:
             for block in new_blocks:
-                print(block)
                 if lang not in ["ja", "zh"] or self.classify(block)[0] == lang:
                     final_blocks.append(block)
 
@@ -752,7 +748,6 @@ class ScreenshotClass:
 
         if rand_int == 1:
             img.save(os.path.join(get_temporary_directory(), 'after_crop.png'), 'PNG')
-            print(f'OCR images saved to {get_temporary_directory()} if debugging is needed, this is 1/20 chance')
 
         return img
 
@@ -897,7 +892,9 @@ def process_and_write_results(img_or_path, write_to=None, last_result=None, filt
     engine_color = config.get_general('engine_color')
 
     start_time = time.time()
-    res, text = engine_instance(img_or_path)
+    result = engine_instance(img_or_path)
+    res, text, crop_coords = (*result, None)[:3]
+
     end_time = time.time()
 
     if not res and ocr_2 == engine:
@@ -908,7 +905,8 @@ def process_and_write_results(img_or_path, write_to=None, last_result=None, filt
                 if last_result:
                     last_result = []
                 break
-        res, text = engine_instance(img_or_path)
+        result = engine_instance(img_or_path)
+        res, text, crop_coords = (*result, None)[:3]
 
     orig_text = []
     # print(filtering)
@@ -933,7 +931,7 @@ def process_and_write_results(img_or_path, write_to=None, last_result=None, filt
         elif write_to == 'clipboard':
             pyperclipfix.copy(text)
         elif write_to == "callback":
-            txt_callback(text, orig_text, ocr_start_time, img_or_path, bool(engine), filtering)
+            txt_callback(text, orig_text, ocr_start_time, img_or_path, bool(engine), filtering, crop_coords)
         elif write_to:
             with Path(write_to).open('a', encoding='utf-8') as f:
                 f.write(text + '\n')

{gamesentenceminer-2.8.49 → gamesentenceminer-2.8.51}/GameSentenceMiner/vad/silero_trim.py

@@ -27,7 +27,7 @@ def detect_voice_with_silero(input_audio):
 
 
 # Example usage of Silero with trimming
-def process_audio_with_silero(input_audio, output_audio):
+def process_audio_with_silero(input_audio, output_audio, game_line):
     voice_activity = detect_voice_with_silero(input_audio)
 
     if not voice_activity:
@@ -35,7 +35,13 @@ def process_audio_with_silero(input_audio, output_audio):
 
     # Trim based on the first and last speech detected
     start_time = voice_activity[0]['start'] if voice_activity else 0
-    end_time = voice_activity[-1]['end'] if voice_activity else 0
+    if (game_line.next and len(voice_activity) > 1
+        and voice_activity[-1]['end'] - get_config().audio.beginning_offset > len(input_audio) / 16000
+            and (voice_activity[-1]['start'] - voice_activity[-2]['end']) > 3.0):
+                end_time = voice_activity[-2]['end']
+                logger.info("Using the second last timestamp for trimming")
+    else:
+        end_time = voice_activity[-1]['end'] if voice_activity else 0
 
     # Trim the audio using FFmpeg
     ffmpeg.trim_audio(input_audio, start_time + get_config().vad.beginning_offset, end_time + get_config().audio.end_offset, output_audio)

{gamesentenceminer-2.8.49 → gamesentenceminer-2.8.51}/GameSentenceMiner/vad/vosk_helper.py

@@ -123,7 +123,7 @@ def detect_voice_with_vosk(input_audio):
 
 
 # Example usage of Vosk with trimming
-def process_audio_with_vosk(input_audio, output_audio):
+def process_audio_with_vosk(input_audio, output_audio, game_line):
     voice_activity, total_duration = detect_voice_with_vosk(input_audio)
 
     if not voice_activity:
@@ -132,7 +132,13 @@ def process_audio_with_vosk(input_audio, output_audio):
 
     # Trim based on the first and last speech detected
     start_time = voice_activity[0]['start'] if voice_activity else 0
-    end_time = voice_activity[-1]['end'] if voice_activity else total_duration
+    if (game_line.next and len(voice_activity) > 1
+            and voice_activity[-1]['end'] - get_config().audio.beginning_offset > len(input_audio) / 16000
+            and (voice_activity[-1]['start'] - voice_activity[-2]['end']) > 3.0):
+        end_time = voice_activity[-2]['end']
+        logger.info("Using the second last timestamp for trimming")
+    else:
+        end_time = voice_activity[-1]['end'] if voice_activity else 0
 
     if get_config().vad.trim_beginning:
         logger.info(f"VAD Trimmed Beginning of Audio to {start_time}")

{gamesentenceminer-2.8.49 → gamesentenceminer-2.8.51}/GameSentenceMiner/vad/whisper_helper.py

@@ -70,7 +70,7 @@ def detect_voice_with_whisper(input_audio):
 
 
 # Example usage of Whisper with trimming
-def process_audio_with_whisper(input_audio, output_audio):
+def process_audio_with_whisper(input_audio, output_audio, game_line):
     voice_activity = detect_voice_with_whisper(input_audio)
 
     if not voice_activity:
@@ -78,8 +78,14 @@ def process_audio_with_whisper(input_audio, output_audio):
         return VADResult(False, 0, 0)
 
     # Trim based on the first and last speech detected
-    start_time = voice_activity[0]['start']
-    end_time = voice_activity[-1]['end']
+    start_time = voice_activity[0]['start'] if voice_activity else 0
+    if (game_line.next and len(voice_activity) > 1
+        and voice_activity[-1]['end'] - get_config().audio.beginning_offset > len(input_audio) / 16000
+            and (voice_activity[-1]['start'] - voice_activity[-2]['end']) > 3.0):
+                end_time = voice_activity[-2]['end']
+                logger.info("Using the second last timestamp for trimming")
+    else:
+        end_time = voice_activity[-1]['end'] if voice_activity else 0
 
     if get_config().vad.trim_beginning:
         logger.info(f"VAD Trimmed Beginning of Audio to {start_time}")

{gamesentenceminer-2.8.49 → gamesentenceminer-2.8.51}/GameSentenceMiner/web/templates/utility.html

@@ -126,7 +126,6 @@
 <script>
     let mainStyle = document.querySelector('head style');
     let deleteHistoryButton = document.getElementById('delete-history');
-    console.log(mainStyle);
     let displayedEventIds = new Set();
     let isTabActive = true;
     let isFetching = false; // Flag to track if a fetch is in progress
@@ -141,6 +140,8 @@
     let hoveredCheckboxes = new Set();
     let checkboxes = []; // Will hold all checkbox elements
     let checkboxMap = {};
+    let textLines = []; // Will hold all textline elements
+    let textLineMap = {};
     let checkboxes_being_updated = new Set();
 
     // Shift click selection variable
@@ -170,7 +171,6 @@
                     }
                 }
                 if (!ev.history) {
-                    console.log(checkboxMap[ev.id])
                     if (!checkboxes_being_updated.has(ev.id)) {
                         const checkbox = checkboxMap[ev.id];
                         if (checkbox) {
@@ -219,6 +219,7 @@
         });
     }
 
+
     function addNewEvent(event) {
         displayedEventIds.add(event.id);
         const container = document.getElementById('session-events');
@@ -237,7 +238,7 @@
         aria-label="Mark item"
         data-event-id="${event.id}"
         onchange="toggleCheckbox('${event.id}', this.checked)">
-        <p>${event.text}</p>
+        <p id="textline-${event.id}" contenteditable="false" ondblclick="this.contentEditable = this.contentEditable === 'true' ? 'false' : 'true'; if (this.contentEditable === 'true') this.focus();">${event.text}</p>
         <div class="textline-buttons">
             <button onclick="buttonClick('${event.id}', 'Screenshot')" title="Screenshot" style="background-color: #333; color: #fff; border: 1px solid #555; padding: 6px 10px; font-size: 10px; border-radius: 4px; cursor: pointer; transition: background-color 0.3s;">
                 &#x1F4F7;
@@ -258,6 +259,11 @@
         checkboxes.push(checkbox);
         checkboxMap[event.id] = checkbox; // Store the checkbox in the map for easy access
 
+        let textline = shadowRoot.querySelector('#textline-' + event.id);
+        textLines.push(textline);
+        textLineMap[event.id] = textline; // Store the textline in the map for easy access
+
+
         container.appendChild(div);
         window.scrollTo({
             top: document.documentElement.scrollHeight,
@@ -286,6 +292,12 @@
             });
     }
 
+    function textDoubleClicked(id) {
+        const textElement = textLineMap[id];
+        console.log(textElement);
+        textElement.contenteditable = textElement.contenteditable === "true" ? "false" : "true";
+    }
+
     async function toggleCheckbox(id, checked) {
         try {
             checkboxes_being_updated.add(id);

{gamesentenceminer-2.8.49 → gamesentenceminer-2.8.51}/GameSentenceMiner.egg-info/PKG-INFO

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

{gamesentenceminer-2.8.49 → gamesentenceminer-2.8.51}/PKG-INFO

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

{gamesentenceminer-2.8.49 → gamesentenceminer-2.8.51}/pyproject.toml

@@ -7,7 +7,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "GameSentenceMiner"
-version = "2.8.49"
+version = "2.8.51"
 description = "A tool for mining sentences from games. Update: Multi-Line Mining! Fixed!"
 readme = "README.md"
 requires-python = ">=3.10"