GameSentenceMiner 2.18.6__py3-none-any.whl → 2.18.8__py3-none-any.whl

GameSentenceMiner/anki.py

@@ -234,7 +234,7 @@ def update_anki_card(last_note: 'AnkiCard', note=None, audio_path='', video_path
         sentence = note['fields'].get(config.anki.sentence_field, last_note.get_field(config.anki.sentence_field))
         
         use_voice, sentence, translation, new_ss_path = config_app.show_anki_confirmation_dialog(
-            tango, sentence, assets.screenshot_path, assets.audio_path, translation, ss_time
+            tango, sentence, assets.screenshot_path, assets.audio_path if update_audio_flag else None, translation, ss_time
         )
         note['fields'][config.anki.sentence_field] = sentence
         note['fields'][config.ai.anki_field] = translation
@@ -279,7 +279,8 @@ def update_anki_card(last_note: 'AnkiCard', note=None, audio_path='', video_path
             sentence_in_anki=game_line.text if game_line else '',
             multi_line=bool(selected_lines and len(selected_lines) > 1),
             video_in_anki=assets.video_in_anki or '',
-            word_path=word_path
+            word_path=word_path,
+            word=tango
         )
     
     # 9. Update the local application database with final paths
@@ -554,14 +555,17 @@ def update_new_card():
     else:
         logger.info("New card(s) detected! Added to Processing Queue!")
         gsm_state.last_mined_line = game_line
-        card_queue.append((last_card, datetime.now(), lines))
-        texthooking_page.reset_checked_lines()
-        try:
-            obs.save_replay_buffer()
-        except Exception as e:
-            card_queue.pop(0)
-            logger.error(f"Error saving replay buffer: {e}")
-            return
+        queue_card_for_processing(last_card, lines)
+        
+def queue_card_for_processing(last_card, lines):
+    card_queue.append((last_card, datetime.now(), lines))
+    texthooking_page.reset_checked_lines()
+    try:
+        obs.save_replay_buffer()
+    except Exception as e:
+        card_queue.pop(0)
+        logger.error(f"Error saving replay buffer: {e}")
+        return
 
 def update_card_from_same_sentence(last_card, lines, game_line):
     time_elapsed = 0
@@ -570,16 +574,15 @@ def update_card_from_same_sentence(last_card, lines, game_line):
         time_elapsed += 0.5
         if time_elapsed > 15:
             logger.info(f"Timed out waiting for Anki update for card {last_card.noteId}, retrieving new audio")
-            card_queue.append((last_card, datetime.now(), lines))
-            texthooking_page.reset_checked_lines()
-            try:
-                obs.save_replay_buffer()
-            except Exception as e:
-                card_queue.pop(0)
-                logger.error(f"Error saving replay buffer: {e}")
-                return
+            queue_card_for_processing(last_card, lines)
             return
     anki_result = anki_results[game_line.id]
+    
+    if anki_result.word == last_card.get_field(get_config().anki.word_field):
+        logger.info(f"Same word detected, attempting to get new audio for card {last_card.noteId}")
+        queue_card_for_processing(last_card, lines)
+        return
+    
     if anki_result.success:
         note, last_card = get_initial_card_info(last_card, lines)
         tango = last_card.get_field(get_config().anki.word_field)

GameSentenceMiner/locales/en_us.json

@@ -497,11 +497,11 @@
           },
           "texthooker_comm_port": {
             "label": "Texthooker Communication WebSocket Port:",
-            "tooltip": "Port for GSM Texthooker WebSocket communication. Does nothing right now, hardcoded to 55001"
+            "tooltip": "Port for GSM Texthooker WebSocket communication. "
           },
           "plaintext_export_port": {
-            "label": "Plaintext Websocket Export Port:",
-            "tooltip": "Port for GSM Plaintext WebSocket Export communication. Does nothing right now, hardcoded to 55002"
+            "label": "Plaintext/JL Websocket Export Port:",
+            "tooltip": "Port that GSM will send plaintext to. Useful for integrating with other tools like JL."
           },
           "reset_line_hotkey": {
             "label": "Reset Line Hotkey:",

GameSentenceMiner/locales/ja_jp.json

@@ -495,12 +495,12 @@
             "tooltip": "OCR WebSocket通信用のポート。GSMもこのポートで待機します。"
           },
           "texthooker_comm_port": {
-            "label": "Texthooker通信ポート:",
-            "tooltip": "GSM Texthooker通信用のWebSocketポート（現在未使用）。"
+            "label": "Texthooker通信WebSocketポート:",
+            "tooltip": "GSM Texthooker WebSocket通信用のポート。"
           },
           "plaintext_export_port": {
-            "label": "平文エクスポートポート:",
-            "tooltip": "GSM平文エクスポート用のWebSocketポート（現在未使用）。"
+            "label": "平文/JL Websocketエクスポートポート:",
+            "tooltip": "GSMが平文を送信するポート。JLなどの他のツールとの統合に便利です。"
           },
           "reset_line_hotkey": {
             "label": "行リセットホットキー:",

GameSentenceMiner/locales/zh_cn.json

@@ -497,11 +497,11 @@
           },
           "texthooker_comm_port": {
             "label": "Texthooker 通信 WebSocket 端口:",
-            "tooltip": "GSM Texthooker WebSocket 通信的端口。目前不起作用，硬编码为 55001。"
+            "tooltip": "GSM Texthooker WebSocket 通信的端口。"
           },
           "plaintext_export_port": {
-            "label": "纯文本 WebSocket 导出端口:",
-            "tooltip": "GSM 纯文本 WebSocket 导出通信的端口。目前不起作用，硬编码为 55002。"
+            "label": "纯文本/JL Websocket 导出端口:",
+            "tooltip": "GSM 将纯文本发送到的端口。对于与 JL 等其他工具集成很有用。"
           },
           "reset_line_hotkey": {
             "label": "重置行热键:",

GameSentenceMiner/ui/anki_confirmation.py

@@ -4,6 +4,7 @@ from PIL import Image, ImageTk
 
 import ttkbootstrap as ttk
 from GameSentenceMiner.util.configuration import get_config, logger, gsm_state
+from GameSentenceMiner.util.audio_player import AudioPlayer
 
 import platform
 import subprocess
@@ -17,10 +18,16 @@ class AnkiConfirmationDialog(tk.Toplevel):
         super().__init__(parent)
         self.config_app = config_app
         self.screenshot_timestamp = screenshot_timestamp
+        self.translation_text = None
+        self.sentence_text = None
         
         # Initialize screenshot_path here, will be updated by button if needed
         self.screenshot_path = screenshot_path 
 
+        # Audio player management
+        self.audio_player = AudioPlayer(finished_callback=self._audio_finished)
+        self.audio_button = None  # Store reference to audio button
+
         self.title("Confirm Anki Card Details")
         self.result = None  # This will store the user's choice
 
@@ -55,6 +62,10 @@ class AnkiConfirmationDialog(tk.Toplevel):
 
         self.protocol("WM_DELETE_WINDOW", self._on_cancel)
         self.attributes('-topmost', True)
+        
+        # Ensure audio cleanup on window close
+        self.protocol("WM_DELETE_WINDOW", self._cleanup_and_close)
+        
         self.wait_window(self)
 
     def _create_widgets(self, expression, sentence, screenshot_path, audio_path, translation):
@@ -76,13 +87,14 @@ class AnkiConfirmationDialog(tk.Toplevel):
         self.sentence_text = sentence_text
         row += 1
 
-        # Translation
-        ttk.Label(main_frame, text=f"{get_config().ai.anki_field}:", font=("-weight bold")).grid(row=row, column=0, sticky="ne", padx=5, pady=2)
-        translation_text = scrolledtext.ScrolledText(main_frame, height=4, width=50, wrap=tk.WORD)
-        translation_text.insert(tk.END, translation)
-        translation_text.grid(row=row, column=1, sticky="w", padx=5, pady=2)
-        self.translation_text = translation_text
-        row += 1
+        if translation:
+            # Translation
+            ttk.Label(main_frame, text=f"{get_config().ai.anki_field}:", font=("-weight bold")).grid(row=row, column=0, sticky="ne", padx=5, pady=2)
+            translation_text = scrolledtext.ScrolledText(main_frame, height=4, width=50, wrap=tk.WORD)
+            translation_text.insert(tk.END, translation)
+            translation_text.grid(row=row, column=1, sticky="w", padx=5, pady=2)
+            self.translation_text = translation_text
+            row += 1
 
         # Screenshot
         ttk.Label(main_frame, text=f"{get_config().anki.picture_field}:", font=("-weight bold")).grid(row=row, column=0, sticky="ne", padx=5, pady=2)
@@ -109,12 +121,20 @@ class AnkiConfirmationDialog(tk.Toplevel):
         row += 1
         
         # Audio Path
-        ttk.Label(main_frame, text="Audio Path:", font=("-weight bold")).grid(row=row, column=0, sticky="ne", padx=5, pady=2)
-        ttk.Label(main_frame, text=audio_path if audio_path else "No Audio", wraplength=400, justify="left").grid(row=row, column=1, sticky="w", padx=5, pady=2)
         if audio_path and os.path.isfile(audio_path):
-            ttk.Button(main_frame, text="Play Audio", command=lambda: self._play_audio(audio_path)).grid(row=row, column=2, sticky="w", padx=5, pady=2)
-            
-        row += 1
+            ttk.Label(main_frame, text="Audio Path:", font=("-weight bold")).grid(row=row, column=0, sticky="ne", padx=5, pady=2)
+            ttk.Label(main_frame, text=audio_path if audio_path else "No Audio", wraplength=400, justify="left").grid(row=row, column=1, sticky="w", padx=5, pady=2)
+            if audio_path and os.path.isfile(audio_path):
+                self.audio_button = ttk.Button(
+                    main_frame, 
+                    text="▶", 
+                    command=lambda: self._play_audio(audio_path),
+                    bootstyle="outline-info",
+                    width=12
+                )
+                self.audio_button.grid(row=row, column=2, sticky="w", padx=5, pady=2)
+
+            row += 1
 
         # Action Buttons
         button_frame = ttk.Frame(main_frame)
@@ -161,23 +181,60 @@ class AnkiConfirmationDialog(tk.Toplevel):
         if not os.path.isfile(audio_path):
             print(f"Audio file does not exist: {audio_path}")
             return
+        
         try:
-            if platform.system() == "Windows":
-                os.startfile(audio_path)
-            elif platform.system() == "Darwin":
-                subprocess.run(["open", audio_path])
+            # Check if we have a configuration for external audio player
+            if get_config().advanced.audio_player_path:
+                # Use external audio player
+                import platform
+                import subprocess
+                if platform.system() == "Windows":
+                    os.startfile(audio_path)
+                elif platform.system() == "Darwin":
+                    subprocess.run(["open", audio_path])
+                else:
+                    subprocess.run(["xdg-open", audio_path])
             else:
-                subprocess.run(["xdg-open", audio_path])
+                # Use internal audio player
+                success = self.audio_player.play_audio_file(audio_path)
+                if success:
+                    self._update_audio_button()
+                
         except Exception as e:
             print(f"Failed to play audio: {e}")
+    
+    def _audio_finished(self):
+        """Called when audio playback finishes"""
+        self._update_audio_button()
+    
+    def _update_audio_button(self):
+        """Update the audio button text and style based on playing state"""
+        if self.audio_button:
+            if self.audio_player.is_playing:
+                self.audio_button.config(text="⏹ Stop", bootstyle="outline-warning")
+            else:
+                self.audio_button.config(text="▶ Play Audio", bootstyle="outline-info")
+        
+    def _cleanup_audio(self):
+        """Clean up audio stream resources"""
+        self.audio_player.cleanup()
+    
+    def _cleanup_and_close(self):
+        """Clean up resources and close dialog"""
+        self._cleanup_audio()
+        self._on_cancel()
         
     def _on_voice(self):
+        # Clean up audio before closing
+        self._cleanup_audio()
         # The screenshot_path is now correctly updated if the user chose a new one
-        self.result = (True, self.sentence_text.get("1.0", tk.END).strip(), self.translation_text.get("1.0", tk.END).strip(), self.screenshot_path)
+        self.result = (True, self.sentence_text.get("1.0", tk.END).strip(), self.translation_text.get("1.0", tk.END).strip() if self.translation_text else None, self.screenshot_path)
         self.destroy()
 
     def _on_no_voice(self):
-        self.result = (False, self.sentence_text.get("1.0", tk.END).strip(), self.translation_text.get("1.0", tk.END).strip(), self.screenshot_path)
+        # Clean up audio before closing
+        self._cleanup_audio()
+        self.result = (False, self.sentence_text.get("1.0", tk.END).strip(), self.translation_text.get("1.0", tk.END).strip() if self.translation_text else None, self.screenshot_path)
         self.destroy()
         
     def _on_cancel(self):

GameSentenceMiner/ui/config_gui.py

@@ -698,7 +698,7 @@ class ConfigApp:
             ),
             overlay=Overlay(
                 websocket_port=int(self.overlay_websocket_port_value.get()),
-                monitor_to_capture=self.overlay_monitor.current() if self.monitors else 0,
+                monitor_to_capture=int(self.overlay_monitor.current() if self.monitors else 0),
                 engine=OverlayEngine(self.overlay_engine_value.get()).value if self.overlay_engine_value.get() else OverlayEngine.LENS.value,
                 scan_delay=float(self.scan_delay_value.get()),
                 periodic=float(self.periodic_value.get()),
@@ -732,6 +732,7 @@ class ConfigApp:
             self.master_config.set_config_for_profile(current_profile, config)
             
         self.master_config.locale = Locale[self.locale_value.get()].value
+        self.master_config.overlay = config.overlay
 
 
         config_backup_folder = os.path.join(get_app_directory(), "backup", "config")
@@ -877,6 +878,14 @@ class ConfigApp:
         ttk.Entry(self.general_tab, textvariable=self.texthooker_port_value).grid(row=self.current_row, column=1, sticky='EW', pady=2)
         self.current_row += 1
         
+        advanced_i18n = self.i18n.get('tabs', {}).get('advanced', {})
+        export_port_i18n = advanced_i18n.get('plaintext_export_port', {})
+        HoverInfoLabelWidget(self.general_tab, text=export_port_i18n.get('label', '...'),
+                             tooltip=export_port_i18n.get('tooltip', '...'),
+                             row=self.current_row, column=0)
+        ttk.Entry(self.general_tab, textvariable=self.plaintext_websocket_export_port_value).grid(row=self.current_row, column=1, sticky='EW', pady=2)
+        self.current_row += 1
+        
         # locale_i18n = general_i18n.get('locale', {})
         # HoverInfoLabelWidget(self.general_tab, text=locale_i18n.get('label', 'Locale:'),
         #                      tooltip=locale_i18n.get('tooltip', '...'),
@@ -2047,13 +2056,6 @@ class ConfigApp:
         ttk.Entry(advanced_frame, textvariable=self.texthooker_communication_websocket_port_value).grid(row=self.current_row, column=1, sticky='EW', pady=2)
         self.current_row += 1
 
-        export_port_i18n = advanced_i18n.get('plaintext_export_port', {})
-        HoverInfoLabelWidget(advanced_frame, text=export_port_i18n.get('label', '...'),
-                             tooltip=export_port_i18n.get('tooltip', '...'),
-                             row=self.current_row, column=0)
-        ttk.Entry(advanced_frame, textvariable=self.plaintext_websocket_export_port_value).grid(row=self.current_row, column=1, sticky='EW', pady=2)
-        self.current_row += 1
-
         reset_hotkey_i18n = advanced_i18n.get('reset_line_hotkey', {})
         HoverInfoLabelWidget(advanced_frame, text=reset_hotkey_i18n.get('label', '...'),
                              tooltip=reset_hotkey_i18n.get('tooltip', '...'), row=self.current_row, column=0)
@@ -2342,13 +2344,14 @@ class ConfigApp:
         
         overlay_monitor_i18n = overlay_i18n.get('overlay_monitor', {})
         HoverInfoLabelWidget(overlay_frame, text=overlay_monitor_i18n.get('label', '...'),
-                             tooltip=overlay_monitor_i18n.get('tooltip', '...'),
-                                row=self.current_row, column=0)
-        self.overlay_monitor = ttk.Combobox(overlay_frame, values=self.monitors, state="readonly")
+                     tooltip=overlay_monitor_i18n.get('tooltip', '...'),
+                    row=self.current_row, column=0)
+        self.overlay_monitor = ttk.Combobox(overlay_frame, values=self.monitors)
         self.overlay_monitor.grid(row=self.current_row, column=1, sticky='EW', pady=2)
         # disable selection for now, default to value 1
-        self.overlay_monitor.current(0)
-        self.overlay_monitor.config(state="disabled")
+        if self.settings.overlay.monitor_to_capture >= len(self.monitors):
+            self.settings.overlay.monitor_to_capture = 0
+        self.overlay_monitor.current(self.settings.overlay.monitor_to_capture)
         self.current_row += 1
 
         # Overlay Engine Selection

GameSentenceMiner/util/audio_player.py

@@ -0,0 +1,220 @@
+"""
+Audio playback utility module for GameSentenceMiner.
+Provides safe, non-blocking audio playback functionality.
+"""
+
+import threading
+from typing import Optional, Callable
+import sounddevice as sd
+import soundfile as sf
+import numpy as np
+
+
+class AudioPlayer:
+    """
+    A safe, non-blocking audio player class that handles audio stream management.
+    """
+    
+    def __init__(self, finished_callback: Optional[Callable] = None):
+        """
+        Initialize the audio player.
+        
+        Args:
+            finished_callback: Optional callback function to call when audio finishes playing
+        """
+        self.current_audio_stream: Optional[sd.OutputStream] = None
+        self.current_audio_data: Optional[np.ndarray] = None
+        self.current_audio_samplerate: Optional[int] = None
+        self.is_playing: bool = False
+        self._audio_position: int = 0
+        self.finished_callback = finished_callback
+        self._lock = threading.Lock()
+    
+    def play_audio_file(self, audio_path: str) -> bool:
+        """
+        Play an audio file. If already playing, stop the current playback.
+        
+        Args:
+            audio_path: Path to the audio file to play
+            
+        Returns:
+            True if playback started successfully, False otherwise
+        """
+        try:
+            # If audio is currently playing, stop it
+            if self.is_playing:
+                self.stop_audio()
+                return True
+            
+            # Load audio data
+            data, samplerate = sf.read(audio_path)
+            return self.play_audio_data(data, samplerate)
+            
+        except Exception as e:
+            print(f"Failed to play audio file {audio_path}: {e}")
+            self._cleanup_stream()
+            return False
+    
+    def play_audio_data(self, data: np.ndarray, samplerate: int) -> bool:
+        """
+        Play audio from numpy array data.
+        
+        Args:
+            data: Audio data as numpy array
+            samplerate: Sample rate of the audio data
+            
+        Returns:
+            True if playback started successfully, False otherwise
+        """
+        try:
+            with self._lock:
+                # Ensure data is float32 for sounddevice playback
+                data = data.astype('float32')
+                
+                # Store audio data
+                self.current_audio_data = data
+                self.current_audio_samplerate = samplerate
+                self._audio_position = 0
+                
+                # Create audio callback
+                def audio_callback(outdata, frames, time, status):
+                    if status:
+                        print(f"Audio callback status: {status}")
+                    
+                    # Calculate how much data we need for this callback
+                    start_frame = self._audio_position
+                    end_frame = start_frame + frames
+                    
+                    if end_frame <= len(data):
+                        # We have enough data
+                        if data.ndim == 1:
+                            outdata[:, 0] = data[start_frame:end_frame]
+                        else:
+                            outdata[:] = data[start_frame:end_frame]
+                        self._audio_position = end_frame
+                    else:
+                        # We've reached the end
+                        remaining_frames = len(data) - start_frame
+                        if remaining_frames > 0:
+                            if data.ndim == 1:
+                                outdata[:remaining_frames, 0] = data[start_frame:]
+                                outdata[remaining_frames:, 0] = 0
+                            else:
+                                outdata[:remaining_frames] = data[start_frame:]
+                                outdata[remaining_frames:] = 0
+                        else:
+                            outdata.fill(0)
+                        
+                        # Schedule cleanup
+                        self._schedule_finish()
+                
+                # Create and start audio stream
+                stream = sd.OutputStream(
+                    samplerate=samplerate,
+                    channels=data.shape[1] if data.ndim > 1 else 1,
+                    callback=audio_callback
+                )
+                
+                self.current_audio_stream = stream
+                self.is_playing = True
+                stream.start()
+                
+                return True
+                
+        except Exception as e:
+            print(f"Failed to play audio data: {e}")
+            self._cleanup_stream()
+            return False
+    
+    def stop_audio(self):
+        """Stop the currently playing audio."""
+        with self._lock:
+            if self.current_audio_stream and self.is_playing:
+                try:
+                    self.current_audio_stream.stop()
+                except Exception:
+                    pass
+            self._cleanup_stream()
+    
+    def _schedule_finish(self):
+        """Schedule the finish callback to be called."""
+        # Use threading to avoid blocking the audio callback
+        def finish_task():
+            self._audio_finished()
+        
+        threading.Thread(target=finish_task, daemon=True).start()
+    
+    def _audio_finished(self):
+        """Called when audio playback finishes."""
+        with self._lock:
+            self._cleanup_stream()
+            if self.finished_callback:
+                try:
+                    self.finished_callback()
+                except Exception as e:
+                    print(f"Error in audio finished callback: {e}")
+    
+    def _cleanup_stream(self):
+        """Clean up the current audio stream."""
+        if self.current_audio_stream:
+            try:
+                self.current_audio_stream.close()
+            except Exception:
+                pass
+        
+        self.current_audio_stream = None
+        self.is_playing = False
+        self.current_audio_data = None
+        self.current_audio_samplerate = None
+        self._audio_position = 0
+    
+    def cleanup(self):
+        """Clean up all resources."""
+        self.stop_audio()
+        self.finished_callback = None
+
+
+def create_safe_audio_callback(data: np.ndarray, position_tracker: dict, finish_callback: Callable):
+    """
+    Create a safe audio callback function for use with sounddevice.
+    
+    Args:
+        data: Audio data array
+        position_tracker: Dictionary to track playback position (mutable)
+        finish_callback: Function to call when playback finishes
+    
+    Returns:
+        Audio callback function
+    """
+    def audio_callback(outdata, frames, time, status):
+        if status:
+            print(f"Audio callback status: {status}")
+        
+        # Calculate how much data we need for this callback
+        start_frame = position_tracker.get('position', 0)
+        end_frame = start_frame + frames
+        
+        if end_frame <= len(data):
+            # We have enough data
+            if data.ndim == 1:
+                outdata[:, 0] = data[start_frame:end_frame]
+            else:
+                outdata[:] = data[start_frame:end_frame]
+            position_tracker['position'] = end_frame
+        else:
+            # We've reached the end
+            remaining_frames = len(data) - start_frame
+            if remaining_frames > 0:
+                if data.ndim == 1:
+                    outdata[:remaining_frames, 0] = data[start_frame:]
+                    outdata[remaining_frames:, 0] = 0
+                else:
+                    outdata[:remaining_frames] = data[start_frame:]
+                    outdata[remaining_frames:] = 0
+            else:
+                outdata.fill(0)
+            
+            # Schedule cleanup
+            threading.Thread(target=finish_callback, daemon=True).start()
+    
+    return audio_callback

GameSentenceMiner/util/configuration.py

@@ -666,7 +666,17 @@ class Overlay:
     def __post_init__(self):
         if self.monitor_to_capture == -1:
             self.monitor_to_capture = 0  # Default to the first monitor if not set
-
+            
+        try:
+            import mss as mss
+            monitors = [f"Monitor {i}: width: {monitor['width']}, height: {monitor['height']}" for i, monitor in enumerate(mss.mss().monitors[1:], start=1)]
+            if len(monitors) == 0:
+                monitors = [1]
+            self.monitors = monitors
+        except ImportError:
+            self.monitors = []
+        if self.monitor_to_capture >= len(self.monitors):
+            self.monitor_to_capture = 0  # Reset to first monitor if out of range
 
 @dataclass_json
 @dataclass
@@ -823,6 +833,7 @@ class Config:
     switch_to_default_if_not_found: bool = True
     locale: str = Locale.English.value
     stats: StatsConfig = field(default_factory=StatsConfig)
+    overlay: Overlay = field(default_factory=Overlay)
     version: str = ""
 
     @classmethod
@@ -865,7 +876,7 @@ class Config:
         if self.version:
             if self.version != get_current_version():
                 from packaging import version
-                logger.info(f"Config version mismatch detected: {self.version} != {get_current_version()}")
+                logger.info(f"New Config Found: {self.version} != {get_current_version()}")
                 # Handle version mismatch
                 changed = False
                 if version.parse(self.version) < version.parse("2.18.0"):
@@ -879,6 +890,7 @@ class Config:
 
                 if changed:
                     self.save()
+        self.overlay = self.get_config().overlay
 
         self.version = get_current_version()
 
@@ -1160,6 +1172,11 @@ def get_config():
     # print(config_instance.get_config())
     return config_instance.get_config()
 
+def get_overlay_config():
+    global config_instance
+    if config_instance is None:
+        config_instance = load_config()
+    return config_instance.overlay
 
 def reload_config():
     global config_instance
@@ -1284,6 +1301,7 @@ class GsmAppState:
         self.recording_started_time = None
         self.current_srt = None
         self.srt_index = 1
+        self.current_audio_stream = None
 
 
 @dataclass_json
@@ -1297,10 +1315,11 @@ class AnkiUpdateResult:
     multi_line: bool = False
     video_in_anki: str = ''
     word_path: str = ''
+    word: str = ''
 
     @staticmethod
     def failure():
-        return AnkiUpdateResult(success=False, audio_in_anki='', screenshot_in_anki='', prev_screenshot_in_anki='', sentence_in_anki='', multi_line=False, video_in_anki='', word_path='')
+        return AnkiUpdateResult(success=False, audio_in_anki='', screenshot_in_anki='', prev_screenshot_in_anki='', sentence_in_anki='', multi_line=False, video_in_anki='', word_path='', word='')
 
 
 @dataclass_json