s2t 0.1.0.post1.dev2__py3-none-any.whl

s2t/__init__.py

@@ -0,0 +1,13 @@
+from importlib.metadata import PackageNotFoundError, version
+
+__all__ = ["__version__"]
+
+try:
+    __version__ = version("s2t")
+except PackageNotFoundError:
+    try:
+        from setuptools_scm import get_version
+
+        __version__ = get_version(root="..", relative_to=__file__)
+    except Exception:
+        __version__ = "0.0.0"

s2t/cli.py

@@ -0,0 +1,420 @@
+#!/usr/bin/env python3
+"""
+Interactive microphone recording -> Whisper transcription -> outputs + clipboard
+
+Features
+- Records from the default microphone until you press Enter.
+- Default recording format is FLAC (lossless); WAV and MP3 are supported. MP3 requires ffmpeg; otherwise it falls back to FLAC with a warning.
+- Uses Whisper's Python API (no subprocess) to transcribe/translate and emits txt, srt, vtt, tsv, json.
+- Copies the .txt transcript to the system clipboard.
+- Creates a per-session subdirectory under a base output directory, named with an ISO timestamp (e.g., 2025-01-31T14-22-05+0200).
+
+Requirements
+- Python packages: sounddevice, soundfile, openai-whisper (pip install sounddevice soundfile openai-whisper)
+- Optional: ffmpeg (only needed for MP3 or if Whisper loads audio by path for MP3)
+
+Usage
+  s2t
+Optional
+  s2t -l de -m turbo -o transcripts -t -f flac
+
+Notes
+- Default output directory is `transcripts/` if `-o/--outdir` is omitted.
+- In prompt mode (`-p/--prompt`), speak your prompt first, then press SPACE. The app waits until the prompt is transcribed, prints a separator, and then you start speaking your main content. You may also press ENTER instead of SPACE to finish after the prompt; in that case the session ends after transcribing the prompt.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import logging
+import queue
+import re
+import shutil
+import sys
+import threading
+import time
+from pathlib import Path
+
+from . import __version__
+from .config import SessionOptions
+from .outputs import concat_audio, write_final_outputs
+from .recorder import Recorder
+from .types import TranscriptionResult
+from .utils import (
+    convert_wav_to_mp3,
+    copy_to_clipboard,
+    make_session_dir,
+    open_in_shell_editor,
+)
+from .whisper_engine import WhisperEngine
+
+
+def run_session(opts: SessionOptions) -> int:
+    session_dir = make_session_dir(opts.outdir)
+    profile_data: dict = {}
+    requested = opts.recording_format.lower()
+    effective = requested
+    if requested == "mp3" and shutil.which("ffmpeg") is None:
+        logging.warning("ffmpeg not found; falling back to FLAC recording instead of MP3.")
+        effective = "flac"
+    ext = ".flac" if effective == "flac" else ".wav"
+
+    engine = WhisperEngine(
+        model_name=opts.model,
+        translate=opts.translate,
+        language=opts.lang,
+        native_segmentation=opts.native_segmentation,
+        session_dir=session_dir,
+        samplerate=opts.rate,
+        channels=opts.channels,
+        verbose=opts.verbose,
+        profile=profile_data if opts.profile else {},
+    )
+    ex, fut = engine.preload()
+
+    tx_q: queue.Queue[tuple[int, Path, int, float]] = queue.Queue()
+    cumulative_text = ""
+    next_to_emit = 1
+    pending: dict[int, str] = {}
+    results: list[TranscriptionResult] = []
+    offsets: list[float] = []
+    agg_lock = threading.Lock()
+    tx_done = threading.Event()
+
+    def _build_latest_ready_prompt(
+        current_index: int, finished: dict[int, str], max_chars: int = 800, max_chunks: int = 3
+    ) -> str | None:
+        parts: list[str] = []
+        total = 0
+        taken_chunks = 0
+        # Walk backward from previous indices
+        for idx in range(current_index - 1, 0, -1):
+            if idx not in finished:
+                continue
+            text = finished[idx].strip()
+            if not text:
+                continue
+            # Split into sentences (simple heuristic: ., !, ? followed by whitespace or end)
+            sentences = re.split(r"(?<=[.!?])[\s\n]+", text)
+            # Take completed sentences from the end
+            for s in reversed(sentences):
+                s = s.strip()
+                if not s:
+                    continue
+                # Ensure it looks like a completed sentence
+                # Use triple-quoted raw string to safely include quotes in the class
+                if not re.search(r"""[.!?][\)\]\}"']*$|[.!?]$""", s):
+                    # skip likely incomplete trailing fragment
+                    continue
+                if total + len(s) + (1 if parts else 0) > max_chars:
+                    return (" ".join(reversed(parts))) or None
+                parts.append(s)
+                total += len(s) + (1 if parts else 0)
+                # We don't count sentences per chunk strictly, but stop if we already got from enough chunks
+            taken_chunks += 1
+            if taken_chunks >= max_chunks or total >= max_chars:
+                break
+        return (" ".join(reversed(parts))) or None
+
+    # Event signaling that prompt (chunk #1) is fully transcribed
+    prompt_done = threading.Event()
+
+    def tx_worker():
+        model = engine.resolve_model(fut)
+        nonlocal cumulative_text, next_to_emit
+        finished_texts: dict[int, str] = {}
+        while True:
+            idx, path, frames, offset = tx_q.get()
+            if idx == -1:
+                break
+            # If in spoken-prompt mode, ensure we don't process payload chunks before prompt is done
+            if opts.prompt and idx > 1 and not prompt_done.is_set():
+                prompt_done.wait()
+            # Build latest-ready prompt based on already finished chunks
+            prompt = _build_latest_ready_prompt(idx, finished_texts)
+            res = engine.transcribe_chunk(model, path, frames, initial_prompt=prompt)
+            engine.write_chunk_outputs(res, path)
+            text_i = (res.get("text", "") or "").strip()
+            with agg_lock:
+                if text_i:
+                    finished_texts[idx] = text_i
+                results.append(res)
+                offsets.append(offset)
+                pending[idx] = text_i
+                while next_to_emit in pending:
+                    out = pending.pop(next_to_emit)
+                    if out:
+                        print(out)
+                        print("")
+                        cumulative_text += out if not cumulative_text else ("\n\n" + out)
+                        try:
+                            copy_to_clipboard(cumulative_text)
+                        except Exception:
+                            pass
+                    next_to_emit += 1
+                # If this was the prompt chunk, signal readiness and instruct user
+                if opts.prompt and idx == 1 and not prompt_done.is_set():
+                    prompt_done.set()
+                    print("=" * 60)
+                    print("Prompt transcribed. Start speaking your main content now.")
+                    print("=" * 60)
+                    # Allow recorder to resume writing the next chunk
+                    if prompt_resume_event is not None:
+                        prompt_resume_event.set()
+        tx_done.set()
+
+    tx_t = threading.Thread(target=tx_worker, daemon=True)
+    tx_t.start()
+
+    if opts.prompt:
+        print("Prompt mode enabled: Speak your prompt first, then press SPACE.")
+        print("Recording will wait for the prompt transcription before starting payload.")
+    # Prepare resume event to pause recording between prompt and payload
+    prompt_resume_event = threading.Event() if opts.prompt else None
+    rec = Recorder(
+        session_dir,
+        opts.rate,
+        opts.channels,
+        ext,
+        debounce_ms=opts.debounce_ms,
+        verbose=opts.verbose,
+        pause_after_first_chunk=opts.prompt,
+        resume_event=prompt_resume_event,
+    )
+    t0 = time.perf_counter()
+    chunk_paths, chunk_frames, chunk_offsets = rec.run(tx_q)
+    t1 = time.perf_counter()
+    if opts.profile:
+        profile_data["recording_sec"] = t1 - t0
+    tx_t.join()
+
+    merged: TranscriptionResult = engine.merge_results(results, chunk_offsets, cumulative_text)
+    base_audio_path = session_dir / f"recording{ext}"
+    txt_path = write_final_outputs(merged, session_dir, base_audio_path)
+
+    try:
+        if chunk_paths:
+            concat_audio(chunk_paths, base_audio_path, opts.rate, opts.channels)
+            if opts.verbose:
+                print(f"Merged audio written: {base_audio_path.name}", file=sys.stderr)
+            if requested == "mp3" and shutil.which("ffmpeg") is not None:
+                mp3_out = session_dir / "recording.mp3"
+                convert_wav_to_mp3(
+                    (
+                        base_audio_path
+                        if base_audio_path.suffix.lower() == ".wav"
+                        else base_audio_path
+                    ),
+                    mp3_out,
+                )
+                if opts.verbose:
+                    print(f"Converted merged audio to MP3: {mp3_out.name}", file=sys.stderr)
+    except Exception as e:
+        if opts.verbose:
+            print(f"Warning: failed to merge chunk audio: {e}", file=sys.stderr)
+
+    # Optionally delete chunk files (audio + per-chunk outputs)
+    if chunk_paths and not opts.keep_chunks:
+        for p in chunk_paths:
+            try:
+                p.unlink(missing_ok=True)
+            except Exception:
+                pass
+            stem = p.with_suffix("")
+            for suf in (".txt", ".srt", ".vtt", ".tsv", ".json"):
+                try:
+                    (stem.with_suffix(suf)).unlink(missing_ok=True)
+                except Exception:
+                    pass
+
+    text_final: str = merged.get("text") or cumulative_text
+    t_cb0 = time.perf_counter()
+    copy_to_clipboard(text_final)
+    t_cb1 = time.perf_counter()
+    profile_data["clipboard_sec"] = t_cb1 - t_cb0
+
+    print("—" * 60)
+    print(f"Done. Files in folder: {session_dir}")
+    print("Created:")
+    if chunk_paths:
+        print(f"  - chunks: {chunk_paths[0].name} … {chunk_paths[-1].name} (x{len(chunk_paths)})")
+    print("  - Whisper outputs: .txt, .srt, .vtt, .tsv, .json")
+    print(f"Copied TXT to clipboard: {txt_path.name}")
+
+    if opts.edit:
+        opened, used = open_in_shell_editor(txt_path)
+        if opened:
+            print("—" * 60)
+            print(f"Opened transcript in editor: {used or '$VISUAL/$EDITOR'}")
+        else:
+            print("—" * 60)
+            print(
+                "Could not open an editor from $VISUAL/$EDITOR or fallbacks; printing transcript instead:"
+            )
+            print(text_final.rstrip("\n"))
+    else:
+        print("—" * 60)
+        print("Transcript (clipboard text):")
+        print(text_final.rstrip("\n"))
+
+    if opts.profile:
+        try:
+            prof_path = session_dir / "profile.json"
+            prof_json = {**profile_data}
+            prof_json["total_sec"] = prof_json.get("total_sec", (time.perf_counter() - t0))
+            prof_path.write_text(json.dumps(prof_json, indent=2), encoding="utf-8")
+            print("—" * 60)
+            print("Profiling summary (seconds):")
+            for key in (
+                "recording_sec",
+                "model_load_sec",
+                "transcribe_sec",
+                "clipboard_sec",
+                "total_sec",
+            ):
+                if key in prof_json:
+                    print(f"  {key}: {prof_json[key]:.3f}")
+            print(f"Saved profiling JSON: {prof_path}")
+        except Exception as e:
+            print(f"Warning: failed to write profiling JSON: {e}")
+    return 0
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(
+        description="Record speech, transcribe with Whisper, emit outputs, and copy .txt to clipboard."
+    )
+    parser.add_argument(
+        "-V",
+        "--version",
+        action="version",
+        version=f"%(prog)s {__version__}",
+        help="Show program's version number and exit",
+    )
+    parser.add_argument(
+        "-l",
+        "--lang",
+        help="Whisper language (e.g., 'de' or 'en'); auto-detect if omitted",
+        default=None,
+    )
+    parser.add_argument(
+        "-r", "--rate", type=int, default=44100, help="Sample rate (default: 44100)"
+    )
+    parser.add_argument(
+        "-c", "--channels", type=int, default=1, help="Channels (1=mono, 2=stereo; default: 1)"
+    )
+    parser.add_argument(
+        "-m",
+        "--model",
+        default="turbo",
+        help="Whisper model (e.g., turbo, base, small, medium, large-v2)",
+    )
+    parser.add_argument(
+        "-f",
+        "--recording-format",
+        choices=["flac", "wav", "mp3"],
+        default="flac",
+        help="Audio container for the recording (default: flac)",
+    )
+    parser.add_argument(
+        "-o",
+        "--outdir",
+        default=None,
+        help="Base output directory for timestamped sessions (default: current directory)",
+    )
+    parser.add_argument(
+        "-t",
+        "--translate",
+        action="store_true",
+        help="Translate to English instead of transcribing in source language",
+    )
+    parser.add_argument(
+        "-v",
+        "--verbose",
+        action="store_true",
+        help="Print details about the Whisper invocation",
+    )
+    parser.add_argument(
+        "-L",
+        "--list-models",
+        action="store_true",
+        help="List available Whisper model names and exit",
+    )
+    parser.add_argument(
+        "--profile",
+        action="store_true",
+        help="Collect and print timing information; also writes profile.json to the session folder",
+    )
+    parser.add_argument(
+        "--debounce-ms",
+        type=int,
+        default=0,
+        help="Debounce window for SPACE (ms). If >0, ignores rapid successive space presses",
+    )
+    parser.add_argument(
+        "--native-segmentation",
+        action="store_true",
+        help="Use Whisper's native segmentation inside chunks (default collapses each chunk to a single phrase)",
+    )
+    parser.add_argument(
+        "-p",
+        "--prompt",
+        action="store_true",
+        help="Spoken prompt mode: speak your prompt, then press SPACE to use it as prompt and continue with payload; if you press ENTER instead, no prompt is used and the spoken audio is transcribed as normal payload before ending",
+    )
+    parser.add_argument(
+        "--keep-chunks",
+        action="store_true",
+        help="Keep per-chunk audio and outputs (default: delete after final merge)",
+    )
+    parser.add_argument(
+        "-e",
+        "--edit",
+        action="store_true",
+        help="Open the transcript (.txt) in the system's default editor instead of printing to stdout",
+    )
+    args = parser.parse_args(argv)
+
+    try:
+        if args.list_models:
+            try:
+                import whisper
+
+                models = sorted(whisper.available_models())
+                print("Available models:")
+                for m in models:
+                    print(f"  - {m}")
+                return 0
+            except Exception as e:
+                print(f"Error listing models: {e}", file=sys.stderr)
+                return 1
+        logging.basicConfig(
+            level=(logging.INFO if args.verbose else logging.WARNING),
+            format="%(levelname)s: %(message)s",
+        )
+        # Default outdir to 'transcripts' if not provided
+        opts = SessionOptions(
+            outdir=Path(args.outdir) if args.outdir else Path("transcripts"),
+            rate=args.rate,
+            channels=args.channels,
+            recording_format=args.recording_format,
+            model=args.model,
+            lang=args.lang,
+            translate=args.translate,
+            native_segmentation=getattr(args, "native_segmentation", False),
+            verbose=args.verbose,
+            edit=args.edit,
+            debounce_ms=getattr(args, "debounce_ms", 0),
+            profile=args.profile,
+            keep_chunks=getattr(args, "keep_chunks", False),
+            prompt=getattr(args, "prompt", False),
+        )
+        return run_session(opts)
+    except Exception as e:
+        print(f"Error: {e}", file=sys.stderr)
+        return 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

s2t/config.py

@@ -0,0 +1,22 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+
+
+@dataclass
+class SessionOptions:
+    outdir: Path | None
+    rate: int
+    channels: int
+    recording_format: str
+    model: str
+    lang: str | None
+    translate: bool
+    native_segmentation: bool
+    verbose: bool
+    edit: bool
+    debounce_ms: int
+    profile: bool
+    keep_chunks: bool
+    prompt: bool

s2t/outputs.py

@@ -0,0 +1,49 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from .types import TranscriptionResult
+
+
+def write_final_outputs(
+    merged_result: TranscriptionResult, session_dir: Path, base_audio_path: Path
+) -> Path:
+    try:
+        from whisper.utils import get_writer
+
+        for fmt in ("txt", "srt", "vtt", "tsv", "json"):
+            writer = get_writer(fmt, str(session_dir))
+            writer(merged_result, str(base_audio_path))
+        return session_dir / "recording.txt"
+    except Exception as e:
+        print(f"Error writing merged outputs: {e}")
+        txt_path = session_dir / "recording.txt"
+        try:
+            txt_path.write_text(merged_result.get("text", ""), encoding="utf-8")
+        except Exception:
+            pass
+        return txt_path
+
+
+def concat_audio(
+    chunk_paths: list[Path],
+    out_path: Path,
+    samplerate: int,
+    channels: int,
+) -> None:
+    try:
+        import soundfile as sf
+
+        fmt = "FLAC" if out_path.suffix.lower() == ".flac" else "WAV"
+        with sf.SoundFile(
+            str(out_path), mode="w", samplerate=samplerate, channels=channels, format=fmt
+        ) as outf:
+            for p in chunk_paths:
+                with sf.SoundFile(str(p), mode="r") as inf:
+                    while True:
+                        data = inf.read(frames=16384, dtype="float32")
+                        if data.size == 0:
+                            break
+                        outf.write(data)
+    except Exception as e:
+        print(f"Warning: failed to merge chunk audio: {e}")

s2t/py.typed

@@ -0,0 +1 @@
+

s2t/recorder.py

@@ -0,0 +1,205 @@
+from __future__ import annotations
+
+import queue
+import select
+import sys
+import threading
+import time
+from pathlib import Path
+from typing import Any, Protocol, cast, runtime_checkable
+
+
+class Recorder:
+    def __init__(
+        self,
+        session_dir: Path,
+        samplerate: int,
+        channels: int,
+        ext: str,
+        debounce_ms: int = 0,
+        verbose: bool = False,
+        pause_after_first_chunk: bool = False,
+        resume_event: threading.Event | None = None,
+    ) -> None:
+        self.session_dir = session_dir
+        self.samplerate = samplerate
+        self.channels = channels
+        self.ext = ext
+        self.debounce_ms = max(0, int(debounce_ms))
+        self.verbose = verbose
+        self.pause_after_first_chunk = pause_after_first_chunk
+        self.resume_event = resume_event
+        self._paused = False
+
+    def run(
+        self,
+        tx_queue: queue.Queue[tuple[int, Path, int, float]],
+    ) -> tuple[list[Path], list[int], list[float]]:
+        import platform
+        import termios
+        import tty
+
+        try:
+            import sounddevice as sd
+            import soundfile as sf
+        except Exception as e:
+            raise RuntimeError("sounddevice/soundfile required for recording.") from e
+
+        evt_q: queue.Queue[str] = queue.Queue()
+        stop_evt = threading.Event()
+
+        def key_reader() -> None:
+            try:
+                if platform.system() == "Windows":
+                    import msvcrt
+
+                    @runtime_checkable
+                    class _MSVCRT(Protocol):
+                        def kbhit(self) -> int: ...
+                        def getwch(self) -> str: ...
+
+                    ms = cast(_MSVCRT, msvcrt)
+
+                    last_space = 0.0
+                    while not stop_evt.is_set():
+                        if ms.kbhit():
+                            ch = ms.getwch()
+                            if ch in ("\r", "\n"):
+                                evt_q.put("ENTER")
+                                break
+                            if ch == " ":
+                                now = time.perf_counter()
+                                if self.debounce_ms and (now - last_space) < (
+                                    self.debounce_ms / 1000.0
+                                ):
+                                    continue
+                                last_space = now
+                                evt_q.put("SPACE")
+                        time.sleep(0.01)
+                else:
+                    fd = sys.stdin.fileno()
+                    old = termios.tcgetattr(fd)
+                    tty.setcbreak(fd)
+                    last_space = 0.0
+                    try:
+                        while not stop_evt.is_set():
+                            r, _, _ = select.select([sys.stdin], [], [], 0.05)
+                            if r:
+                                ch = sys.stdin.read(1)
+                                if ch in ("\n", "\r"):
+                                    evt_q.put("ENTER")
+                                    break
+                                if ch == " ":
+                                    now = time.perf_counter()
+                                    if self.debounce_ms and (now - last_space) < (
+                                        self.debounce_ms / 1000.0
+                                    ):
+                                        continue
+                                    last_space = now
+                                    evt_q.put("SPACE")
+                    finally:
+                        termios.tcsetattr(fd, termios.TCSADRAIN, old)
+            except Exception:
+                pass
+
+        audio_q: queue.Queue[tuple[str, Any]] = queue.Queue(maxsize=128)
+        chunk_index = 1
+        chunk_paths: list[Path] = []
+        chunk_frames: list[int] = []
+        chunk_offsets: list[float] = []
+        offset_seconds_total = 0.0
+
+        def writer_fn() -> None:
+            nonlocal chunk_index, offset_seconds_total
+            frames_written = 0
+            cur_path = self.session_dir / f"chunk_{chunk_index:04d}{self.ext}"
+            fh = sf.SoundFile(
+                str(cur_path), mode="w", samplerate=self.samplerate, channels=self.channels
+            )
+            while True:
+                kind, payload = audio_q.get()
+                if kind == "frames":
+                    data = payload
+                    fh.write(data)
+                    frames_written += len(data)
+                elif kind == "split":
+                    fh.flush()
+                    fh.close()
+                    if frames_written > 0:
+                        dur = frames_written / float(self.samplerate)
+                        chunk_paths.append(cur_path)
+                        chunk_frames.append(frames_written)
+                        chunk_offsets.append(offset_seconds_total)
+                        offset_seconds_total += dur
+                        if self.verbose:
+                            print(f"Saved chunk: {cur_path.name} ({dur:.2f}s)", file=sys.stderr)
+                        tx_queue.put((chunk_index, cur_path, frames_written, chunk_offsets[-1]))
+                    else:
+                        try:
+                            cur_path.unlink(missing_ok=True)
+                        except Exception:
+                            pass
+                    frames_written = 0
+                    chunk_index += 1
+                    if (
+                        self.pause_after_first_chunk
+                        and chunk_index == 2
+                        and self.resume_event is not None
+                    ):
+                        self._paused = True
+                        self.resume_event.wait()
+                        self._paused = False
+                    cur_path = self.session_dir / f"chunk_{chunk_index:04d}{self.ext}"
+                    fh = sf.SoundFile(
+                        str(cur_path), mode="w", samplerate=self.samplerate, channels=self.channels
+                    )
+                elif kind == "finish":
+                    fh.flush()
+                    fh.close()
+                    if frames_written > 0:
+                        dur = frames_written / float(self.samplerate)
+                        chunk_paths.append(cur_path)
+                        chunk_frames.append(frames_written)
+                        chunk_offsets.append(offset_seconds_total)
+                        offset_seconds_total += dur
+                        if self.verbose:
+                            print(f"Saved chunk: {cur_path.name} ({dur:.2f}s)", file=sys.stderr)
+                        tx_queue.put((chunk_index, cur_path, frames_written, chunk_offsets[-1]))
+                    else:
+                        try:
+                            cur_path.unlink(missing_ok=True)
+                        except Exception:
+                            pass
+                    break
+            tx_queue.put((-1, Path(), 0, 0.0))
+
+        def cb(indata: Any, frames: int, time_info: Any, status: Any) -> None:
+            if status:
+                print(status, file=sys.stderr)
+            if not self._paused:
+                audio_q.put(("frames", indata.copy()))
+
+        key_t = threading.Thread(target=key_reader, daemon=True)
+        writer_t = threading.Thread(target=writer_fn, daemon=True)
+        key_t.start()
+        writer_t.start()
+
+        print("Recording… Press SPACE to split, Enter to finish.")
+        print("—" * 60)
+        print("")
+
+        import sounddevice as sd
+
+        with sd.InputStream(samplerate=self.samplerate, channels=self.channels, callback=cb):
+            while True:
+                try:
+                    evt = evt_q.get(timeout=0.05)
+                except queue.Empty:
+                    continue
+                if evt == "SPACE":
+                    audio_q.put(("split", None))
+                elif evt == "ENTER":
+                    audio_q.put(("finish", None))
+                    break
+        writer_t.join()
+        return chunk_paths, chunk_frames, chunk_offsets

s2t/types.py

@@ -0,0 +1,14 @@
+from __future__ import annotations
+
+from typing import TypedDict
+
+
+class SegmentDict(TypedDict, total=False):
+    start: float
+    end: float
+    text: str
+
+
+class TranscriptionResult(TypedDict):
+    text: str
+    segments: list[SegmentDict]

s2t/utils.py

@@ -0,0 +1,109 @@
+from __future__ import annotations
+
+import os
+import platform
+import shutil
+import subprocess
+import sys
+from datetime import datetime
+from pathlib import Path
+
+import numpy as np
+
+
+def check_dependency(cmd: str, install_hint: str) -> None:
+    if shutil.which(cmd) is None:
+        raise RuntimeError(f"Dependency '{cmd}' not found. Hint: {install_hint}")
+
+
+def convert_wav_to_mp3(wav_path: Path, mp3_path: Path) -> None:
+    check_dependency(
+        "ffmpeg",
+        "macOS: brew install ffmpeg; Linux: apt/yum; Windows: install ffmpeg and add to PATH",
+    )
+    cmd = [
+        "ffmpeg",
+        "-y",
+        "-i",
+        str(wav_path),
+        "-vn",
+        "-acodec",
+        "libmp3lame",
+        "-q:a",
+        "2",
+        str(mp3_path),
+    ]
+    subprocess.run(cmd, check=True, stdout=subprocess.DEVNULL, stderr=subprocess.STDOUT)
+
+
+def copy_to_clipboard(text: str) -> None:
+    system = platform.system()
+    try:
+        if system == "Darwin":
+            subprocess.run(["pbcopy"], input=text, text=True, check=True)
+            return
+        if system == "Windows":
+            subprocess.run(["clip"], input=text, text=True, check=True)
+            return
+        if shutil.which("xclip"):
+            subprocess.run(["xclip", "-selection", "clipboard"], input=text, text=True, check=True)
+            return
+        if shutil.which("xsel"):
+            subprocess.run(["xsel", "--clipboard", "--input"], input=text, text=True, check=True)
+            return
+        try:
+            import pyperclip
+
+            pyperclip.copy(text)
+            return
+        except Exception:
+            pass
+    except Exception as e:
+        print(f"Copy to clipboard failed: {e}", file=sys.stderr)
+        return
+    print("No clipboard tool found (pbcopy/clip/xclip/xsel). Optional: pip install pyperclip.")
+
+
+def open_in_shell_editor(file_path: Path) -> tuple[bool, str]:
+    env_editor = os.environ.get("VISUAL") or os.environ.get("EDITOR")
+    candidates: list[list[str]] = []
+    if env_editor:
+        import shlex as _shlex
+
+        try:
+            candidates.append(_shlex.split(env_editor))
+        except Exception:
+            candidates.append([env_editor])
+    candidates += [["vim"], ["nvim"], ["nano"], ["micro"], ["notepad"]]
+    for argv in candidates:
+        exe = argv[0]
+        if shutil.which(exe) is None:
+            continue
+        try:
+            subprocess.run(argv + [str(file_path)], check=True)
+            return True, " ".join(argv)
+        except Exception:
+            continue
+    return False, ""
+
+
+def make_session_dir(base_dir: Path | None = None) -> Path:
+    ts = datetime.now().astimezone().strftime("%Y-%m-%dT%H-%M-%S%z")
+    base = Path(base_dir) if base_dir is not None else Path.cwd()
+    base.mkdir(parents=True, exist_ok=True)
+    session = base / ts
+    session.mkdir(parents=True, exist_ok=False)
+    return session
+
+
+def resample_linear(x: np.ndarray, src_sr: int, dst_sr: int) -> np.ndarray:
+    if src_sr == dst_sr:
+        return x.astype(np.float32, copy=False)
+    x = x.astype(np.float32, copy=False)
+    n_src = x.shape[0]
+    n_dst = int(round(n_src * (dst_sr / float(src_sr))))
+    if n_src == 0 or n_dst == 0:
+        return np.zeros(n_dst, dtype=np.float32)
+    src_t = np.linspace(0.0, 1.0, num=n_src, endpoint=False)
+    dst_t = np.linspace(0.0, 1.0, num=n_dst, endpoint=False)
+    return np.interp(dst_t, src_t, x).astype(np.float32)

s2t/whisper_engine.py

@@ -0,0 +1,139 @@
+from __future__ import annotations
+
+import time
+from concurrent.futures import Future, ThreadPoolExecutor
+from pathlib import Path
+from typing import Any
+
+from .types import SegmentDict, TranscriptionResult
+
+
+class WhisperEngine:
+    def __init__(
+        self,
+        model_name: str,
+        translate: bool,
+        language: str | None,
+        native_segmentation: bool,
+        session_dir: Path,
+        samplerate: int,
+        channels: int,
+        verbose: bool = False,
+        profile: dict | None = None,
+    ) -> None:
+        self.model_name = model_name
+        self.translate = translate
+        self.language = language
+        self.native_segmentation = native_segmentation
+        self.session_dir = session_dir
+        self.samplerate = samplerate
+        self.channels = channels
+        self.verbose = verbose
+        self.profile = profile or {}
+        self._executor: ThreadPoolExecutor | None = None
+
+    def preload(self) -> tuple[ThreadPoolExecutor | None, Future | None]:
+        try:
+            self._executor = ThreadPoolExecutor(max_workers=1)
+
+            def _load(name: str):
+                import whisper
+
+                t0 = time.perf_counter()
+                m = whisper.load_model(name)
+                t1 = time.perf_counter()
+                return m, (t1 - t0)
+
+            fut = self._executor.submit(_load, self.model_name)
+            return self._executor, fut
+        except Exception:
+            return None, None
+
+    def resolve_model(self, fut: Future | None):
+        import whisper
+
+        model = None
+        if fut is not None:
+            try:
+                model, load_dur = fut.result()
+                self.profile["model_load_sec"] = self.profile.get("model_load_sec", 0.0) + float(
+                    load_dur
+                )
+            except Exception:
+                model = None
+        if model is None:
+            t0m = time.perf_counter()
+            model = whisper.load_model(self.model_name)
+            t1m = time.perf_counter()
+            self.profile["model_load_sec"] = self.profile.get("model_load_sec", 0.0) + (t1m - t0m)
+        return model
+
+    def transcribe_chunk(
+        self,
+        model,
+        audio_path: Path,
+        frames: int,
+        initial_prompt: str | None = None,
+    ) -> TranscriptionResult:
+        task = "translate" if self.translate else "transcribe"
+        t0 = time.perf_counter()
+        res: dict[str, Any] = model.transcribe(
+            str(audio_path),
+            task=task,
+            language=self.language,
+            fp16=False,
+            initial_prompt=initial_prompt,
+        )
+        t1 = time.perf_counter()
+        self.profile["transcribe_sec"] = self.profile.get("transcribe_sec", 0.0) + (t1 - t0)
+        text_c = str(res.get("text", "") or "").strip()
+        if self.native_segmentation:
+            segs_raw = res.get("segments", []) or []
+            segs_typed: list[SegmentDict] = []
+            for s in segs_raw:
+                try:
+                    start = float(s.get("start", 0.0))
+                    end = float(s.get("end", 0.0))
+                    text = str(s.get("text", "") or "")
+                    segs_typed.append({"start": start, "end": end, "text": text})
+                except Exception:
+                    continue
+            return {"text": text_c, "segments": segs_typed}
+        # Collapsed single segment per chunk
+        segs_raw = res.get("segments", []) or []
+        start = float(segs_raw[0].get("start", 0.0)) if segs_raw else 0.0
+        end = float(segs_raw[-1].get("end", 0.0)) if segs_raw else (frames / float(self.samplerate))
+        return {
+            "text": text_c,
+            "segments": ([{"start": start, "end": end, "text": text_c}] if text_c else []),
+        }
+
+    def write_chunk_outputs(self, result: TranscriptionResult, audio_path: Path) -> None:
+        try:
+            from whisper.utils import get_writer
+
+            for fmt in ("txt", "srt", "vtt", "tsv", "json"):
+                writer = get_writer(fmt, str(self.session_dir))
+                writer(result, str(audio_path))
+        except Exception as e:
+            if self.verbose:
+                print(f"Warning: failed to write chunk outputs for {audio_path.name}: {e}")
+
+    def merge_results(
+        self, results: list[TranscriptionResult], offsets: list[float], cumulative_text: str
+    ) -> TranscriptionResult:
+        merged: TranscriptionResult = {"text": "", "segments": []}
+        for res, off in zip(results, offsets, strict=False):
+            merged["text"] += res.get("text") or ""
+            for s in res.get("segments", []):
+                s2: SegmentDict = {}
+                if "start" in s:
+                    s2["start"] = float(s["start"]) + off
+                if "end" in s:
+                    s2["end"] = float(s["end"]) + off
+                if "text" in s:
+                    s2["text"] = s["text"]
+                merged["segments"].append(s2)
+        if (cumulative_text or "").strip():
+            merged["text"] = cumulative_text
+        return merged

s2t-0.1.0.post1.dev2.dist-info/METADATA

@@ -0,0 +1,85 @@
+Metadata-Version: 2.4
+Name: s2t
+Version: 0.1.0.post1.dev2
+Summary: Speech to Text (s2t): Record audio, run Whisper, export formats, and copy transcript to clipboard.
+Author: Maintainers
+License-Expression: LicenseRef-Proprietary
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Environment :: Console
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: sounddevice>=0.4.6
+Requires-Dist: soundfile>=0.12.1
+Requires-Dist: numpy>=1.23
+Requires-Dist: openai-whisper>=20231117
+Provides-Extra: dev
+Requires-Dist: pytest>=7; extra == "dev"
+Requires-Dist: pytest-cov>=4; extra == "dev"
+Requires-Dist: ruff>=0.4; extra == "dev"
+Requires-Dist: mypy>=1.7; extra == "dev"
+Requires-Dist: build>=1; extra == "dev"
+Requires-Dist: setuptools-scm>=8; extra == "dev"
+Requires-Dist: twine>=4; extra == "dev"
+
+# s2t
+
+Record audio from your microphone, run Whisper to transcribe it, export common formats, and copy the .txt transcript to your clipboard.
+
+## Install
+- From local checkout:
+  - Editable: `pip install -e .`
+  - Standard: `pip install .`
+
+Requirements: Python 3.11+. No mandatory external binaries. ffmpeg is optional (only for MP3 encoding/decoding).
+
+System requirements (Linux)
+- Some environments need system libraries for audio I/O:
+  - Debian/Ubuntu: `sudo apt-get install libportaudio2 libsndfile1`
+  - Fedora/RHEL: `sudo dnf install portaudio libsndfile`
+- Optional for MP3: ffmpeg (`sudo apt-get install ffmpeg` or `brew install ffmpeg`).
+
+## Usage
+- Start interactive recording and transcribe:
+  - `s2t`
+- Short options:
+  - Language: `-l de` (long: `--lang de`)
+  - Model: `-m large-v3` (long: `--model large-v3`)
+  - Sample rate: `-r 48000` (long: `--rate 48000`)
+  - Channels: `-c 2` (long: `--channels 2`)
+  - Output dir: `-o transcripts` (long: `--outdir transcripts`) — default is `transcripts/` if omitted
+  - Translate to English: `-t` (long: `--translate`). You may still provide `--lang` as an input-language hint if you want.
+  - List available models and exit: `-L` (long: `--list-models`)
+  - Recording format: `-f flac|wav|mp3` (long: `--recording-format`), default `flac`. MP3 requires ffmpeg; if absent, it falls back to FLAC with a warning.
+  - Prompt mode (spoken prompt): `-p` (long: `--prompt`). Speak your prompt first, then press SPACE to use it as prompt and continue with your main content. If you press ENTER instead of SPACE, no prompt is used; the spoken audio is transcribed as normal payload and the session ends.
+  - Keep chunk files: `--keep-chunks` — by default, per‑chunk audio and per‑chunk Whisper outputs are deleted after the final merge.
+  - Open transcript for editing: `-e` (long: `--edit`) — opens the generated `.txt` in your shell editor (`$VISUAL`/`$EDITOR`).
+- Examples:
+  - Transcribe in German using large-v3: `s2t -l de -m large-v3`
+  - Translate any input to English: `s2t -t`
+  - Write outputs under transcripts/: `s2t -o transcripts`
+  - List local model names: `s2t -L`
+
+Outputs are written into a timestamped folder under the chosen output directory (default is `transcripts/`), e.g. `transcripts/2025-01-31T14-22-05+0200/`, containing:
+- Per‑chunk outputs: `chunk_####.flac/.wav` plus `chunk_####.txt/.srt/.vtt/.tsv/.json` (deleted by default unless `--keep-chunks`)
+- Final outputs: `recording.flac/.wav` (and `recording.mp3` if requested and ffmpeg available), plus `recording.txt/.srt/.vtt/.tsv/.json`
+- Clipboard mirrors the combined `.txt` with blank lines between chunks.
+
+## Makefile (optional)
+- Setup venv + dev deps: `make setup`
+- Lint/format/test: `make lint`, `make format`, `make test`; combined gate: `make check`
+- Build sdist/wheel: `make build` (runs `check` first)
+- Publish to PyPI/TestPyPI: `make publish`, `make publish-test` (run after `build`)
+- Run CLI: `make record ARGS='-l de -t -o transcripts'`
+- List models: `make list-models`
+- Show package version: `make version`
+
+Notes on models
+- The local openai-whisper CLI supports models like: `tiny`, `base`, `small`, `medium`, `large-v1`, `large-v2`, `large-v3` and their `.en` variants.
+- The name `turbo` refers to OpenAI’s hosted model family and is not provided by the local `whisper` CLI. If you pass `-m turbo`, the command may fail; choose a supported local model instead.
+
+## Development & Release
+- Für Entwickler-Setup und Beitragshinweise siehe `CONTRIBUTING.md`.
+- Für den Release-Prozess siehe `docs/RELEASING.md`.

s2t-0.1.0.post1.dev2.dist-info/RECORD

@@ -0,0 +1,14 @@
+s2t/__init__.py,sha256=wV4E9i-7KrUn1dOtLUQB3ZGEKx9gRWH3hPHlpw-ZdWc,332
+s2t/cli.py,sha256=5Z0YxLPwvfV8wrU-vN1s1HzzOLmA0HYi5uVf6brUtQQ,15786
+s2t/config.py,sha256=mzz6ljGEupNDAzlUwf5kvl0iKqO8WZ4TWsU4nSVtp0M,409
+s2t/outputs.py,sha256=Lo8VcARZ7QPuuQQNu8myD5J4c4NO1Rs0L1DLnzLe9tM,1546
+s2t/py.typed,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+s2t/recorder.py,sha256=uBD9mYf-uUCkRJw8fQitVnDrX6PwRNXJycyY4dBfXL0,8076
+s2t/types.py,sha256=BuMyWuueS7EZbk7I_CkIWSb69Yi6g9-wr7CZLAZKflw,242
+s2t/utils.py,sha256=YU6YhiuONmqhrKte4DY5tiC5PP-yFExJMMBzFUiA8qA,3416
+s2t/whisper_engine.py,sha256=s9NBPtyptdhKauKQB4moq2SeGDQp2z7qc13e8C00SxY,5075
+s2t-0.1.0.post1.dev2.dist-info/METADATA,sha256=c-7jrltbRiLjW0ixPZwgf49L8Ar7p7N5Dc7b0QO_pUo,4568
+s2t-0.1.0.post1.dev2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+s2t-0.1.0.post1.dev2.dist-info/entry_points.txt,sha256=JISIUlZAJ3DX1dB6zT3X_E3vcXI-eWEQKwHiT35fPKs,37
+s2t-0.1.0.post1.dev2.dist-info/top_level.txt,sha256=o8N0JcuHdIrfX3iGHvntHiDC2XgN7__joyNu08ZOh0s,4
+s2t-0.1.0.post1.dev2.dist-info/RECORD,,

s2t-0.1.0.post1.dev2.dist-info/WHEEL

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

s2t-0.1.0.post1.dev2.dist-info/entry_points.txt

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

s2t-0.1.0.post1.dev2.dist-info/top_level.txt

@@ -0,0 +1 @@
+s2t