GameSentenceMiner 2.11.3__tar.gz → 2.11.4__tar.gz

{gamesentenceminer-2.11.3 → gamesentenceminer-2.11.4}/GameSentenceMiner/util/text_log.py

@@ -35,6 +35,9 @@ class GameLine:
     def set_TL(self, tl: str):
         self.TL = tl
 
+    def get_stripped_text(self):
+        return self.text.replace('\n', '').strip()
+
     def __str__(self):
         return str({"text": self.text, "time": self.time})
 
@@ -151,10 +154,10 @@ def get_line_and_future_lines(last_note):
         found = False
         for line in game_log.values:
             if found:
-                found_lines.append(line.text)
+                found_lines.append(line)
             if lines_match(line.text, remove_html_and_cloze_tags(sentence)):  # 80% similarity threshold
                 found = True
-                found_lines.append(line.text)
+                found_lines.append(line)
     return found_lines
 
 
@@ -168,7 +171,7 @@ def get_mined_line(last_note: AnkiCard, lines=None):
 
     sentence = last_note.get_field(get_config().anki.sentence_field)
     for line in reversed(lines):
-        if lines_match(line.text, remove_html_and_cloze_tags(sentence)):
+        if lines_match(line.get_stripped_text(), remove_html_and_cloze_tags(sentence)):
             return line
     return lines[-1]
 

gamesentenceminer-2.11.4/GameSentenceMiner/util/window_transparency.py

@@ -0,0 +1,168 @@
+import win32gui
+import win32con
+import win32api
+import keyboard
+import time
+import threading
+
+from GameSentenceMiner.util.configuration import logger
+
+# --- Configuration (equivalent to AHK top-level variables) ---
+TRANSPARENT_LEVEL = 1  # Almost invisible (0-255 scale)
+OPAQUE_LEVEL = 255     # Fully opaque
+HOTKEY = 'ctrl+alt+y'
+
+# --- Global State Variables (equivalent to AHK global variables) ---
+is_toggled = False
+target_hwnd = None
+# A lock to prevent race conditions when accessing global state from different threads
+state_lock = threading.Lock()
+
+# --- Core Functions (equivalent to AHK functions) ---
+
+def set_window_transparency(hwnd, transparency):
+    """
+    Sets the transparency of a window.
+    This is the Python equivalent of WinSetTransparent.
+    """
+    if not hwnd or not win32gui.IsWindow(hwnd):
+        return
+    try:
+        # Get the current window style
+        style = win32gui.GetWindowLong(hwnd, win32con.GWL_EXSTYLE)
+        # Add the WS_EX_LAYERED style, which is required for transparency
+        win32gui.SetWindowLong(hwnd, win32con.GWL_EXSTYLE, style | win32con.WS_EX_LAYERED)
+        # Set the transparency
+        win32gui.SetLayeredWindowAttributes(hwnd, 0, transparency, win32con.LWA_ALPHA)
+    except Exception as e:
+        # Some windows (like system or elevated ones) might deny permission
+        # logger.info(f"Error setting transparency for HWND {hwnd}: {e}")
+        pass
+
+def set_always_on_top(hwnd, is_on_top):
+    """
+    Sets or removes the "Always on Top" status for a window.
+    This is the Python equivalent of WinSetAlwaysOnTop.
+    """
+    if not hwnd or not win32gui.IsWindow(hwnd):
+        return
+    try:
+        rect = win32gui.GetWindowRect(hwnd)
+        position = win32con.HWND_TOPMOST if is_on_top else win32con.HWND_NOTOPMOST
+        # Set the window position without moving or resizing it
+        win32gui.SetWindowPos(hwnd, position, rect[0], rect[1], 0, 0,
+                              win32con.SWP_NOMOVE | win32con.SWP_NOSIZE)
+    except Exception as e:
+        # logger.info(f"Error setting always-on-top for HWND {hwnd}: {e}")
+        pass
+
+def reset_window_state(hwnd):
+    """A helper to reset a window to its default state."""
+    set_window_transparency(hwnd, OPAQUE_LEVEL)
+    set_always_on_top(hwnd, False)
+
+# --- Hotkey Callback (equivalent to AHK ^!y::) ---
+
+def toggle_functionality():
+    """
+    This function is called when the hotkey is pressed.
+    It manages the toggling logic.
+    """
+    global is_toggled, target_hwnd
+
+    # Get the currently focused window (equivalent to WinGetID("A"))
+    current_hwnd = win32gui.GetForegroundWindow()
+    if not current_hwnd:
+        logger.info("No window is currently active!")
+        return
+
+    with state_lock:
+        # Case 1: The hotkey is pressed on the currently toggled window to disable it.
+        if is_toggled and target_hwnd == current_hwnd:
+            logger.info(f"Disabling functionality for window: {win32gui.GetWindowText(current_hwnd)}")
+            reset_window_state(current_hwnd)
+            is_toggled = False
+            target_hwnd = None
+        # Case 2: Enable functionality for a new window, or switch to a new one.
+        else:
+            # If another window was already toggled, reset it first.
+            if is_toggled and target_hwnd is not None:
+                logger.info(f"Resetting old window: {win32gui.GetWindowText(target_hwnd)}")
+                reset_window_state(target_hwnd)
+
+            # Enable functionality for the new window.
+            logger.info(f"Enabling functionality for window: {win32gui.GetWindowText(current_hwnd)}")
+            is_toggled = True
+            target_hwnd = current_hwnd
+            set_always_on_top(target_hwnd, True)
+            # The mouse_monitor_loop will handle setting the initial transparency
+
+# --- Mouse Monitoring (equivalent to AHK Loop) ---
+
+def mouse_monitor_loop():
+    """
+    A loop that runs in a separate thread to monitor the mouse position.
+    """
+    global is_toggled, target_hwnd
+
+    while True:
+        # We check the state without a lock first for performance,
+        # then use the lock when we need to read the shared variable.
+        if is_toggled:
+            with state_lock:
+                # Make a local copy of the target handle to work with
+                monitored_hwnd = target_hwnd
+
+            if monitored_hwnd:
+                # Get mouse position and the window handle under the cursor
+                pos = win32gui.GetCursorPos()
+                hwnd_under_mouse = win32gui.WindowFromPoint(pos)
+
+                # WindowFromPoint can return a child window (like a button).
+                # We need to walk up the parent chain to see if it belongs to our target window.
+                is_mouse_over_target = False
+                current_hwnd = hwnd_under_mouse
+                while current_hwnd != 0:
+                    if current_hwnd == monitored_hwnd:
+                        is_mouse_over_target = True
+                        break
+                    current_hwnd = win32gui.GetParent(current_hwnd)
+
+                # Apply transparency based on mouse position
+                if is_mouse_over_target:
+                    set_window_transparency(monitored_hwnd, OPAQUE_LEVEL)
+                else:
+                    set_window_transparency(monitored_hwnd, TRANSPARENT_LEVEL)
+
+        # A small delay to reduce CPU usage
+        time.sleep(0.1)
+
+# --- Main Execution Block ---
+
+if __name__ == "__main__":
+    import argparse
+    # Start the mouse monitor in a separate, non-blocking thread.
+    # daemon=True ensures the thread will exit when the main script does.
+    monitor_thread = threading.Thread(target=mouse_monitor_loop, daemon=True)
+    monitor_thread.start()
+
+    # get hotkey from args
+    parser = argparse.ArgumentParser(description="Window Transparency Toggle Script")
+    parser.add_argument('--hotkey', type=str, default=HOTKEY, help='Hotkey to toggle transparency (default: ctrl+alt+y)')
+
+    hotkey = parser.parse_args().hotkey.lower()
+
+    # Register the global hotkey
+    keyboard.add_hotkey(hotkey, toggle_functionality)
+
+    logger.info(f"Script running. Press '{hotkey}' on a window to toggle transparency.")
+    logger.info("Press Ctrl+C in this console to exit.")
+
+    # Keep the script running to listen for the hotkey.
+    # keyboard.wait() is a blocking call that waits indefinitely.
+    try:
+        keyboard.wait()
+    except KeyboardInterrupt:
+        if is_toggled and target_hwnd:
+            reset_window_state(target_hwnd)
+        logger.info("\nScript terminated by user.")

{gamesentenceminer-2.11.3 → gamesentenceminer-2.11.4}/GameSentenceMiner/vad.py

@@ -53,18 +53,10 @@ class VADSystem:
         match model:
             case configuration.OFF:
                 return VADResult(False, 0, 0, "OFF")
-            # case configuration.GROQ:
-            #     if not self.groq:
-            #         self.groq = GroqVADProcessor()
-            #     return self.groq.process_audio(input_audio, output_audio, game_line)
             case configuration.SILERO:
                 if not self.silero:
                     self.silero = SileroVADProcessor()
                 return self.silero.process_audio(input_audio, output_audio, game_line)
-            # case configuration.VOSK:
-            #     if not self.vosk:
-            #         self.vosk = VoskVADProcessor()
-            #     return self.vosk.process_audio(input_audio, output_audio, game_line)
             case configuration.WHISPER:
                 if not self.whisper:
                     self.whisper = WhisperVADProcessor()
@@ -121,8 +113,6 @@ class VADProcessor(ABC):
             logger.info("No voice activity detected in the audio.")
             return VADResult(False, 0, 0, self.vad_system_name)
 
-        print(voice_activity)
-
         start_time = voice_activity[0]['start'] if voice_activity else 0
         end_time = voice_activity[-1]['end'] if voice_activity else 0
 
@@ -132,6 +122,17 @@ class VADProcessor(ABC):
             if 0 > audio_length - voice_activity[-1]['start'] + get_config().audio.beginning_offset:
                 end_time = voice_activity[-2]['end']
 
+        # if detected text is much shorter than game_line.text, if no text, guess based on length
+        if 'text' in voice_activity[0]:
+            dectected_text = ''.join([item['text'] for item in voice_activity])
+            if game_line and game_line.text and len(dectected_text) < len(game_line.text) / 2:
+                logger.info(f"Detected text '{dectected_text}' is much shorter than expected '{game_line.text}', skipping.")
+                return VADResult(False, 0, 0, self.vad_system_name)
+        else:
+            if game_line and game_line.text and (end_time - start_time) < max(0.5, len(game_line.text) * 0.05):
+                logger.info(f"Detected audio length {end_time - start_time} is much shorter than expected for text '{game_line.text}', skipping.")
+                return VADResult(False, 0, 0, self.vad_system_name)
+
         if get_config().vad.cut_and_splice_segments:
             self.extract_audio_and_combine_segments(input_audio, voice_activity, output_audio, padding=get_config().vad.splice_padding)
         else:
@@ -186,7 +187,7 @@ class WhisperVADProcessor(VADProcessor):
 
         # Process the segments to extract tokens, timestamps, and confidence
         for i, segment in enumerate(result.segments):
-            if len(segment.text) == 1 and (i > 1 and segment.start - result.segments[i - 1].end > 1.0) or (i < len(result.segments) - 1 and result.segments[i + 1].start - segment.end > 1.0):
+            if len(segment.text) <= 2 and ((i > 1 and segment.start - result.segments[i - 1].end > 1.0) or (i < len(result.segments) - 1 and result.segments[i + 1].start - segment.end > 1.0)):
                 if segment.text in ['えー', 'ん']:
                         logger.debug(f"Skipping filler segment: {segment.text} at {segment.start}-{segment.end}")
                         continue
@@ -194,6 +195,7 @@ class WhisperVADProcessor(VADProcessor):
                     logger.info(
                         "Unknown single character segment, not skipping, but logging, please report if this is a mistake: " + segment.text)
 
+
             logger.debug(segment.to_dict())
             voice_activity.append({
                 'text': segment.text,

{gamesentenceminer-2.11.3 → gamesentenceminer-2.11.4}/GameSentenceMiner.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: GameSentenceMiner
-Version: 2.11.3
+Version: 2.11.4
 Summary: A tool for mining sentences from games. Update: Full UI Re-design
 Author-email: Beangate <bpwhelan95@gmail.com>
 License: MIT License

{gamesentenceminer-2.11.3 → gamesentenceminer-2.11.4}/GameSentenceMiner.egg-info/SOURCES.txt

@@ -48,6 +48,7 @@ GameSentenceMiner/util/notification.py
 GameSentenceMiner/util/package.py
 GameSentenceMiner/util/ss_selector.py
 GameSentenceMiner/util/text_log.py
+GameSentenceMiner/util/window_transparency.py
 GameSentenceMiner/util/communication/__init__.py
 GameSentenceMiner/util/communication/send.py
 GameSentenceMiner/util/communication/websocket.py

{gamesentenceminer-2.11.3 → gamesentenceminer-2.11.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: GameSentenceMiner
-Version: 2.11.3
+Version: 2.11.4
 Summary: A tool for mining sentences from games. Update: Full UI Re-design
 Author-email: Beangate <bpwhelan95@gmail.com>
 License: MIT License

{gamesentenceminer-2.11.3 → gamesentenceminer-2.11.4}/pyproject.toml

@@ -7,7 +7,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "GameSentenceMiner"
-version = "2.11.3"
+version = "2.11.4"
 description = "A tool for mining sentences from games. Update: Full UI Re-design"
 readme = "README.md"
 requires-python = ">=3.10"