whisper-key-local 0.5.3__py3-none-any.whl → 0.6.0__py3-none-any.whl

whisper_key/assets/version.txt

@@ -1 +1 @@
-0.5.3
+0.6.0

whisper_key/audio_feedback.py

@@ -1,56 +1,57 @@
 import logging
 import os
+import platform
 import threading
-import winsound
+
+from playsound3 import playsound
+
+SOUND_BACKEND = "winmm" if platform.system() == "Windows" else None
 
 from .utils import resolve_asset_path
 
-class AudioFeedback:    
+class AudioFeedback:
     def __init__(self, enabled=True, start_sound='', stop_sound='', cancel_sound=''):
         self.enabled = enabled
         self.logger = logging.getLogger(__name__)
-        
+
         self.start_sound_path = resolve_asset_path(start_sound)
         self.stop_sound_path = resolve_asset_path(stop_sound)
         self.cancel_sound_path = resolve_asset_path(cancel_sound)
-        
+
         if not self.enabled:
             self.logger.info("Audio feedback disabled by configuration")
             print("   ✗ Audio feedback disabled")
         else:
             self._validate_sound_files()
             print("   ✓ Audio feedback enabled...")
-    
+
     def _validate_sound_files(self):
         if self.start_sound_path and not os.path.isfile(self.start_sound_path):
             self.logger.warning(f"Start sound file not found: {self.start_sound_path}")
-        
+
         if self.stop_sound_path and not os.path.isfile(self.stop_sound_path):
             self.logger.warning(f"Stop sound file not found: {self.stop_sound_path}")
-        
+
         if self.cancel_sound_path and not os.path.isfile(self.cancel_sound_path):
             self.logger.warning(f"Cancel sound file not found: {self.cancel_sound_path}")
-    
+
     def _play_sound_file_async(self, file_path: str):
-        def play_sound():
+        def play():
             try:
-                # SND_FILENAME = play from file, SND_ASYNC = don't block
-                winsound.PlaySound(file_path, winsound.SND_FILENAME | winsound.SND_ASYNC)
-                
+                playsound(file_path, block=False, backend=SOUND_BACKEND)
             except Exception as e:
                 self.logger.warning(f"Failed to play sound file {file_path}: {e}")
-        
-        sound_thread = threading.Thread(target=play_sound, daemon=True)
-        sound_thread.start()
-    
+
+        threading.Thread(target=play, daemon=True).start()
+
     def play_start_sound(self):
         if self.enabled:
             self._play_sound_file_async(self.start_sound_path)
-    
+
     def play_stop_sound(self):
-        if self.enabled:        
+        if self.enabled:
             self._play_sound_file_async(self.stop_sound_path)
-    
+
     def play_cancel_sound(self):
         if self.enabled:
-            self._play_sound_file_async(self.cancel_sound_path)
+            self._play_sound_file_async(self.cancel_sound_path)

whisper_key/clipboard_manager.py

@@ -3,13 +3,10 @@ import time
 from typing import Optional
 
 import pyperclip
-import win32gui
-import pyautogui
 
+from .platform import keyboard
 from .utils import parse_hotkey
 
-pyautogui.FAILSAFE = True  # Enable "move mouse to corner to abort automation"
-
 class ClipboardManager:
     def __init__(self, key_simulation_delay, auto_paste, preserve_clipboard, paste_hotkey):
         self.logger = logging.getLogger(__name__)
@@ -18,90 +15,77 @@ class ClipboardManager:
         self.preserve_clipboard = preserve_clipboard
         self.paste_hotkey = paste_hotkey
         self.paste_keys = parse_hotkey(paste_hotkey)
-        self._configure_pyautogui_timing()
+        self._configure_keyboard_timing()
         self._test_clipboard_access()
         self._print_status()
-    
-    def _configure_pyautogui_timing(self):
-        pyautogui.PAUSE = self.key_simulation_delay
-    
+
+    def _configure_keyboard_timing(self):
+        keyboard.set_delay(self.key_simulation_delay)
+
     def _test_clipboard_access(self):
         try:
             pyperclip.paste()
             self.logger.info("Clipboard access test successful")
-            
+
         except Exception as e:
             self.logger.error(f"Clipboard access test failed: {e}")
             raise
-    
+
     def _print_status(self):
         hotkey_display = self.paste_hotkey.upper()
         if self.auto_paste:
             print(f"   ✓ Auto-paste is ENABLED using key simulation ({hotkey_display})")
         else:
             print(f"   ✗ Auto-paste is DISABLED - paste manually with {hotkey_display}")
-    
+
     def copy_text(self, text: str) -> bool:
         if not text:
             return False
-        
+
         try:
             self.logger.info(f"Copying text to clipboard ({len(text)} chars)")
             pyperclip.copy(text)
             return True
-                
+
         except Exception as e:
             self.logger.error(f"Failed to copy text to clipboard: {e}")
             return False
-    
+
     def get_clipboard_content(self) -> Optional[str]:
         try:
             clipboard_content = pyperclip.paste()
-            
+
             if clipboard_content:
                 return clipboard_content
             else:
                 return None
-                
+
         except Exception as e:
             self.logger.error(f"Failed to paste text from clipboard: {e}")
             return None
-    
+
     def copy_with_notification(self, text: str) -> bool:
         if not text:
             return False
-        
+
         success = self.copy_text(text)
-        
+
         if success:
             print("   ✓ Copied to clipboard")
             print("   ✓ You can now paste with Ctrl+V in any application!")
-        
+
         return success
-    
+
     def clear_clipboard(self) -> bool:
         try:
             pyperclip.copy("")
             return True
-            
+
         except Exception as e:
             self.logger.error(f"Failed to clear clipboard: {e}")
             return False
-    
-    def get_active_window_handle(self) -> Optional[int]:
-        try:
-            hwnd = win32gui.GetForegroundWindow()
-            if hwnd:
-                window_title = win32gui.GetWindowText(hwnd)
-                self.logger.info(f"Active window: '{window_title}' (handle: {hwnd})")
-                return hwnd
-            else:
-                return None
-        except Exception as e:
-            self.logger.error(f"Failed to get active window handle: {e}")
-            return None       
-    
-    def execute_auto_paste(self, text: str, preserve_clipboard: bool) -> bool:              
+
+    def execute_auto_paste(self, text: str, preserve_clipboard: bool) -> bool:
         try:
             original_content = None
             if preserve_clipboard:
@@ -109,8 +93,8 @@ class ClipboardManager:
 
             if not self.copy_text(text):
                 return False
-                      
-            pyautogui.hotkey(*self.paste_keys)
+
+            keyboard.send_hotkey(*self.paste_keys)
 
             print(f"   ✓ Auto-pasted via key simulation")
 
@@ -119,19 +103,19 @@ class ClipboardManager:
                 time.sleep(self.key_simulation_delay)
 
             return True
-            
+
         except Exception as e:
             self.logger.error(f"Failed to simulate paste keypress: {e}")
             return False
-        
+
     def send_enter_key(self) -> bool:
         try:
             self.logger.info("Sending ENTER key to active application")
-            pyautogui.press('enter')
+            keyboard.send_key('enter')
             print("   ✓ Text submitted with ENTER!")
 
             return True
-            
+
         except Exception as e:
             self.logger.error(f"Failed to send ENTER key: {e}")
             return False
@@ -139,30 +123,29 @@ class ClipboardManager:
     def deliver_transcription(self,
                               transcribed_text: str,
                               use_auto_enter: bool = False) -> bool:
-        
+
         try:
             if use_auto_enter:
                 print("🚀 Auto-pasting text and SENDING with ENTER...")
-               
-                # Force auto-paste when using auto-enter hotkey
+
                 success = self.execute_auto_paste(transcribed_text, self.preserve_clipboard)
                 if success:
                     success = self.send_enter_key()
 
             elif self.auto_paste:
                 print("🚀 Auto-pasting text...")
-                success = self.execute_auto_paste(transcribed_text, self.preserve_clipboard)             
-                    
+                success = self.execute_auto_paste(transcribed_text, self.preserve_clipboard)
+
             else:
                 print("📋 Copying to clipboard...")
-                success = self.copy_with_notification(transcribed_text)        
+                success = self.copy_with_notification(transcribed_text)
 
             return success
 
         except Exception as e:
             self.logger.error(f"Delivery workflow failed: {e}")
             return False
-        
+
     def update_auto_paste(self, enabled: bool):
         self.auto_paste = enabled
-        self._print_status()
+        self._print_status()

whisper_key/config.defaults.yaml

@@ -3,9 +3,10 @@
 # =============================================================================
 # DO NOT EDIT THIS FILE
 # This is the default configuration template for Whisper Key
-# 
+#
 # Personal settings are stored at:
-# %APPDATA%\Roaming\whisperkey\user_settings.yaml
+# Windows: %APPDATA%\whisperkey\user_settings.yaml
+# macOS: ~/Library/Application Support/whisperkey/user_settings.yaml
 
 whisper: # Whisper AI Model Settings
 
@@ -15,7 +16,12 @@ whisper: # Whisper AI Model Settings
   
   # Processing device - where the AI runs
   # Options: "cpu", "cuda" (for NVIDIA GPUs)
-  # Note: "cuda" requires compatible GPU and drivers
+  #
+  # CUDA Setup (for NVIDIA GPUs only):
+  #   1. Install CUDA 12: 
+  #      winget install Nvidia.CUDA --version 12.9
+  #      Or download from: https://developer.nvidia.com/cuda-downloads
+  #   2. Set device: cuda and compute_type: float16 below
   device: cpu
   
   # Compute precision - affects speed vs accuracy
@@ -89,14 +95,16 @@ hotkey: # Hotkey Configuration
 
   # Key combination to start/stop recording
   # Format: modifier+modifier+key (use lowercase)
-  # Common modifiers: ctrl, shift, alt, win
+  # Windows modifiers: ctrl, shift, alt, win
+  # macOS modifiers: cmd, ctrl, shift, option, fn
   # Examples:
-  #   - "ctrl+shift+space"     (default)
+  #   - "ctrl+win"      (Windows default)
+  #   - "fn+ctrl"       (macOS default)
   #   - "ctrl+alt+r"
-  #   - "win+shift+v"
+  #   - "win+v"
   #   - "ctrl+shift+f12"
-  recording_hotkey: ctrl+win
-  
+  recording_hotkey: "ctrl+win | macos: fn+ctrl"
+
   # Stop recording with just the first modifier key
   # If enabled, stops recording with first modifier of the main hotkey
   # (e.g., if combination is 'ctrl+win', pressing 'ctrl' will stop)
@@ -109,12 +117,13 @@ hotkey: # Hotkey Configuration
   auto_enter_enabled: true
 
   # Key combination for auto-ENTER function
-  auto_enter_combination: alt
+  auto_enter_combination: "alt | macos: option"
   
   # Key combination to cancel recording
   # Format: modifier+modifier+key (use lowercase) or single key
-  # Examples: "esc", "ctrl+c", "shift+esc" 
-  cancel_combination: esc
+  # Examples: "esc", "ctrl+c", "shift+esc"
+  # Note: On macOS, ESC is system-reserved
+  cancel_combination: "esc | macos: shift"
 
 vad: # Voice Activity Detection (VAD)
 
@@ -169,7 +178,7 @@ clipboard: # Clipboard Behavior
 
   # Automatically paste after transcription
   # true = paste immediately to active window
-  # false = only copy to clipboard (paste manually with Ctrl+V)
+  # false = only copy to clipboard (paste manually)
   auto_paste: true
 
   # Key combination to simulate paste
@@ -178,7 +187,7 @@ clipboard: # Clipboard Behavior
   #   - "ctrl+v"         (standard paste)
   #   - "ctrl+shift+v"   (plain text paste in some apps)
   #   - "shift+insert"   (terminal paste)
-  paste_hotkey: ctrl+v
+  paste_hotkey: "ctrl+v | macos: cmd+v"
 
   # Preserve existing clipboard content when pasting
   # true = save current clipboard, paste transcription, then restore original clipboard

whisper_key/config_manager.py

@@ -1,28 +1,45 @@
 import os
 import logging
-import shutil
 import platform
+import shutil
 from typing import Dict, Any, Optional
 from io import StringIO
 
 from ruamel.yaml import YAML
 
 from .utils import resolve_asset_path, beautify_hotkey, get_user_app_data_path
+from .platform import IS_MACOS
 
 def deep_merge_config(default_config: Dict[str, Any],
                       user_config: Dict[str, Any]) -> Dict[str, Any]:
-    
+
     result = default_config.copy()
-    
+
     for key, value in user_config.items():
         if key in result and isinstance(result[key], dict) and isinstance(value, dict):
             result[key] = deep_merge_config(result[key], value)
         else:
             result[key] = value
-    
+
     return result
 
 
+def _parse_platform_value(value: str) -> str:
+    parts = value.split(' | macos:')
+    default_value = parts[0].strip()
+    macos_value = parts[1].strip() if len(parts) > 1 else default_value
+    return macos_value if IS_MACOS else default_value
+
+
+def _resolve_platform_values(config: Dict[str, Any]) -> Dict[str, Any]:
+    for key, value in config.items():
+        if isinstance(value, dict):
+            _resolve_platform_values(value)
+        elif isinstance(value, str) and ' | macos:' in value:
+            config[key] = _parse_platform_value(value)
+    return config
+
+
 class ConfigManager:   
     def __init__(self, config_path: str = None, use_user_settings: bool = True):
         if config_path is None:
@@ -109,9 +126,10 @@ class ConfigManager:
                 
                 self._remove_unused_keys_from_user_config(user_config, default_config)
                 merged_config = deep_merge_config(default_config, user_config)
+                resolved_config = _resolve_platform_values(merged_config)
                 self.logger.info(f"Loaded user configuration from {self.config_path}")
-                
-                validated_config = self.validator.fix_config(merged_config, default_config)
+
+                validated_config = self.validator.fix_config(resolved_config, default_config)
                 self.config = validated_config
                 
                 self.save_config_to_user_settings_file()
@@ -125,7 +143,7 @@ class ConfigManager:
                     self.logger.error(f"Error loading user config file: {e}")
                 
         self.logger.info(f"Using default configuration from {self.default_config_path}")
-        return default_config
+        return _resolve_platform_values(default_config)
     
     def _load_default_config(self) -> Dict[str, Any]:
         try:
@@ -272,8 +290,6 @@ class ConfigManager:
                     self.config[section][key] = value
                     self.save_config_to_user_settings_file()
 
-                    print(f"⚙️ Updated {section} setting")
-                
                     self.logger.debug(f"Updated setting {section}.{key}: {old_value} -> {value}")
             else:
                 self.logger.error(f"Setting {section}:{key} does not exist")

whisper_key/console_manager.py

@@ -1,59 +1,3 @@
-import win32console
-import win32gui
-import win32con
-import logging
-import threading
-import time
+from .platform import console
 
-class ConsoleManager:
-    def __init__(self, config: dict, is_executable_mode: bool = False):
-        self.logger = logging.getLogger(__name__)
-        self.config = config
-        self.is_executable_mode = is_executable_mode
-        self.console_handle = None
-        self._lock = threading.Lock()
-
-        try:
-            self.console_handle = self.get_console_window()
-        except Exception as e:
-            self.logger.error(f"Failed to initialize console manager: {e}")
-
-        self.hide_on_startup()
-
-    def get_console_window(self):
-        try:
-            handle = win32console.GetConsoleWindow()
-            if handle:
-                self.logger.debug(f"Console window handle: {handle}")
-                return handle
-            else:
-                self.logger.warning("GetConsoleWindow returned null handle")
-                return None
-        except Exception as e:
-            self.logger.error(f"Failed to get console window: {e}")
-            return None
-
-    def hide_on_startup(self):
-        if self.config.get('start_hidden', False) and self.is_executable_mode:
-            time.sleep(2)
-            self.hide_console()
-
-    def show_console(self):
-        with self._lock:
-            try:
-                win32gui.ShowWindow(self.console_handle, win32con.SW_HIDE)
-                win32gui.ShowWindow(self.console_handle, win32con.SW_RESTORE)
-                win32gui.SetForegroundWindow(self.console_handle)
-                return True
-            except Exception as e:
-                self.logger.error(f"Failed to show/focus console: {e}")
-                return False
-
-    def hide_console(self):
-        with self._lock:
-            try:
-                win32gui.ShowWindow(self.console_handle, win32con.SW_HIDE)
-                return True
-            except Exception as e:
-                self.logger.error(f"Failed to hide console: {e}")
-                return False
+ConsoleManager = console.ConsoleManager