stttype 1.0.0__py3-none-any.whl

stttype/__init__.py

@@ -0,0 +1,8 @@
+"""STT Type - Voice to Text Assistant
+
+Hold F2 to record, release to transcribe and type.
+GPU-accelerated using faster-whisper.
+"""
+
+__version__ = "1.0.0"
+__author__ = "STT Type"

stttype/bell.py

@@ -0,0 +1,56 @@
+"""
+Bell/sound notification module.
+Cross-platform sound using system beep or platform-specific methods.
+"""
+import platform
+import sys
+
+SYSTEM = platform.system()
+
+if SYSTEM == "Windows":
+    try:
+        import winsound
+    except ImportError:
+        winsound = None
+else:
+    winsound = None
+
+
+def _beep(freq, duration):
+    """Cross-platform beep."""
+    if winsound:
+        winsound.Beep(freq, duration)
+    else:
+        # Unix fallback - print bell character
+        print("\a", end="", flush=True)
+        sys.stdout.flush()
+
+
+def play_start_sound():
+    """Play a sound when recording starts (higher pitch beep)."""
+    if winsound:
+        winsound.MessageBeep(winsound.MB_ICONEXCLAMATION)
+    _beep(880, 150)
+    _beep(1100, 200)
+
+
+def play_stop_sound():
+    """Play a sound when recording stops (lower pitch double beep)."""
+    _beep(880, 150)
+    _beep(660, 300)
+
+
+def play_error_sound():
+    """Play an error sound."""
+    if winsound:
+        winsound.MessageBeep(winsound.MB_ICONHAND)
+    else:
+        print("\a\a", end="", flush=True)
+        sys.stdout.flush()
+
+
+def play_success_sound():
+    """Play a success sound after transcription."""
+    _beep(523, 100)
+    _beep(659, 100)
+    _beep(784, 200)

stttype/cli.py

@@ -0,0 +1,226 @@
+"""
+STT Type CLI - Universal command-line interface
+"""
+import os
+import sys
+import argparse
+import subprocess
+import time
+
+# Project paths
+PACKAGE_DIR = os.path.dirname(os.path.abspath(__file__))
+PROJECT_ROOT = os.path.dirname(PACKAGE_DIR)
+SRC_DIR = os.path.join(PROJECT_ROOT, "src")
+SCRIPTS_DIR = os.path.join(PROJECT_ROOT, "scripts")
+STARTUP_FOLDER = os.path.join(
+    os.environ.get("APPDATA", ""),
+    "Microsoft", "Windows", "Start Menu", "Programs", "Startup"
+)
+SHORTCUT_PATH = os.path.join(STARTUP_FOLDER, "STT Type.lnk")
+TRAY_SCRIPT = os.path.join(SCRIPTS_DIR, "run_silent.vbs")
+
+
+def _run_ps(cmd):
+    """Run a PowerShell command and return stdout."""
+    result = subprocess.run(
+        ["powershell", "-NoProfile", "-Command", cmd],
+        capture_output=True, text=True, timeout=10
+    )
+    return result.stdout.strip(), result.returncode
+
+
+def is_running():
+    """Check if STT Type is already running."""
+    try:
+        result = subprocess.run(
+            ["powershell", "-NoProfile", "-Command",
+             "Get-Process pythonw -ErrorAction SilentlyContinue | Where-Object {"
+             "(Get-WmiObject Win32_Process -Filter \"ProcessId=$($_.Id)\").CommandLine -match 'main\\.py'"
+             "} | Select-Object -First 1"],
+            capture_output=True, text=True, timeout=5
+        )
+        return bool(result.stdout.strip())
+    except Exception:
+        return False
+
+
+def get_running_pids():
+    """Get list of running STT Type process IDs."""
+    try:
+        result = subprocess.run(
+            ["powershell", "-NoProfile", "-Command",
+             "$procs = @(); "
+             "Get-Process pythonw -ErrorAction SilentlyContinue | ForEach-Object {"
+             "  $cmd = (Get-WmiObject Win32_Process -Filter \"ProcessId=$($_.Id)\").CommandLine;"
+             "  if ($cmd -match 'main\\.py') { $procs += $_.Id }"
+             "};"
+             "Get-Process python -ErrorAction SilentlyContinue | ForEach-Object {"
+             "  $cmd = (Get-WmiObject Win32_Process -Filter \"ProcessId=$($_.Id)\").CommandLine;"
+             "  if ($cmd -match 'main\\.py') { $procs += $_.Id }"
+             "};"
+             "$procs -join ','"],
+            capture_output=True, text=True
+        )
+        pids = [p for p in result.stdout.strip().split(",") if p.strip().isdigit()]
+        return pids
+    except Exception:
+        return []
+
+
+def cmd_start(args):
+    """Start STT Type in background."""
+    if is_running():
+        print("[WARN] STT Type is already running!")
+        return 1
+    
+    print(f"[INFO] Starting STT Type in background...")
+    print(f"       Model: {args.model} | Language: {args.lang}")
+    
+    try:
+        subprocess.Popen(
+            ["pythonw", os.path.join(SRC_DIR, "main.py"),
+             "--tray", "--model", args.model, "--lang", args.lang],
+            cwd=PROJECT_ROOT,
+            creationflags=subprocess.CREATE_NO_WINDOW
+        )
+        
+        time.sleep(2)
+        
+        if is_running():
+            print("[OK] STT Type started successfully")
+            return 0
+        else:
+            print("[ERR] Failed to start STT Type")
+            return 1
+    except Exception as e:
+        print(f"[ERR] Error starting: {e}")
+        return 1
+
+
+def cmd_shutdown(args):
+    """Stop all STT Type processes."""
+    print("[INFO] Shutting down STT Type...")
+    
+    pids = get_running_pids()
+    killed = 0
+    
+    for pid in pids:
+        try:
+            subprocess.run(["taskkill", "/F", "/PID", pid], 
+                         capture_output=True, check=False)
+            killed += 1
+        except Exception:
+            pass
+    
+    if killed > 0:
+        print(f"[OK] Shutdown complete ({killed} process(es) killed)")
+    else:
+        print("[WARN] No STT Type processes found")
+    return 0
+
+
+def cmd_status(args):
+    """Check if STT Type is running."""
+    pids = get_running_pids()
+    if pids:
+        print("[OK] STT Type is RUNNING")
+        for pid in pids:
+            print(f"     PID: {pid}")
+    else:
+        print("[STOPPED] STT Type is not running")
+    return 0
+
+
+def cmd_restart(args):
+    """Restart STT Type."""
+    print("[INFO] Restarting STT Type...")
+    cmd_shutdown(args)
+    time.sleep(1)
+    return cmd_start(args)
+
+
+def cmd_addtostartup(args):
+    """Add STT Type to Windows startup."""
+    if os.path.exists(SHORTCUT_PATH):
+        print("[WARN] STT Type is already in startup!")
+        return 1
+    
+    print("[INFO] Adding STT Type to Windows startup...")
+    
+    ps_cmd = (
+        f"$WshShell = New-Object -ComObject WScript.Shell;"
+        f"$Shortcut = $WshShell.CreateShortcut('{SHORTCUT_PATH}');"
+        f"$Shortcut.TargetPath = '{TRAY_SCRIPT}';"
+        f"$Shortcut.WorkingDirectory = '{PROJECT_ROOT}';"
+        f"$Shortcut.IconLocation = 'C:\\\\Windows\\\\System32\\\\shell32.dll,22';"
+        f"$Shortcut.Description = 'STT Type - Voice to Text';"
+        f"$Shortcut.Save()"
+    )
+    
+    try:
+        _run_ps(ps_cmd)
+        
+        if os.path.exists(SHORTCUT_PATH):
+            print(f"[OK] Added to startup: {SHORTCUT_PATH}")
+            return 0
+        else:
+            print("[ERR] Failed to create startup shortcut")
+            return 1
+    except Exception as e:
+        print(f"[ERR] Error adding to startup: {e}")
+        return 1
+
+
+def cmd_rmtostartup(args):
+    """Remove STT Type from Windows startup."""
+    if not os.path.exists(SHORTCUT_PATH):
+        print("[WARN] STT Type is not in startup!")
+        return 1
+    
+    print("[INFO] Removing STT Type from Windows startup...")
+    
+    try:
+        os.remove(SHORTCUT_PATH)
+        print("[OK] Removed from startup")
+        return 0
+    except Exception as e:
+        print(f"[ERR] Error removing from startup: {e}")
+        return 1
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="STT Type - Voice to Text Assistant",
+        formatter_class=argparse.RawDescriptionHelpFormatter
+    )
+    
+    parser.add_argument("--start", action="store_true", help="Start STT Type in background")
+    parser.add_argument("--shutdown", action="store_true", help="Stop all STT Type processes")
+    parser.add_argument("--status", action="store_true", help="Check if STT Type is running")
+    parser.add_argument("--restart", action="store_true", help="Restart STT Type")
+    parser.add_argument("--addtostartup", action="store_true", help="Add to Windows startup")
+    parser.add_argument("--rmtostartup", action="store_true", help="Remove from Windows startup")
+    parser.add_argument("--model", default="base", help="Whisper model: tiny/base/small/medium/large-v3")
+    parser.add_argument("--lang", default="en", help="Language code: en/zh/auto/etc")
+    
+    args = parser.parse_args()
+    
+    commands = [
+        ("start", cmd_start),
+        ("shutdown", cmd_shutdown),
+        ("status", cmd_status),
+        ("restart", cmd_restart),
+        ("addtostartup", cmd_addtostartup),
+        ("rmtostartup", cmd_rmtostartup),
+    ]
+    
+    for flag, func in commands:
+        if getattr(args, flag):
+            return func(args)
+    
+    parser.print_help()
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

stttype/main.py

@@ -0,0 +1,241 @@
+"""
+STT Assistant - Hold F2 to record, release to transcribe and type.
+Runs in background with system tray icon.
+GPU-accelerated using faster-whisper.
+Cross-platform: Windows, Linux, macOS
+"""
+import os
+import sys
+import threading
+import time
+import argparse
+import platform
+
+# Add script directory to path
+SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
+if SCRIPT_DIR not in sys.path:
+    sys.path.insert(0, SCRIPT_DIR)
+
+# Project root for other paths
+PROJECT_ROOT = os.path.dirname(SCRIPT_DIR)
+TEMP_DIR = os.path.join(PROJECT_ROOT, "temp")
+os.makedirs(TEMP_DIR, exist_ok=True)
+
+from recorder import AudioRecorder
+from transcriber import WhisperTranscriber
+from typer import KeyboardTyper
+from bell import play_start_sound, play_stop_sound, play_error_sound, play_success_sound
+from recorder_indicator import RecordingIndicator
+
+# Global state
+is_recording = False
+recorder = None
+transcriber = None
+typer = None
+audio_file = None
+indicator = None
+_listener = None
+
+
+def on_f2_press():
+    """Called when F2 is pressed."""
+    global is_recording, recorder, audio_file, indicator
+    
+    if is_recording:
+        return
+    
+    is_recording = True
+    audio_file = None
+    
+    print("[MIC] Recording started...")
+    play_start_sound()
+    
+    # Show red dot indicator
+    if indicator:
+        indicator.show()
+    
+    if recorder:
+        recorder.start()
+
+
+def on_f2_release():
+    """Called when F2 is released."""
+    global is_recording, recorder, transcriber, typer, audio_file, indicator
+    
+    if not is_recording:
+        return
+    
+    is_recording = False
+    print("[STOP] Recording stopped. Transcribing...")
+    play_stop_sound()
+    
+    # Hide red dot indicator
+    if indicator:
+        indicator.hide()
+    
+    # Stop recording and get audio file
+    if recorder:
+        audio_file = recorder.stop()
+    
+    if not audio_file or not os.path.exists(audio_file):
+        print("[WARN] No audio recorded")
+        play_error_sound()
+        return
+    
+    try:
+        # Transcribe
+        text = transcriber.transcribe(audio_file)
+        print(f"[TEXT] Transcribed: {text}")
+        
+        if text:
+            play_success_sound()
+            # Type the text
+            typer.type_text(text)
+            print("[TYPE] Text typed!")
+        else:
+            print("[WARN] No speech detected")
+            play_error_sound()
+    
+    except Exception as e:
+        print(f"[ERR] Error: {e}")
+        play_error_sound()
+    
+    finally:
+        # Cleanup audio file
+        if recorder and audio_file:
+            recorder.cleanup(audio_file)
+            audio_file = None
+
+
+def setup_hotkeys():
+    """Setup global F2 hotkey listeners using pynput (cross-platform)."""
+    global _listener
+    
+    try:
+        from pynput import keyboard as pk
+    except ImportError:
+        print("ERROR: 'pynput' not installed. Run: pip install pynput")
+        sys.exit(1)
+    
+    def on_press(key):
+        global is_recording
+        if key == pk.Key.f2 and not is_recording:
+            on_f2_press()
+    
+    def on_release(key):
+        global is_recording
+        if key == pk.Key.f2 and is_recording:
+            on_f2_release()
+    
+    _listener = pk.Listener(on_press=on_press, on_release=on_release)
+    _listener.start()
+    
+    print("[OK] Hotkeys registered: Hold F2 to record, release to transcribe")
+    print("   Press Ctrl+C or close window to exit")
+
+
+def run_console():
+    """Run in console mode."""
+    global recorder, transcriber, typer, indicator
+    
+    # Initialize components
+    print("[INIT] Initializing STT Assistant...")
+    print("   Loading Whisper model (this may take a moment)...")
+    
+    recorder = AudioRecorder(sample_rate=16000, channels=1)
+    transcriber = WhisperTranscriber(
+        model_size="base",
+        device="cuda",
+        compute_type="float16"
+    )
+    typer = KeyboardTyper()
+    indicator = RecordingIndicator()
+    
+    # Setup hotkeys
+    setup_hotkeys()
+    
+    print("\n[READY] Hold F2 to record your voice.")
+    
+    # Keep the main thread alive
+    try:
+        while True:
+            time.sleep(1)
+    except KeyboardInterrupt:
+        print("\n[EXIT] Shutting down...")
+        if _listener:
+            _listener.stop()
+
+
+def run_tray():
+    """Run with system tray icon."""
+    global recorder, transcriber, typer, indicator
+    
+    try:
+        import pystray
+        from PIL import Image, ImageDraw
+    except ImportError:
+        print("pystray or PIL not installed. Running in console mode.")
+        print("Install with: pip install pystray pillow")
+        run_console()
+        return
+    
+    def create_image():
+        """Create a simple icon image."""
+        width = 64
+        height = 64
+        image = Image.new('RGB', (width, height), color=(0, 120, 212))
+        dc = ImageDraw.Draw(image)
+        dc.ellipse([8, 8, width-8, height-8], fill=(255, 255, 255))
+        dc.ellipse([16, 16, width-16, height-16], fill=(0, 120, 212))
+        return image
+    
+    def on_show(icon, item):
+        print("STT Assistant is running. Hold F2 to record.")
+    
+    def on_exit(icon, item):
+        icon.stop()
+        if _listener:
+            _listener.stop()
+        os._exit(0)
+    
+    # Initialize components
+    print("[INIT] Initializing STT Assistant...")
+    recorder = AudioRecorder(sample_rate=16000, channels=1)
+    transcriber = WhisperTranscriber(
+        model_size="base",
+        device="cuda",
+        compute_type="float16"
+    )
+    typer = KeyboardTyper()
+    indicator = RecordingIndicator()
+    
+    setup_hotkeys()
+    
+    # Create tray icon
+    menu = pystray.Menu(
+        pystray.MenuItem("Show Status", on_show),
+        pystray.MenuItem("Exit", on_exit)
+    )
+    icon = pystray.Icon("stt-assistant", create_image(), "STT Assistant (F2 to record)", menu)
+    
+    print("[READY] Hold F2 to record your voice.")
+    icon.run()
+
+
+def main():
+    parser = argparse.ArgumentParser(description="STT Assistant - Voice to Text")
+    parser.add_argument("--tray", action="store_true", help="Run in system tray mode")
+    parser.add_argument("--model", default="base", help="Whisper model size (tiny/base/small/medium/large-v3)")
+    parser.add_argument("--device", default="cuda", help="Device (cuda/cpu)")
+    parser.add_argument("--compute", default="float16", help="Compute type (float16/int8)")
+    parser.add_argument("--lang", default="en", help="Language code (en/zh/auto)")
+    args = parser.parse_args()
+    
+    if args.tray:
+        run_tray()
+    else:
+        run_console()
+
+
+if __name__ == "__main__":
+    main()

stttype/recorder.py

@@ -0,0 +1,68 @@
+"""
+Audio recorder module - records audio while F2 is held.
+Uses sounddevice for cross-platform audio capture.
+"""
+import sounddevice as sd
+import numpy as np
+import wave
+import tempfile
+import os
+
+
+class AudioRecorder:
+    def __init__(self, sample_rate=16000, channels=1):
+        self.sample_rate = sample_rate
+        self.channels = channels
+        self.frames = []
+        self.is_recording = False
+        self.stream = None
+        
+    def _callback(self, indata, frames, time_info, status):
+        if self.is_recording:
+            self.frames.append(indata.copy())
+    
+    def start(self):
+        """Start recording audio."""
+        if self.is_recording:
+            return
+        self.frames = []
+        self.is_recording = True
+        self.stream = sd.InputStream(
+            samplerate=self.sample_rate,
+            channels=self.channels,
+            dtype=np.int16,
+            callback=self._callback
+        )
+        self.stream.start()
+    
+    def stop(self):
+        """Stop recording and return path to saved WAV file."""
+        if not self.is_recording:
+            return None
+        
+        self.is_recording = False
+        if self.stream:
+            self.stream.stop()
+            self.stream.close()
+            self.stream = None
+        
+        if not self.frames:
+            return None
+        
+        # Concatenate all frames
+        audio_data = np.concatenate(self.frames, axis=0)
+        
+        # Save to temp WAV file
+        temp_file = tempfile.mktemp(suffix=".wav")
+        with wave.open(temp_file, 'wb') as wf:
+            wf.setnchannels(self.channels)
+            wf.setsampwidth(2)  # 16-bit
+            wf.setframerate(self.sample_rate)
+            wf.writeframes(audio_data.tobytes())
+        
+        return temp_file
+    
+    def cleanup(self, filepath):
+        """Remove temporary audio file."""
+        if filepath and os.path.exists(filepath):
+            os.remove(filepath)

stttype/recorder_indicator.py

@@ -0,0 +1,102 @@
+"""
+Recording indicator - shows a red recording dot in the top-right corner.
+"""
+import threading
+
+
+class RecordingIndicator:
+    """A floating red dot indicator with F2 label."""
+    
+    def __init__(self, size=120, offset_x=20, offset_y=20):
+        self.size = size
+        self.offset_x = offset_x
+        self.offset_y = offset_y
+        self._root = None
+        self._visible = False
+        self._lock = threading.Lock()
+        
+    def _create_window(self):
+        """Create the tkinter window."""
+        try:
+            import tkinter as tk
+            
+            root = tk.Tk()
+            root.overrideredirect(True)
+            root.wm_attributes('-topmost', 1)
+            root.lift()
+            root.focus_force()
+            root.wm_attributes('-alpha', 0.5)  # 50% overall transparency
+            
+            screen_w = root.winfo_screenwidth()
+            x = screen_w - self.size - self.offset_x
+            y = self.offset_y
+            root.geometry(f'{self.size}x{self.size}+{x}+{y}')
+            
+            canvas = tk.Canvas(root, width=self.size, height=self.size, 
+                              bg='black', highlightthickness=0)
+            canvas.pack()
+            
+            padding = 3
+            # Draw circle
+            canvas.create_oval(
+                padding, padding, self.size - padding, self.size - padding,
+                fill='red', outline='darkred', width=2
+            )
+            
+            # Smaller F2 text centered
+            font_size = max(10, self.size // 6)
+            canvas.create_text(
+                self.size // 2, self.size // 2,
+                text='F2',
+                fill='white',
+                font=('Segoe UI', font_size, 'bold')
+            )
+            
+            # Keep on top
+            def keep_on_top():
+                if self._visible and self._root:
+                    try:
+                        self._root.lift()
+                        self._root.wm_attributes('-topmost', 1)
+                        self._root.after(100, keep_on_top)
+                    except:
+                        pass
+            
+            root.after(100, keep_on_top)
+            return root
+            
+        except Exception as e:
+            print(f"[WARN] Could not create indicator: {e}")
+            return None
+    
+    def show(self):
+        """Show the recording indicator."""
+        with self._lock:
+            if self._visible:
+                return
+            self._visible = True
+        
+        def _show():
+            try:
+                self._root = self._create_window()
+                if self._root:
+                    self._root.mainloop()
+            except Exception:
+                pass
+            finally:
+                self._root = None
+        
+        thread = threading.Thread(target=_show, daemon=True)
+        thread.start()
+    
+    def hide(self):
+        """Hide the recording indicator."""
+        with self._lock:
+            self._visible = False
+        
+        if self._root:
+            try:
+                self._root.after(0, self._root.destroy)
+            except Exception:
+                pass
+            self._root = None

stttype/transcriber.py

@@ -0,0 +1,107 @@
+"""
+STT Transcriber using faster-whisper with GPU acceleration.
+"""
+import os
+import sys
+import warnings
+
+# Suppress FP16 warning on consumer GPUs
+warnings.filterwarnings("ignore", message=".*FP16 is not supported.*")
+
+
+def _ensure_cuda_libs():
+    """Add NVIDIA CUDA libraries to PATH for ctranslate2/faster-whisper."""
+    try:
+        import site
+        for site_path in site.getsitepackages():
+            cublas_bin = os.path.join(site_path, "nvidia", "cublas", "bin")
+            if os.path.exists(cublas_bin) and cublas_bin not in os.environ.get("PATH", ""):
+                os.environ["PATH"] = cublas_bin + os.pathsep + os.environ.get("PATH", "")
+                break
+    except Exception:
+        pass
+
+
+_ensure_cuda_libs()
+
+
+class WhisperTranscriber:
+    def __init__(self, model_size="base", device="cuda", compute_type="float16"):
+        """
+        Initialize Whisper transcriber.
+        
+        Args:
+            model_size: "tiny", "base", "small", "medium", "large-v3"
+            device: "cuda" or "cpu"
+            compute_type: "float16" or "int8" (int8 for lower VRAM)
+        """
+        self.model_size = model_size
+        self.device = device
+        self.compute_type = compute_type
+        self.model = None
+        self._load_model()
+    
+    def _load_model(self):
+        """Load the faster-whisper model."""
+        try:
+            from faster_whisper import WhisperModel
+        except ImportError:
+            raise ImportError(
+                "faster-whisper not installed. Run: pip install faster-whisper"
+            )
+        
+        print(f"Loading Whisper model '{self.model_size}' on {self.device} ({self.compute_type})...")
+        self.model = WhisperModel(
+            self.model_size,
+            device=self.device,
+            compute_type=self.compute_type,
+            cpu_threads=4 if self.device == "cpu" else 0
+        )
+        print("Model loaded successfully!")
+    
+    def transcribe(self, audio_path, language="en"):
+        """
+        Transcribe audio file to text.
+        
+        Args:
+            audio_path: Path to audio file (WAV, MP3, etc.)
+            language: Language code (e.g., "en", "zh", "auto" for auto-detect)
+        
+        Returns:
+            Transcribed text string
+        """
+        if not self.model:
+            raise RuntimeError("Model not loaded")
+        
+        if not os.path.exists(audio_path):
+            return ""
+        
+        segments, info = self.model.transcribe(
+            audio_path,
+            language=None if language == "auto" else language,
+            task="transcribe",
+            vad_filter=True,
+            vad_parameters=dict(min_silence_duration_ms=500)
+        )
+        
+        text_parts = []
+        for segment in segments:
+            text_parts.append(segment.text.strip())
+        
+        return " ".join(text_parts).strip()
+    
+    def transcribe_with_fallback(self, audio_path, language="en"):
+        """
+        Transcribe with fallback to CPU if GPU fails.
+        """
+        try:
+            return self.transcribe(audio_path, language)
+        except Exception as e:
+            print(f"GPU transcription failed: {e}")
+            if self.device == "cuda":
+                print("Falling back to CPU...")
+                self.device = "cpu"
+                self.compute_type = "int8"
+                self._load_model()
+                return self.transcribe(audio_path, language)
+            raise

stttype/typer.py

@@ -0,0 +1,54 @@
+"""
+Keyboard typer module - types transcribed text using virtual keyboard input.
+Uses pyautogui for cross-platform typing.
+"""
+import pyautogui
+import time
+
+# Configure pyautogui for safety and speed
+pyautogui.FAILSAFE = True  # Move mouse to corner to abort
+pyautogui.PAUSE = 0.01  # Small delay between keypresses
+
+
+class KeyboardTyper:
+    def __init__(self, typing_delay=0.01):
+        self.typing_delay = typing_delay
+    
+    def type_text(self, text):
+        """
+        Type text using virtual keyboard.
+        
+        Args:
+            text: String to type
+        """
+        if not text:
+            return
+        
+        # Small delay to let user release F2 key completely
+        time.sleep(0.2)
+        
+        # Type the text
+        pyautogui.typewrite(text, interval=self.typing_delay)
+    
+    def type_text_instant(self, text):
+        """Type text with clipboard paste (faster for long text)."""
+        if not text:
+            return
+        
+        import pyperclip
+        
+        # Save original clipboard
+        original = pyperclip.paste()
+        
+        try:
+            # Copy text to clipboard and paste
+            pyperclip.copy(text)
+            time.sleep(0.1)
+            pyautogui.keyDown('ctrl')
+            pyautogui.keyDown('v')
+            pyautogui.keyUp('v')
+            pyautogui.keyUp('ctrl')
+            time.sleep(0.1)
+        finally:
+            # Restore original clipboard
+            pyperclip.copy(original)

stttype-1.0.0.dist-info/METADATA

@@ -0,0 +1,220 @@
+Metadata-Version: 2.4
+Name: stttype
+Version: 1.0.0
+Summary: Python based STT module running on GPU
+Author: LucasApps
+License: MIT
+Project-URL: Homepage, https://github.com/LucasApps/stttype
+Project-URL: Issues, https://github.com/LucasApps/stttype/issues
+Keywords: stt,speech-to-text,whisper,voice,typing,keyboard
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: MacOS
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Multimedia :: Sound/Audio :: Speech
+Classifier: Topic :: Utilities
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: faster-whisper>=1.0.0
+Requires-Dist: sounddevice>=0.4.6
+Requires-Dist: soundfile>=0.12.1
+Requires-Dist: numpy>=1.24.0
+Requires-Dist: pynput>=1.7.0
+Requires-Dist: pyautogui>=0.9.54
+Requires-Dist: pyperclip>=1.8.2
+Requires-Dist: pystray>=0.19.4
+Requires-Dist: pillow>=10.0.0
+Provides-Extra: gpu
+Requires-Dist: torch>=2.0.0; extra == "gpu"
+Requires-Dist: torchaudio>=2.0.0; extra == "gpu"
+
+# STT Type v1.0.0
+
+**Python based STT module running on GPU.**
+
+Hold **F2** to record your voice, release to transcribe and type the text automatically at your cursor position.
+
+## Features
+
+- **Cross-platform** - Works on Windows, Linux, and macOS
+- **Hold F2 to record** - Audio captures while key is held
+- **Visual indicator** - Semi-transparent red dot with "F2" label appears in top-right corner while recording
+- **Bell sounds** - Audio feedback when recording starts/stops
+- **GPU-accelerated STT** - Uses faster-whisper on your NVIDIA GPU
+- **Auto-typing** - Transcribed text is typed at cursor position
+- **System tray mode** - Runs silently in background
+- **Auto-startup** - Starts automatically on login
+
+## Requirements
+
+- Python 3.9+
+- NVIDIA GPU with CUDA support (for GPU mode)
+- Microphone
+
+## Installation
+
+### Prerequisites
+
+Install PyTorch with CUDA support:
+
+```bash
+# Windows/Linux
+pip install torch torchaudio --index-url https://download.pytorch.org/whl/cu118
+
+# macOS (CPU only, no CUDA)
+pip install torch torchaudio
+```
+
+### Windows
+
+```powershell
+cd "E:\Lucas\STT Type"
+.\install.ps1
+```
+
+Then restart PowerShell.
+
+### Linux
+
+```bash
+cd /path/to/stttype
+chmod +x install.sh
+./install.sh
+```
+
+If `sounddevice` fails, install PortAudio:
+```bash
+# Debian/Ubuntu
+sudo apt-get install portaudio19-dev
+
+# Fedora
+sudo dnf install portaudio-devel
+
+# Arch
+sudo pacman -S portaudio
+```
+
+### macOS
+
+```bash
+cd /path/to/stttype
+chmod +x install.sh
+./install.sh
+```
+
+If `sounddevice` fails, install PortAudio:
+```bash
+brew install portaudio
+```
+
+**Note:** On macOS, you need to grant Accessibility permissions for `pynput` to capture global hotkeys. Go to **System Settings > Privacy & Security > Accessibility** and add your terminal application.
+
+## Commands
+
+Once installed, `stttype` works from any terminal.
+
+| Command | Description |
+|---------|-------------|
+| `stttype --start` | Start STT Type in background |
+| `stttype --shutdown` | Stop all STT Type processes |
+| `stttype --status` | Check if STT Type is running |
+| `stttype --restart` | Restart STT Type |
+| `stttype --addtostartup` | Add to startup |
+| `stttype --rmtostartup` | Remove from startup |
+| `stttype --model <size>` | Set Whisper model (tiny/base/small/medium/large-v3) |
+| `stttype --lang <code>` | Set language (en/zh/auto/etc) |
+| `stttype --help` | Show help |
+
+### Examples
+
+```bash
+# Start with default settings
+stttype --start
+
+# Start with a larger model for better accuracy
+stttype --start --model small
+
+# Start with Chinese language
+stttype --start --lang zh
+
+# Start with small model and auto-detect language
+stttype --start --model small --lang auto
+```
+
+## How It Works
+
+1. **Hold F2** - A semi-transparent red dot with "F2" appears in the top-right corner, microphone starts recording
+2. **Release F2** - Red dot disappears, recording stops
+3. **GPU transcribes** - Whisper processes audio on your NVIDIA GPU
+4. **Text is typed** - Result appears at your cursor position
+
+## Models
+
+| Model | Size | VRAM | Speed | Accuracy |
+|-------|------|------|-------|----------|
+| `tiny` | 39 MB | ~1 GB | Fastest | Basic |
+| `base` | 74 MB | ~1 GB | Fast | Good |
+| `small` | 244 MB | ~2 GB | Medium | Better |
+| `medium` | 769 MB | ~5 GB | Slower | Best |
+| `large-v3` | 1550 MB | ~10 GB | Slowest | Excellent |
+
+Default is `base` - a good balance of speed and accuracy.
+
+## Uninstall
+
+### Windows
+```powershell
+cd "E:\Lucas\STT Type"
+.\uninstall.ps1
+```
+
+### Linux/macOS
+```bash
+cd /path/to/stttype
+chmod +x uninstall.sh
+./uninstall.sh
+```
+
+## Troubleshooting
+
+| Issue | Solution |
+|-------|----------|
+| `stttype` not found | Restart terminal after installation |
+| "CUDA not available" | Install NVIDIA drivers and CUDA toolkit |
+| No sound on start/stop | Check system volume |
+| Text not typing | Make sure the target window is focused |
+| Model download fails | Check internet connection |
+| Hotkeys don't work (macOS) | Grant Accessibility permissions to your terminal |
+| Hotkeys don't work (Linux) | Make sure you're running under X11 (not Wayland) |
+
+## Publish to PyPI
+
+```bash
+# Install build tools
+pip install build twine
+
+# Build
+cd /path/to/stttype
+python -m build
+
+# Upload
+python -m twine upload dist/*
+```
+
+When prompted:
+- **Username**: `__token__`
+- **Password**: Your PyPI API token
+
+---
+
+**Author**: LucasApps  
+**Version**: 1.0.0  
+**License**: MIT

stttype-1.0.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+stttype/__init__.py,sha256=Y-MmjPtmAfii3yr5r3dmES0MMp8au2xGJpLaKeXIZNQ,179
+stttype/bell.py,sha256=z5akiAhETMhwkuoJ1u5ZrkODUeyDX-ZdsOUbABYafoM,1223
+stttype/cli.py,sha256=4W7kRJcrcphBkRQ2vhz_MPKZehwthOzdYWe0jV_Hp9g,7145
+stttype/main.py,sha256=CyCZv4SYLbZpgBcm-0X2Modjk9l4qpbUIBt2Eoe2qXI,6570
+stttype/recorder.py,sha256=6LoGybW3XBplvXfRq_kIa-tPAEvNFUFDemL__Qk-ec4,1948
+stttype/recorder_indicator.py,sha256=cdbeZ5O7Fcur0LMzdAVehSIQ7YfDtnYQWVvZnvkpzZ0,3174
+stttype/transcriber.py,sha256=2XzfEm8l0v1nebFFBImAA0EkseXYd_rAe97GvL8NozY,3449
+stttype/typer.py,sha256=Z8xpiTlLynuepvp86yKLPk910EFHBjfz66TRTW-Uttc,1471
+stttype-1.0.0.dist-info/METADATA,sha256=V014Xdj3J7vd5URsJ-ZeSb3jt3xUy6RHvdvut7_gB6Y,6040
+stttype-1.0.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+stttype-1.0.0.dist-info/entry_points.txt,sha256=N8yigAGrQw5ew4a4N7gFoje1Qr3E4n-ksDzHWVAuQ2I,45
+stttype-1.0.0.dist-info/top_level.txt,sha256=MO-2G94oAqUfkf7WFy6ouxNQ7db4UShMcHqDTWRWv18,8
+stttype-1.0.0.dist-info/RECORD,,

stttype-1.0.0.dist-info/WHEEL

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

stttype-1.0.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+stttype = stttype.cli:main

stttype-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+stttype