talktype 0.1.0__py3-none-any.whl

talk/__init__.py

@@ -0,0 +1,4 @@
+"""talk — local-first dictation for macOS."""
+
+__all__ = ["__version__"]
+__version__ = "0.1.0"

talk/__main__.py

@@ -0,0 +1,85 @@
+from __future__ import annotations
+
+import argparse
+import sys
+
+from talk import __version__
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="talk",
+        description="Local-first laptop dictation with a global hotkey.",
+    )
+    parser.add_argument(
+        "--version", action="version", version=f"%(prog)s {__version__}",
+    )
+    sub = parser.add_subparsers(dest="command", required=True)
+
+    sub.add_parser("run", help="Start the live dictation app")
+    sub.add_parser("doctor", help="Run setup preflight checks")
+
+    file_parser = sub.add_parser("transcribe-file", help="Transcribe a WAV file")
+    file_parser.add_argument("path", help="Path to a 16-bit PCM WAV file")
+    file_parser.add_argument(
+        "--paste",
+        action="store_true",
+        help="Paste transcription at cursor after transcription",
+    )
+
+    return parser
+
+
+def _cmd_run() -> None:
+    from talk.app import DictationApp
+    from talk.config import load_settings
+
+    settings = load_settings()
+    app = DictationApp(settings)
+    app.run()
+
+
+def _cmd_doctor() -> None:
+    from talk.config import load_settings
+    from talk.doctor import run_doctor
+
+    settings = load_settings()
+    code = run_doctor(settings)
+    if code:
+        sys.exit(code)
+
+
+def _cmd_transcribe_file(path: str, paste: bool) -> None:
+    from talk.audio import load_wav_mono
+    from talk.backends.factory import build_backend
+    from talk.config import load_settings
+    from talk.paste import paste_text
+
+    settings = load_settings()
+    backend = build_backend(settings)
+    chunk = load_wav_mono(path)
+    text = backend.transcribe(chunk.samples, chunk.sample_rate).strip()
+
+    if not text:
+        print("[warn] No transcription text produced.")
+        sys.exit(1)
+
+    print(text)
+    if paste:
+        paste_text(text)
+
+
+def main() -> None:
+    parser = build_parser()
+    args = parser.parse_args()
+
+    if args.command == "run":
+        _cmd_run()
+    elif args.command == "doctor":
+        _cmd_doctor()
+    elif args.command == "transcribe-file":
+        _cmd_transcribe_file(args.path, args.paste)
+
+
+if __name__ == "__main__":
+    main()

talk/app.py

@@ -0,0 +1,137 @@
+from __future__ import annotations
+
+import signal
+import subprocess
+import threading
+import time
+from pathlib import Path
+
+from pynput import keyboard
+
+from talk.audio import AudioChunk, MicRecorder, RecorderError
+from talk.backends.factory import build_backend
+from talk.config import Settings
+from talk.paste import paste_text
+
+
+def _play_sound(filename: str) -> None:
+    sound_path = Path("/System/Library/Sounds") / filename
+    if not sound_path.exists():
+        return
+    subprocess.Popen(
+        ["afplay", str(sound_path)],
+        stdout=subprocess.DEVNULL,
+        stderr=subprocess.DEVNULL,
+    )
+
+
+class DictationApp:
+    def __init__(self, settings: Settings) -> None:
+        self.settings = settings
+        self.backend = build_backend(settings)
+        self.recorder = MicRecorder(
+            sample_rate=settings.sample_rate,
+            channels=settings.channels,
+        )
+
+        self._lock = threading.Lock()
+        self._stop_event = threading.Event()
+        self._is_recording = False
+        self._is_transcribing = False
+
+    def _toggle_recording(self) -> None:
+        chunk: AudioChunk | None = None
+
+        with self._lock:
+            if self._is_transcribing:
+                print("[busy] Still transcribing previous clip.")
+                return
+
+            if not self._is_recording:
+                try:
+                    self.recorder.start()
+                except Exception as exc:  # noqa: BLE001
+                    print(f"[error] Could not start recording: {exc}")
+                    return
+
+                self._is_recording = True
+                _play_sound("Glass.aiff")
+                print("[rec] Recording... press hotkey again to stop.")
+                return
+
+            try:
+                chunk = self.recorder.stop()
+            except RecorderError as exc:
+                print(f"[error] Could not stop recording cleanly: {exc}")
+                self._is_recording = False
+                return
+
+            self._is_recording = False
+            self._is_transcribing = True
+
+        _play_sound("Pop.aiff")
+        worker = threading.Thread(
+            target=self._transcribe_and_emit,
+            args=(chunk,),
+            daemon=True,
+        )
+        worker.start()
+
+    def _transcribe_and_emit(self, chunk: AudioChunk) -> None:
+        try:
+            duration_seconds = 0.0
+            if chunk.sample_rate > 0:
+                duration_seconds = len(chunk.samples) / float(chunk.sample_rate)
+
+            if duration_seconds < self.settings.min_seconds:
+                print("[skip] Clip too short. Try speaking a bit longer.")
+                return
+
+            text = self.backend.transcribe(chunk.samples, chunk.sample_rate).strip()
+            if not text:
+                print("[skip] No speech detected.")
+                return
+
+            print(f"[text] {text}")
+            if self.settings.autopaste:
+                paste_text(text)
+                print("[paste] Inserted at current cursor.")
+        except Exception as exc:  # noqa: BLE001
+            print(f"[error] Transcription failed: {exc}")
+        finally:
+            with self._lock:
+                self._is_transcribing = False
+
+    def _request_shutdown(self) -> None:
+        with self._lock:
+            if self._is_recording:
+                try:
+                    self.recorder.stop()
+                except Exception:  # noqa: BLE001
+                    pass
+                self._is_recording = False
+        print("[exit] Shutting down dictation app.")
+        self._stop_event.set()
+
+    def run(self) -> None:
+        print(f"[ready] Backend: {self.backend.name}")
+        print(f"[ready] Toggle dictation: {self.settings.hotkey}")
+        print(f"[ready] Quit app: {self.settings.quit_hotkey}")
+
+        keymap = {
+            self.settings.hotkey: self._toggle_recording,
+            self.settings.quit_hotkey: self._request_shutdown,
+        }
+
+        signal.signal(signal.SIGTERM, lambda *_: self._request_shutdown())
+
+        listener = keyboard.GlobalHotKeys(keymap)
+        listener.start()
+        try:
+            while not self._stop_event.is_set():
+                time.sleep(0.15)
+        except KeyboardInterrupt:
+            self._request_shutdown()
+        finally:
+            listener.stop()
+

talk/audio.py

@@ -0,0 +1,107 @@
+from __future__ import annotations
+
+import io
+import threading
+import wave
+from dataclasses import dataclass
+
+import numpy as np
+import sounddevice as sd
+
+
+class RecorderError(RuntimeError):
+    """Raised when recording state is invalid."""
+
+
+@dataclass(slots=True)
+class AudioChunk:
+    samples: np.ndarray
+    sample_rate: int
+
+
+class MicRecorder:
+    def __init__(self, sample_rate: int, channels: int = 1) -> None:
+        self.sample_rate = sample_rate
+        self.channels = channels
+        self._stream: sd.InputStream | None = None
+        self._frames: list[np.ndarray] = []
+        self._lock = threading.Lock()
+
+    def _on_audio(self, indata: np.ndarray, frames: int, time_info: dict, status: sd.CallbackFlags) -> None:
+        del frames, time_info
+        if status:
+            print(f"[warn] audio callback status: {status}")
+        with self._lock:
+            self._frames.append(indata.copy())
+
+    def start(self) -> None:
+        if self._stream is not None:
+            raise RecorderError("Recorder is already running")
+
+        with self._lock:
+            self._frames = []
+
+        self._stream = sd.InputStream(
+            samplerate=self.sample_rate,
+            channels=self.channels,
+            dtype="float32",
+            callback=self._on_audio,
+        )
+        self._stream.start()
+
+    def stop(self) -> AudioChunk:
+        if self._stream is None:
+            raise RecorderError("Recorder is not running")
+
+        self._stream.stop()
+        self._stream.close()
+        self._stream = None
+
+        with self._lock:
+            if not self._frames:
+                merged = np.zeros((0,), dtype=np.float32)
+            else:
+                merged = np.concatenate(self._frames, axis=0).astype(np.float32)
+
+        if merged.ndim == 2:
+            if merged.shape[1] == 1:
+                merged = merged[:, 0]
+            else:
+                merged = merged.mean(axis=1)
+
+        return AudioChunk(samples=merged, sample_rate=self.sample_rate)
+
+
+def to_wav_buffer(audio: np.ndarray, sample_rate: int) -> io.BytesIO:
+    clipped = np.clip(audio.astype(np.float32), -1.0, 1.0)
+    pcm16 = (clipped * 32767.0).astype(np.int16)
+
+    buffer = io.BytesIO()
+    with wave.open(buffer, "wb") as wav_file:
+        wav_file.setnchannels(1)
+        wav_file.setsampwidth(2)
+        wav_file.setframerate(sample_rate)
+        wav_file.writeframes(pcm16.tobytes())
+
+    buffer.seek(0)
+    buffer.name = "dictation.wav"
+    return buffer
+
+
+def load_wav_mono(path: str) -> AudioChunk:
+    with wave.open(path, "rb") as wav_file:
+        channels = wav_file.getnchannels()
+        sample_rate = wav_file.getframerate()
+        sample_width = wav_file.getsampwidth()
+        frame_count = wav_file.getnframes()
+        raw = wav_file.readframes(frame_count)
+
+    if sample_width != 2:
+        raise ValueError("Only 16-bit PCM WAV files are supported for file transcription.")
+
+    audio = np.frombuffer(raw, dtype=np.int16).astype(np.float32) / 32767.0
+
+    if channels > 1:
+        audio = audio.reshape(-1, channels).mean(axis=1)
+
+    return AudioChunk(samples=audio, sample_rate=sample_rate)

talk/backends/__init__.py

@@ -0,0 +1 @@
+"""Transcription backends."""

talk/backends/base.py

@@ -0,0 +1,12 @@
+from __future__ import annotations
+
+from typing import Protocol
+
+import numpy as np
+
+
+class DictationBackend(Protocol):
+    name: str
+
+    def transcribe(self, audio: np.ndarray, sample_rate: int) -> str:
+        """Convert mono float32 audio into text."""

talk/backends/factory.py

@@ -0,0 +1,24 @@
+from __future__ import annotations
+
+from talk.backends.base import DictationBackend
+from talk.config import Settings
+
+
+def build_backend(settings: Settings) -> DictationBackend:
+    if settings.backend == "parakeet":
+        from talk.backends.parakeet_backend import ParakeetBackend
+
+        return ParakeetBackend(model_id=settings.parakeet_model)
+
+    if settings.backend == "openai":
+        from talk.backends.openai_backend import OpenAIBackend
+
+        return OpenAIBackend(
+            api_key=settings.openai_api_key or "",
+            model=settings.openai_model,
+            language=settings.openai_language,
+        )
+
+    raise ValueError(
+        f"Unknown DICTATE_BACKEND='{settings.backend}'. Use 'parakeet' or 'openai'."
+    )

talk/backends/openai_backend.py

@@ -0,0 +1,31 @@
+from __future__ import annotations
+
+import numpy as np
+
+from talk.audio import to_wav_buffer
+
+
+class OpenAIBackend:
+    name = "openai"
+
+    def __init__(self, api_key: str, model: str, language: str | None = None) -> None:
+        if not api_key:
+            raise ValueError("OPENAI_API_KEY is required for the OpenAI backend")
+
+        from openai import OpenAI
+
+        self._client = OpenAI(api_key=api_key)
+        self.model = model
+        self.language = language
+
+    def transcribe(self, audio: np.ndarray, sample_rate: int) -> str:
+        payload = {
+            "model": self.model,
+            "file": to_wav_buffer(audio, sample_rate),
+        }
+        if self.language:
+            payload["language"] = self.language
+
+        transcript = self._client.audio.transcriptions.create(**payload)
+        text = getattr(transcript, "text", "")
+        return (text or "").strip()

talk/backends/parakeet_backend.py

@@ -0,0 +1,29 @@
+from __future__ import annotations
+
+import tempfile
+
+import numpy as np
+
+from talk.audio import to_wav_buffer
+
+
+class ParakeetBackend:
+    name = "parakeet"
+
+    def __init__(self, model_id: str) -> None:
+        self.model_id = model_id
+        print(f"[init] Loading Parakeet model ({model_id})...")
+        print("[init] First run downloads ~1.2 GB of weights. Subsequent runs are fast.")
+
+        from parakeet_mlx import from_pretrained
+
+        self._model = from_pretrained(model_id)
+        print("[init] Model ready.")
+
+    def transcribe(self, audio: np.ndarray, sample_rate: int) -> str:
+        wav_buffer = to_wav_buffer(audio, sample_rate)
+        with tempfile.NamedTemporaryFile(suffix=".wav") as tmp:
+            tmp.write(wav_buffer.getvalue())
+            tmp.flush()
+            result = self._model.transcribe(tmp.name)
+        return (getattr(result, "text", "") or "").strip()

talk/config.py

@@ -0,0 +1,94 @@
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass
+from pathlib import Path
+
+from dotenv import load_dotenv
+
+_XDG_CONFIG = Path(os.environ.get("XDG_CONFIG_HOME", Path.home() / ".config"))
+CONFIG_DIR = _XDG_CONFIG / "talk"
+
+
+_MODIFIER_MAP = {
+    "cmd": "<cmd>",
+    "command": "<cmd>",
+    "shift": "<shift>",
+    "ctrl": "<ctrl>",
+    "control": "<ctrl>",
+    "alt": "<alt>",
+    "option": "<alt>",
+}
+
+_KEY_MAP = {
+    "space": "<space>",
+    "enter": "<enter>",
+    "return": "<enter>",
+    "tab": "<tab>",
+    "esc": "<esc>",
+    "escape": "<esc>",
+}
+
+
+def _as_bool(value: str | None, default: bool) -> bool:
+    if value is None:
+        return default
+    return value.strip().lower() in {"1", "true", "yes", "y", "on"}
+
+
+def normalize_hotkey(raw_hotkey: str) -> str:
+    parts = [part.strip().lower() for part in raw_hotkey.split("+") if part.strip()]
+    normalized = []
+    for part in parts:
+        if part in _MODIFIER_MAP:
+            normalized.append(_MODIFIER_MAP[part])
+        elif part in _KEY_MAP:
+            normalized.append(_KEY_MAP[part])
+        elif part.startswith("<") and part.endswith(">"):
+            inner = part[1:-1].lower()
+            if inner in _KEY_MAP:
+                normalized.append(_KEY_MAP[inner])
+            else:
+                normalized.append(f"<{inner}>")
+        else:
+            normalized.append(part)
+    return "+".join(normalized)
+
+
+@dataclass(slots=True)
+class Settings:
+    backend: str
+    hotkey: str
+    quit_hotkey: str
+    autopaste: bool
+    sample_rate: int
+    channels: int
+    min_seconds: float
+    parakeet_model: str
+    openai_api_key: str | None
+    openai_model: str
+    openai_language: str | None
+
+
+
+def load_settings() -> Settings:
+    load_dotenv()
+    load_dotenv(CONFIG_DIR / ".env")
+
+    backend = os.getenv("DICTATE_BACKEND", "parakeet").strip().lower()
+    hotkey = normalize_hotkey(os.getenv("DICTATE_HOTKEY", "<cmd>+<shift>+<space>"))
+    quit_hotkey = normalize_hotkey(os.getenv("DICTATE_QUIT_HOTKEY", "<cmd>+<shift>+q"))
+
+    return Settings(
+        backend=backend,
+        hotkey=hotkey,
+        quit_hotkey=quit_hotkey,
+        autopaste=_as_bool(os.getenv("DICTATE_AUTOPASTE"), True),
+        sample_rate=int(os.getenv("DICTATE_SAMPLE_RATE", "16000")),
+        channels=int(os.getenv("DICTATE_CHANNELS", "1")),
+        min_seconds=float(os.getenv("DICTATE_MIN_SECONDS", "0.35")),
+        parakeet_model=os.getenv("PARAKEET_MODEL", "mlx-community/parakeet-tdt-0.6b-v3").strip(),
+        openai_api_key=os.getenv("OPENAI_API_KEY"),
+        openai_model=os.getenv("OPENAI_TRANSCRIBE_MODEL", "gpt-4o-transcribe").strip(),
+        openai_language=(os.getenv("OPENAI_TRANSCRIBE_LANGUAGE") or "").strip() or None,
+    )

talk/doctor.py

@@ -0,0 +1,226 @@
+from __future__ import annotations
+
+import platform
+import sys
+from dataclasses import dataclass
+
+import sounddevice as sd
+
+from talk.config import Settings
+
+
+@dataclass(slots=True)
+class CheckResult:
+    name: str
+    ok: bool
+    message: str
+
+
+def _check_platform() -> CheckResult:
+    system = platform.system()
+    machine = platform.machine().lower()
+    if system != "Darwin":
+        return CheckResult(
+            name="platform",
+            ok=False,
+            message=f"Detected {system}. This build is currently optimized for macOS (Darwin).",
+        )
+
+    if machine != "arm64":
+        return CheckResult(
+            name="platform",
+            ok=True,
+            message=f"Running on macOS {machine}. Works, but Parakeet-MLX is best on Apple Silicon.",
+        )
+
+    return CheckResult(
+        name="platform",
+        ok=True,
+        message="Running on macOS arm64 (Apple Silicon), ideal for Parakeet-MLX.",
+    )
+
+
+def _check_microphone_device() -> CheckResult:
+    try:
+        devices = sd.query_devices()
+    except Exception as exc:  # noqa: BLE001
+        return CheckResult(
+            name="microphone_device",
+            ok=False,
+            message=f"Could not enumerate audio devices: {exc}",
+        )
+
+    has_input = any((device.get("max_input_channels") or 0) > 0 for device in devices)
+    if not has_input:
+        return CheckResult(
+            name="microphone_device",
+            ok=False,
+            message="No input-capable microphone device found.",
+        )
+
+    default_device = sd.default.device
+    return CheckResult(
+        name="microphone_device",
+        ok=True,
+        message=f"Input device detected. Default device tuple: {default_device}.",
+    )
+
+
+def _check_microphone_access(settings: Settings) -> CheckResult:
+    stream = None
+    try:
+        stream = sd.InputStream(
+            samplerate=settings.sample_rate,
+            channels=settings.channels,
+            dtype="float32",
+        )
+        stream.start()
+        stream.stop()
+        return CheckResult(
+            name="microphone_access",
+            ok=True,
+            message="Microphone stream opened successfully.",
+        )
+    except Exception as exc:  # noqa: BLE001
+        return CheckResult(
+            name="microphone_access",
+            ok=False,
+            message=f"Microphone stream failed. Grant microphone permission in macOS settings. Error: {exc}",
+        )
+    finally:
+        if stream is not None:
+            try:
+                stream.close()
+            except Exception:  # noqa: BLE001
+                pass
+
+
+def _check_accessibility_permission() -> CheckResult:
+    if platform.system() != "Darwin":
+        return CheckResult(
+            name="accessibility_permission",
+            ok=False,
+            message="Accessibility permission check is only available on macOS.",
+        )
+
+    try:
+        from ApplicationServices import AXIsProcessTrusted
+    except Exception as exc:  # noqa: BLE001
+        return CheckResult(
+            name="accessibility_permission",
+            ok=False,
+            message=f"Could not load macOS accessibility APIs: {exc}",
+        )
+
+    trusted = bool(AXIsProcessTrusted())
+    if trusted:
+        return CheckResult(
+            name="accessibility_permission",
+            ok=True,
+            message="Accessibility permission is granted.",
+        )
+
+    return CheckResult(
+        name="accessibility_permission",
+        ok=False,
+        message=(
+            "Accessibility permission is not granted. Add your terminal/Codex app in "
+            "System Settings > Privacy & Security > Accessibility."
+        ),
+    )
+
+
+def _check_input_monitoring_permission() -> CheckResult:
+    if platform.system() != "Darwin":
+        return CheckResult(
+            name="input_monitoring_permission",
+            ok=False,
+            message="Input Monitoring check is only available on macOS.",
+        )
+
+    try:
+        from Quartz import CGPreflightListenEventAccess
+    except Exception as exc:  # noqa: BLE001
+        return CheckResult(
+            name="input_monitoring_permission",
+            ok=False,
+            message=f"Could not load Input Monitoring API: {exc}",
+        )
+
+    trusted = bool(CGPreflightListenEventAccess())
+    if trusted:
+        return CheckResult(
+            name="input_monitoring_permission",
+            ok=True,
+            message="Input Monitoring permission is granted.",
+        )
+
+    return CheckResult(
+        name="input_monitoring_permission",
+        ok=False,
+        message=(
+            "Input Monitoring permission is not granted. Add your terminal/Codex app in "
+            "System Settings > Privacy & Security > Input Monitoring."
+        ),
+    )
+
+
+def _check_backend_config(settings: Settings) -> CheckResult:
+    if settings.backend == "parakeet":
+        return CheckResult(
+            name="backend_config",
+            ok=True,
+            message=f"Backend is parakeet (model: {settings.parakeet_model}).",
+        )
+
+    if settings.backend == "openai":
+        if settings.openai_api_key:
+            return CheckResult(
+                name="backend_config",
+                ok=True,
+                message="Backend is openai and OPENAI_API_KEY is set.",
+            )
+        return CheckResult(
+            name="backend_config",
+            ok=False,
+            message="Backend is openai but OPENAI_API_KEY is missing.",
+        )
+
+    return CheckResult(
+        name="backend_config",
+        ok=False,
+        message=f"Unknown backend value: {settings.backend}",
+    )
+
+
+def run_doctor(settings: Settings) -> int:
+    print("[doctor] talk preflight checks")
+    print(f"[doctor] Python: {sys.version.split()[0]}")
+    print(f"[doctor] Backend: {settings.backend}")
+    print(f"[doctor] Dictate hotkey: {settings.hotkey}")
+    print(f"[doctor] Quit hotkey: {settings.quit_hotkey}")
+    print()
+
+    checks = [
+        _check_platform(),
+        _check_backend_config(settings),
+        _check_microphone_device(),
+        _check_microphone_access(settings),
+        _check_accessibility_permission(),
+        _check_input_monitoring_permission(),
+    ]
+
+    failed = 0
+    for check in checks:
+        status = "ok" if check.ok else "fail"
+        print(f"[{status}] {check.name}: {check.message}")
+        if not check.ok:
+            failed += 1
+
+    print()
+    if failed:
+        print(f"[doctor] Completed with {failed} failing check(s).")
+        return 1
+
+    print("[doctor] All checks passed. You are ready to run live dictation.")
+    return 0

talk/paste.py

@@ -0,0 +1,28 @@
+from __future__ import annotations
+
+import subprocess
+import time
+
+
+def paste_text(text: str, restore_clipboard: bool = True) -> None:
+    previous_clipboard = None
+    if restore_clipboard:
+        prior = subprocess.run(["pbpaste"], capture_output=True, text=True, check=False)
+        if prior.returncode == 0:
+            previous_clipboard = prior.stdout
+
+    subprocess.run(["pbcopy"], input=text, text=True, check=True)
+
+    # Requires macOS Accessibility permission for Terminal/Codex app.
+    subprocess.run(
+        [
+            "osascript",
+            "-e",
+            'tell application "System Events" to keystroke "v" using command down',
+        ],
+        check=False,
+    )
+
+    if restore_clipboard and previous_clipboard is not None:
+        time.sleep(0.15)
+        subprocess.run(["pbcopy"], input=previous_clipboard, text=True, check=False)

talktype-0.1.0.dist-info/METADATA

@@ -0,0 +1,125 @@
+Metadata-Version: 2.4
+Name: talktype
+Version: 0.1.0
+Summary: Local-first dictation for macOS — press a hotkey, talk, text appears at your cursor
+Project-URL: Homepage, https://github.com/strangeloopcanon/talk
+Project-URL: Repository, https://github.com/strangeloopcanon/talk
+Project-URL: Issues, https://github.com/strangeloopcanon/talk/issues
+Author: Rohit Krishnan
+License: MIT
+Keywords: dictation,macos,mlx,parakeet,speech-to-text,transcription
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: MacOS X
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: MacOS
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Multimedia :: Sound/Audio :: Speech
+Requires-Python: >=3.11
+Requires-Dist: numpy>=1.26
+Requires-Dist: openai>=1.108.0
+Requires-Dist: parakeet-mlx>=0.4.2
+Requires-Dist: pynput>=1.8.1
+Requires-Dist: python-dotenv>=1.1.1
+Requires-Dist: sounddevice>=0.5.2
+Description-Content-Type: text/markdown
+
+# talk
+
+> **macOS only** (Apple Silicon recommended). Requires Python 3.11+.
+
+Local-first dictation for macOS.
+Press a hotkey, talk, text appears at your cursor.
+
+- Parakeet local transcription by default (zero API cost on Apple Silicon).
+- OpenAI `gpt-4o-transcribe` fallback with one env switch.
+- Automatic paste at cursor (clipboard-safe restore).
+
+## Install
+
+```bash
+pip install talk
+```
+
+That's it. On first run, Parakeet model weights (~1.2 GB) download automatically.
+
+### Alternative: from source
+
+```bash
+git clone https://github.com/strangeloopcanon/talk.git
+cd talk
+./scripts/install_macos.sh
+./scripts/doctor_macos.sh
+./scripts/run_macos.sh
+```
+
+## Usage
+
+```bash
+talk run
+```
+
+- Press `Cmd+Shift+Space` to start recording.
+- Press `Cmd+Shift+Space` again to stop, transcribe, and paste.
+- Press `Cmd+Shift+Q` to quit.
+
+### Preflight checks
+
+```bash
+talk doctor
+```
+
+### File transcription
+
+```bash
+talk transcribe-file /path/to/sample.wav
+```
+
+## macOS permissions
+
+You must grant your terminal app:
+
+- **Microphone** -- for audio recording
+- **Accessibility** -- for paste keystroke automation
+- **Input Monitoring** -- for global hotkeys
+
+If paste fails but transcription works, Accessibility permission is usually the issue.
+
+## Configuration
+
+Works out of the box with zero configuration. To customize, create `~/.config/talk/.env`:
+
+```bash
+mkdir -p ~/.config/talk
+```
+
+Key options (all have sensible defaults):
+
+| Variable | Default | Notes |
+|----------|---------|-------|
+| `DICTATE_BACKEND` | `parakeet` | `parakeet` (local) or `openai` (cloud) |
+| `DICTATE_HOTKEY` | `<cmd>+<shift>+<space>` | Toggle recording |
+| `DICTATE_QUIT_HOTKEY` | `<cmd>+<shift>+q` | Quit the app |
+| `DICTATE_AUTOPASTE` | `true` | Paste transcription at cursor |
+| `PARAKEET_MODEL` | `mlx-community/parakeet-tdt-0.6b-v3` | Local model |
+| `OPENAI_API_KEY` | *(empty)* | Required if backend=openai |
+
+See `.env.example` for the full list.
+
+## Switching backend
+
+```bash
+# In ~/.config/talk/.env or as env vars:
+DICTATE_BACKEND=openai
+OPENAI_API_KEY=sk-...
+```
+
+## Cleanup
+
+Parakeet model weights are cached in `~/.cache/huggingface/hub/`. To reclaim disk space:
+
+```bash
+rm -rf ~/.cache/huggingface/hub/models--mlx-community--parakeet-tdt-0.6b-v3
+```

talktype-0.1.0.dist-info/RECORD

@@ -0,0 +1,16 @@
+talk/__init__.py,sha256=rZ23pjPHZeZNPyo5gXZg3FnNEs5WhjsnWmbZUf0zmws,97
+talk/__main__.py,sha256=ef-UYzxQcuxJEzjeTPorWMnG-QvxtJldLZL5KIJoY-g,2180
+talk/app.py,sha256=72gAyY_lpmC3zb36JL8TyljGoD9db0cRb3n40A66ir8,4295
+talk/audio.py,sha256=VD9OkkcW0cxmMwIe3auVFEpRS3xIRmlgkA3TxfDtMUY,3129
+talk/config.py,sha256=6ig1Onk3qKHIL6ZLnnHdnw1FG8N5svWOdK7RVyJlc-U,2740
+talk/doctor.py,sha256=8ruGeMK6LlF06mGkZOZpGzM_tt0OUf3s50LtjPp3Zz8,6570
+talk/paste.py,sha256=9gV79zIKqr-0OpJAo_-uiQuo3Q8vY9AkWZUpfm5gJ20,865
+talk/backends/__init__.py,sha256=45iJg8DVzIPGRLOpOWeXbGPwqseA8w0neF-Gh-MW-Zc,30
+talk/backends/base.py,sha256=idxqyxwpHdTEt1k9KT_lU2mSjAK96fBpScxUUxgRttA,257
+talk/backends/factory.py,sha256=N2CdKT0D1IHJRFnfdeCQTjvUmV9jQJyMzsPr34A_FIA,745
+talk/backends/openai_backend.py,sha256=9sWtUo1--_T-qdsATdvvvHRgEdpoouX1cih3mDQw-yg,893
+talk/backends/parakeet_backend.py,sha256=w8PRZm2llakZlcgTe0txNM19IizXIS4G8LihRDKZxK0,900
+talktype-0.1.0.dist-info/METADATA,sha256=RuKBzt9dM-rifzVfLoJxYHQpdR3pke_483fJW3Fomm4,3375
+talktype-0.1.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+talktype-0.1.0.dist-info/entry_points.txt,sha256=GzJ7dfM32L_VtWnAUoqYF69KUfL8-3XQlr022DfJIXM,44
+talktype-0.1.0.dist-info/RECORD,,

talktype-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

talktype-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+talk = talk.__main__:main