s2t 0.1.2__py3-none-any.whl → 0.1.3.post1.dev1__py3-none-any.whl

s2t/cli.py

@@ -40,6 +40,11 @@ from . import __version__
 from .config import SessionOptions
 from .outputs import concat_audio, write_final_outputs
 from .recorder import Recorder
+from .translator.argos_backend import (
+    ArgosTranslator,
+    ensure_packages_background,
+    translate_result_segments,
+)
 from .types import TranscriptionResult
 from .utils import (
     convert_wav_to_mp3,
@@ -62,7 +67,7 @@ def run_session(opts: SessionOptions) -> int:
 
     engine = WhisperEngine(
         model_name=opts.model,
-        translate=opts.translate,
+        translate=False,  # translation handled as post-processing
         language=opts.lang,
         native_segmentation=opts.native_segmentation,
         session_dir=session_dir,
@@ -73,6 +78,27 @@ def run_session(opts: SessionOptions) -> int:
     )
     ex, fut = engine.preload()
 
+    # Determine translation target languages from options
+    target_langs: list[str] = []
+    if opts.translate_to:
+        target_langs = list(dict.fromkeys([s.strip().lower() for s in opts.translate_to if s]))
+    elif opts.translate:
+        target_langs = ["en"]
+
+    # Background auto-install/update Argos packages as early as possible
+    detected_lang: dict[str, str | None] = {"code": None}
+    detected_lang_event = threading.Event()
+    translator: ArgosTranslator | None = None
+    if target_langs:
+        translator = ArgosTranslator(verbose=opts.verbose)
+        ensure_packages_background(
+            translator,
+            src_lang_hint=(opts.lang.lower() if opts.lang else None),
+            target_langs=target_langs,
+            detected_lang_event=detected_lang_event,
+            detected_lang_holder=detected_lang,
+        )
+
     tx_q: queue.Queue[tuple[int, Path, int, float]] = queue.Queue()
     cumulative_text = ""
     next_to_emit = 1
@@ -134,6 +160,12 @@ def run_session(opts: SessionOptions) -> int:
             # 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)
+            # Record detected language once (for translator preload if needed)
+            if target_langs and detected_lang["code"] is None:
+                lang_code = str(res.get("language") or "").strip().lower()
+                if lang_code:
+                    detected_lang["code"] = lang_code
+                    detected_lang_event.set()
             engine.write_chunk_outputs(res, path)
             text_i = (res.get("text", "") or "").strip()
             with agg_lock:
@@ -260,6 +292,55 @@ def run_session(opts: SessionOptions) -> int:
         print("=" * 60)
         print(text_final.rstrip("\n"))
 
+    # Post-processing: translate outputs for requested target languages
+    if target_langs and translator is not None:
+        # Decide source language: CLI hint takes precedence; else detected; else skip with warning
+        src_lang = (opts.lang.lower() if opts.lang else (detected_lang["code"] or "")).strip()
+        if not src_lang:
+            if opts.verbose:
+                print(
+                    "Warning: Could not determine source language for translation; skipping post-translation.",
+                    file=sys.stderr,
+                )
+        else:
+            # Skip identical language targets
+            effective_targets = [t for t in target_langs if t.lower() != src_lang.lower()]
+            # Ensure required packages if missing; perform synchronous install as needed
+            for tgt in effective_targets:
+                if not translator.has_package(src_lang, tgt):
+                    print(
+                        f"Ensuring Argos translation package for '{src_lang}->{tgt}' (may download 50–250 MB)…",
+                        file=sys.stderr,
+                    )
+                    ok = False
+                    try:
+                        ok = translator.ensure_package(src_lang, tgt)
+                    except Exception as e:
+                        print(
+                            f"Warning: could not install '{src_lang}->{tgt}' package: {e}",
+                            file=sys.stderr,
+                        )
+                    if not ok and not translator.has_package(src_lang, tgt):
+                        print(
+                            f"Warning: translation package unavailable or failed for '{src_lang}->{tgt}'. Skipping.",
+                            file=sys.stderr,
+                        )
+                        continue
+            try:
+                translated = translate_result_segments(translator, merged, src_lang, tgt)
+                # Write translated outputs with language suffix by passing a suffixed base path
+                suffixed = base_audio_path.with_name(
+                    f"{base_audio_path.stem}.{tgt}{base_audio_path.suffix}"
+                )
+                write_final_outputs(translated, session_dir, suffixed)
+                if opts.verbose:
+                    print(f"Created translated outputs for '{tgt}'.", file=sys.stderr)
+            except Exception as e:
+                print(
+                    f"Warning: failed to translate to '{tgt}': {e}",
+                    file=sys.stderr,
+                )
+
     if opts.profile:
         try:
             prof_path = session_dir / "profile.json"
@@ -329,7 +410,13 @@ def main(argv: list[str] | None = None) -> int:
         "-t",
         "--translate",
         action="store_true",
-        help="Translate to English instead of transcribing in source language",
+        help="After transcription, translate all outputs to English (post-processing)",
+    )
+    parser.add_argument(
+        "--translate-to",
+        action="append",
+        default=None,
+        help="After transcription, translate all outputs to the given language (can be repeated)",
     )
     parser.add_argument(
         "-v",
@@ -404,6 +491,7 @@ def main(argv: list[str] | None = None) -> int:
             model=args.model,
             lang=args.lang,
             translate=args.translate,
+            translate_to=(args.translate_to or []),
             native_segmentation=getattr(args, "native_segmentation", False),
             verbose=args.verbose,
             edit=args.edit,

s2t/config.py

@@ -13,6 +13,7 @@ class SessionOptions:
     model: str
     lang: str | None
     translate: bool
+    translate_to: list[str]
     native_segmentation: bool
     verbose: bool
     edit: bool

s2t/recorder.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import os
 import queue
 import select
 import sys
@@ -46,6 +47,8 @@ class Recorder:
             raise RuntimeError("sounddevice/soundfile required for recording.") from e
 
         evt_q: queue.Queue[str] = queue.Queue()
+        # Control queue is separate from audio frames to avoid control backpressure.
+        ctrl_q: queue.Queue[str] = queue.Queue()
         stop_evt = threading.Event()
 
         def key_reader() -> None:
@@ -61,10 +64,14 @@ class Recorder:
                     ms = cast(_MSVCRT, msvcrt)
 
                     last_space = 0.0
+                    if self.verbose:
+                        print("[key] using msvcrt (Windows)", file=sys.stderr)
                     while not stop_evt.is_set():
                         if ms.kbhit():
                             ch = ms.getwch()
                             if ch in ("\r", "\n"):
+                                if self.verbose:
+                                    print("[key] ENTER", file=sys.stderr)
                                 evt_q.put("ENTER")
                                 break
                             if ch == " ":
@@ -74,33 +81,118 @@ class Recorder:
                                 ):
                                     continue
                                 last_space = now
+                                if self.verbose:
+                                    print("[key] SPACE", file=sys.stderr)
                                 evt_q.put("SPACE")
                         time.sleep(0.01)
                 else:
-                    fd = sys.stdin.fileno()
-                    old = termios.tcgetattr(fd)
-                    tty.setcbreak(fd)
-                    last_space = 0.0
+                    # Prefer sys.stdin when it's a TTY (original, proven path). If not a TTY, try /dev/tty, else fallback to stdin line reads.
                     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
-                                    ):
+                        if sys.stdin.isatty():
+                            fd = sys.stdin.fileno()
+                            if self.verbose:
+                                print("[key] using sys.stdin (isatty, fd read)", file=sys.stderr)
+                            old = termios.tcgetattr(fd)
+                            tty.setcbreak(fd)
+                            last_space = 0.0
+                            try:
+                                while not stop_evt.is_set():
+                                    r, _, _ = select.select([fd], [], [], 0.05)
+                                    if r:
+                                        try:
+                                            ch_b = os.read(fd, 1)
+                                        except BlockingIOError:
+                                            continue
+                                        if not ch_b:
+                                            continue
+                                        ch = ch_b.decode(errors="ignore")
+                                        if ch in ("\n", "\r"):
+                                            if self.verbose:
+                                                print("[key] ENTER", file=sys.stderr)
+                                            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
+                                            if self.verbose:
+                                                print("[key] SPACE", file=sys.stderr)
+                                            evt_q.put("SPACE")
+                            finally:
+                                termios.tcsetattr(fd, termios.TCSADRAIN, old)
+                        else:
+                            # Try /dev/tty when stdin is not a TTY
+                            using_devtty = False
+                            fd = None
+                            try:
+                                fd = os.open("/dev/tty", os.O_RDONLY)
+                                using_devtty = True
+                                if self.verbose:
+                                    print("[key] using /dev/tty (stdin not TTY)", file=sys.stderr)
+                                old = termios.tcgetattr(fd)
+                                tty.setcbreak(fd)
+                                last_space = 0.0
+                                try:
+                                    while not stop_evt.is_set():
+                                        r, _, _ = select.select([fd], [], [], 0.05)
+                                        if r:
+                                            ch_b = os.read(fd, 1)
+                                            if not ch_b:
+                                                continue
+                                            ch = ch_b.decode(errors="ignore")
+                                            if ch in ("\n", "\r"):
+                                                if self.verbose:
+                                                    print("[key] ENTER", file=sys.stderr)
+                                                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
+                                                if self.verbose:
+                                                    print("[key] SPACE", file=sys.stderr)
+                                                evt_q.put("SPACE")
+                                finally:
+                                    termios.tcsetattr(fd, termios.TCSADRAIN, old)
+                            except Exception:
+                                if using_devtty and fd is not None:
+                                    try:
+                                        os.close(fd)
+                                    except Exception:
+                                        pass
+                                print(
+                                    "Warning: no TTY for key input; falling back to stdin line mode.",
+                                    file=sys.stderr,
+                                )
+                                # Last resort: line-buffered stdin; Enter will still end.
+                                while not stop_evt.is_set():
+                                    line = sys.stdin.readline()
+                                    if not line:
+                                        time.sleep(0.05)
                                         continue
-                                    last_space = now
-                                    evt_q.put("SPACE")
-                    finally:
-                        termios.tcsetattr(fd, termios.TCSADRAIN, old)
-            except Exception:
-                pass
+                                    # If user hits Enter on empty line, treat as ENTER
+                                    if line == "\n" or line == "\r\n":
+                                        if self.verbose:
+                                            print("[key] ENTER (line mode)", file=sys.stderr)
+                                        evt_q.put("ENTER")
+                                        break
+                                    # If first non-empty char is space, treat as SPACE
+                                    if line and line[0] == " ":
+                                        if self.verbose:
+                                            print("[key] SPACE (line mode)", file=sys.stderr)
+                                        evt_q.put("SPACE")
+                    except Exception as e:
+                        print(f"Warning: key reader failed: {e}", file=sys.stderr)
+
+            except Exception as e:
+                # Log unexpected key reader errors to aid debugging, but keep recording running.
+                print(f"Warning: key reader stopped unexpectedly: {e}", file=sys.stderr)
 
         audio_q: queue.Queue[tuple[str, Any]] = queue.Queue(maxsize=128)
         chunk_index = 1
@@ -117,67 +209,106 @@ class Recorder:
                 str(cur_path), mode="w", samplerate=self.samplerate, channels=self.channels
             )
             while True:
-                kind, payload = audio_q.get()
+                # First, handle any pending control commands so SPACE/ENTER are never blocked by frames backlog.
+                try:
+                    while True:
+                        cmd = ctrl_q.get_nowait()
+                        if cmd == "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 cmd == "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
+                            tx_queue.put((-1, Path(), 0, 0.0))
+                            return
+                except queue.Empty:
+                    pass
+
+                # Then, write frames if available; short timeout to re-check control queue regularly.
+                try:
+                    kind, payload = audio_q.get(timeout=0.05)
+                except queue.Empty:
+                    continue
                 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))
 
+        # Timestamp of last dropped-frame warning (throttling for verbose mode)
+        last_drop_log = 0.0
+
         def cb(indata: Any, frames: int, time_info: Any, status: Any) -> None:
+            nonlocal last_drop_log
             if status:
                 print(status, file=sys.stderr)
             if not self._paused:
-                audio_q.put(("frames", indata.copy()))
+                try:
+                    audio_q.put_nowait(("frames", indata.copy()))
+                except queue.Full:
+                    # Drop frame if the queue is saturated; throttle warnings.
+                    now = time.perf_counter()
+                    if self.verbose and (now - last_drop_log) > 1.0:
+                        print(
+                            "Warning: audio queue full; dropping input frames.",
+                            file=sys.stderr,
+                        )
+                        last_drop_log = now
 
         key_t = threading.Thread(target=key_reader, daemon=True)
         writer_t = threading.Thread(target=writer_fn, daemon=True)
@@ -197,9 +328,9 @@ class Recorder:
                 except queue.Empty:
                     continue
                 if evt == "SPACE":
-                    audio_q.put(("split", None))
+                    ctrl_q.put("split")
                 elif evt == "ENTER":
-                    audio_q.put(("finish", None))
+                    ctrl_q.put("finish")
                     break
         writer_t.join()
         return chunk_paths, chunk_frames, chunk_offsets

s2t/translator/__init__.py

@@ -0,0 +1,9 @@
+from __future__ import annotations
+
+from .argos_backend import ArgosTranslator, ensure_packages_background, translate_result_segments
+
+__all__ = [
+    "ArgosTranslator",
+    "ensure_packages_background",
+    "translate_result_segments",
+]

s2t/translator/argos_backend.py

@@ -0,0 +1,472 @@
+from __future__ import annotations
+
+import os
+import platform
+import threading
+import time
+from collections.abc import Iterable
+from pathlib import Path
+
+from ..types import SegmentDict, TranscriptionResult
+
+# Global install coordination to avoid duplicate downloads in parallel
+_install_lock = threading.Lock()
+_inflight: dict[tuple[str, str], threading.Event] = {}
+
+
+class ArgosTranslator:
+    """Thin wrapper around argostranslate for install + translate.
+
+    This module performs automatic package installation (network required once)
+    and then translates text fully offline.
+    """
+
+    def __init__(self, verbose: bool = False) -> None:
+        self.verbose = verbose
+
+    def _debug(self, msg: str) -> None:
+        if self.verbose:
+            print(msg)
+
+    @staticmethod
+    def _guess_packages_dir() -> str:
+        try:
+            system = platform.system().lower()
+            home = Path.home()
+            candidates: list[Path] = []
+            if system == "darwin":
+                candidates.append(
+                    home / "Library" / "Application Support" / "argos-translate" / "packages"
+                )
+                candidates.append(home / ".local" / "share" / "argos-translate" / "packages")
+            elif system == "windows":
+                appdata = os.environ.get("APPDATA") or str(home / "AppData" / "Roaming")
+                localapp = os.environ.get("LOCALAPPDATA") or str(home / "AppData" / "Local")
+                candidates.append(Path(appdata) / "argos-translate" / "packages")
+                candidates.append(Path(localapp) / "argos-translate" / "packages")
+            else:
+                candidates.append(home / ".local" / "share" / "argos-translate" / "packages")
+            for p in candidates:
+                if p.exists():
+                    return str(p)
+            return str(candidates[0]) if candidates else "(unknown)"
+        except Exception as e:
+            return f"(unknown: {type(e).__name__}: {e})"
+
+    def ensure_package(self, src_lang: str, dst_lang: str) -> bool:
+        """Ensure Argos package for src->dst is installed. Returns True if ready.
+
+        Attempts to install automatically if missing.
+        """
+        try:
+            # Avoid importing unless needed so users without argostranslate can still run ASR-only.
+            import argostranslate.package as argos_pkg
+        except Exception:  # pragma: no cover - external dep
+            # Keep core tool functional if argostranslate is not present
+            self._debug(
+                "Argos: argostranslate not installed; cannot auto-install translation packages."
+            )
+            return False
+
+        src = src_lang.lower()
+        dst = dst_lang.lower()
+        if src == dst:
+            return True
+
+        # Fast path: already installed (direct or pivot path)
+        if self.has_package(src, dst):
+            return True
+
+        # Coordinate installs to avoid duplicate downloads across threads
+        pair = (src, dst)
+        with _install_lock:
+            ev = _inflight.get(pair)
+            if ev is None:
+                ev = threading.Event()
+                _inflight[pair] = ev
+                starter = True
+            else:
+                starter = False
+
+        if not starter:
+            # Another thread is installing this pair; wait for completion
+            if self.verbose:
+                self._debug(f"Argos: waiting for ongoing install {src}->{dst} to finish…")
+            ev.wait(timeout=600.0)
+            return self.has_package(src, dst)
+
+        try:
+            # We are the installer for this pair
+            packages_dir = self._guess_packages_dir()
+
+            # Update package index once per install attempt
+            try:
+                if self.verbose:
+                    self._debug("Argos: updating package index…")
+                argos_pkg.update_package_index()
+            except Exception as e_upd:
+                if self.verbose:
+                    self._debug(
+                        f"Argos: update_package_index failed: {type(e_upd).__name__}: {e_upd}"
+                    )
+
+            available = []
+            try:
+                available = argos_pkg.get_available_packages()
+            except Exception as e_av:
+                if self.verbose:
+                    self._debug(
+                        f"Argos: get_available_packages failed: {type(e_av).__name__}: {e_av}"
+                    )
+
+            # Attempt direct first
+            cand = next(
+                (
+                    p
+                    for p in available
+                    if getattr(p, 'from_code', None) == src and getattr(p, 'to_code', None) == dst
+                ),
+                None,
+            )
+            if cand is not None:
+                if self.verbose:
+                    self._debug(
+                        f"Argos: downloading package {src}->{dst} -> install into {packages_dir}"
+                    )
+                try:
+                    path = cand.download()
+                    if self.verbose:
+                        self._debug(f"Argos: downloaded file for {src}->{dst}: {path}")
+                    argos_pkg.install_from_path(path)
+                    if self.verbose:
+                        self._debug(f"Argos: installed package {src}->{dst}")
+                except Exception as e_dir:
+                    if self.verbose:
+                        self._debug(
+                            f"Argos: install {src}->{dst} failed: {type(e_dir).__name__}: {e_dir}"
+                        )
+
+            # If still not available, try pivot via English
+            if not self.has_package(src, dst):
+                pivot = "en"
+                if self.verbose:
+                    self._debug(
+                        f"Argos: no direct package {src}->{dst} in index; trying pivot via {pivot} [{src}->{pivot}, {pivot}->{dst}]"
+                    )
+                cand1 = next(
+                    (
+                        p
+                        for p in available
+                        if getattr(p, 'from_code', None) == src
+                        and getattr(p, 'to_code', None) == pivot
+                    ),
+                    None,
+                )
+                cand2 = next(
+                    (
+                        p
+                        for p in available
+                        if getattr(p, 'from_code', None) == pivot
+                        and getattr(p, 'to_code', None) == dst
+                    ),
+                    None,
+                )
+                if cand1 is None and cand2 is None and self.verbose:
+                    self._debug(
+                        f"Argos: no direct or pivot packages available for {src}->{dst} in index"
+                    )
+                if cand1 is not None:
+                    # coordinate concrete edge (src->pivot)
+                    edge = (src, pivot)
+                    with _install_lock:
+                        ev_edge = _inflight.get(edge)
+                        if ev_edge is None:
+                            ev_edge = threading.Event()
+                            _inflight[edge] = ev_edge
+                            edge_starter = True
+                        else:
+                            edge_starter = False
+                    if not edge_starter:
+                        if self.verbose:
+                            self._debug(
+                                f"Argos: waiting for ongoing install {src}->{pivot} to finish…"
+                            )
+                        ev_edge.wait(timeout=600.0)
+                    else:
+                        try:
+                            if self.verbose:
+                                self._debug(
+                                    f"Argos: downloading package {src}->{pivot} -> install into {packages_dir}"
+                                )
+                            path1 = cand1.download()
+                            if self.verbose:
+                                self._debug(f"Argos: downloaded file for {src}->{pivot}: {path1}")
+                            argos_pkg.install_from_path(path1)
+                            if self.verbose:
+                                self._debug(f"Argos: installed package {src}->{pivot}")
+                        except Exception as e1:
+                            if self.verbose:
+                                self._debug(
+                                    f"Argos: install {src}->{pivot} failed: {type(e1).__name__}: {e1}"
+                                )
+                        finally:
+                            with _install_lock:
+                                ev_done = _inflight.get(edge)
+                                if ev_done is not None:
+                                    ev_done.set()
+                                    _inflight.pop(edge, None)
+                if cand2 is not None:
+                    # coordinate concrete edge (pivot->dst)
+                    edge = (pivot, dst)
+                    with _install_lock:
+                        ev_edge = _inflight.get(edge)
+                        if ev_edge is None:
+                            ev_edge = threading.Event()
+                            _inflight[edge] = ev_edge
+                            edge_starter = True
+                        else:
+                            edge_starter = False
+                    if not edge_starter:
+                        if self.verbose:
+                            self._debug(
+                                f"Argos: waiting for ongoing install {pivot}->{dst} to finish…"
+                            )
+                        ev_edge.wait(timeout=600.0)
+                    else:
+                        try:
+                            if self.verbose:
+                                self._debug(
+                                    f"Argos: downloading package {pivot}->{dst} -> install into {packages_dir}"
+                                )
+                            path2 = cand2.download()
+                            if self.verbose:
+                                self._debug(f"Argos: downloaded file for {pivot}->{dst}: {path2}")
+                            argos_pkg.install_from_path(path2)
+                            if self.verbose:
+                                self._debug(f"Argos: installed package {pivot}->{dst}")
+                        except Exception as e2:
+                            if self.verbose:
+                                self._debug(
+                                    f"Argos: install {pivot}->{dst} failed: {type(e2).__name__}: {e2}"
+                                )
+                        finally:
+                            with _install_lock:
+                                ev_done = _inflight.get(edge)
+                                if ev_done is not None:
+                                    ev_done.set()
+                                    _inflight.pop(edge, None)
+
+            # Final check (direct or pivot should now be available)
+            return self.has_package(src, dst)
+        finally:
+            with _install_lock:
+                ev = _inflight.get(pair)
+                if ev is not None:
+                    ev.set()
+                    _inflight.pop(pair, None)
+
+    def translate_texts(self, texts: Iterable[str], src_lang: str, dst_lang: str) -> list[str]:
+        import argostranslate.translate as argos_tr
+
+        src = src_lang.lower()
+        dst = dst_lang.lower()
+        installed = argos_tr.get_installed_languages()
+        src_lang_obj = next((lang for lang in installed if getattr(lang, "code", "") == src), None)
+        dst_lang_obj = next((lang for lang in installed if getattr(lang, "code", "") == dst), None)
+        if not (src_lang_obj and dst_lang_obj):
+            raise RuntimeError(
+                f"Argos package not installed for {src}->{dst}. Installation should have been attempted earlier."
+            )
+
+        # Try direct translation first
+        t_direct = None
+        try:
+            t_direct = src_lang_obj.get_translation(dst_lang_obj)
+        except Exception:
+            t_direct = None
+
+        if t_direct is not None:
+            out: list[str] = []
+            for s in texts:
+                out.append(t_direct.translate(s or ""))
+            return out
+
+        # Fallback: pivot via English if both edges exist
+        pivot_code = "en"
+        pivot_lang_obj = next(
+            (lang for lang in installed if getattr(lang, "code", "") == pivot_code), None
+        )
+        if pivot_lang_obj is None:
+            raise RuntimeError(
+                f"Argos package not installed for {src}->{dst} and no pivot via {pivot_code} available."
+            )
+        try:
+            t_src_pivot = src_lang_obj.get_translation(pivot_lang_obj)
+            t_pivot_dst = pivot_lang_obj.get_translation(dst_lang_obj)
+        except Exception as e:
+            raise RuntimeError(
+                f"Argos direct translator {src}->{dst} missing and cannot pivot via {pivot_code}: {e}"
+            ) from e
+
+        if self.verbose:
+            packages_dir = self._guess_packages_dir()
+            self._debug(
+                f"Argos: using pivot via {pivot_code} (packages dir: {packages_dir}) for {src}->{dst}"
+            )
+        # First hop src->pivot, then pivot->dst
+        mid: list[str] = []
+        for s in texts:
+            mid.append(t_src_pivot.translate(s or ""))
+        out2: list[str] = []
+        for m in mid:
+            out2.append(t_pivot_dst.translate(m or ""))
+        return out2
+
+    def has_package(self, src_lang: str, dst_lang: str) -> bool:
+        """Return True if a translation from src->dst is currently installed."""
+        try:
+            import argostranslate.translate as argos_tr
+
+            src = src_lang.lower()
+            dst = dst_lang.lower()
+            installed = argos_tr.get_installed_languages()
+            src_lang_obj = next(
+                (lang for lang in installed if getattr(lang, "code", "") == src), None
+            )
+            dst_lang_obj = next(
+                (lang for lang in installed if getattr(lang, "code", "") == dst), None
+            )
+            if not (src_lang_obj and dst_lang_obj):
+                return False
+            # True if direct exists or if a pivot path via 'en' exists
+            try:
+                _ = src_lang_obj.get_translation(dst_lang_obj)
+                return True
+            except Exception:
+                # Check pivot path
+                pivot_code = "en"
+                pivot_lang_obj = next(
+                    (lang for lang in installed if getattr(lang, "code", "") == pivot_code), None
+                )
+                if not pivot_lang_obj:
+                    return False
+                try:
+                    _ = src_lang_obj.get_translation(pivot_lang_obj)
+                    _ = pivot_lang_obj.get_translation(dst_lang_obj)
+                    return True
+                except Exception:
+                    return False
+        except Exception:
+            return False
+
+
+def ensure_packages_background(
+    translator: ArgosTranslator,
+    src_lang_hint: str | None,
+    target_langs: list[str],
+    detected_lang_event: threading.Event | None = None,
+    detected_lang_holder: dict[str, str | None] | None = None,
+) -> None:
+    """Start background thread to ensure Argos packages exist.
+
+    - If src_lang_hint is provided, install immediately for that source.
+    - Otherwise, wait for detected_lang_event to fire and then install for the detected source.
+    """
+
+    def _runner() -> None:
+        # First, try to update index early to avoid later blocking.
+        try:
+            import argostranslate.package as argos_pkg
+
+            argos_pkg.update_package_index()
+        except Exception:
+            # offline is OK; will skip install later
+            pass
+
+        src = (src_lang_hint or "").strip().lower()
+        if not src:
+            if detected_lang_event is not None and detected_lang_holder is not None:
+                detected_lang_event.wait(timeout=300.0)
+                src = (detected_lang_holder.get("code") or "").strip().lower()
+        if not src:
+            # Could not determine source language; give up silently
+            return
+        for tgt in dict.fromkeys([t.lower() for t in target_langs if t]):
+            if tgt == src:
+                continue
+            try:
+                translator.ensure_package(src, tgt)
+            except Exception:
+                # swallow background errors
+                pass
+
+    t = threading.Thread(target=_runner, daemon=True)
+    t.start()
+
+
+def translate_result_segments(
+    translator: ArgosTranslator,
+    result: TranscriptionResult,
+    src_lang: str,
+    dst_lang: str,
+) -> TranscriptionResult:
+    """Translate a merged TranscriptionResult segment-wise, preserving timing.
+
+    Returns a new TranscriptionResult with translated text and segments.
+    """
+    segs = result.get("segments", []) or []
+    if segs:
+        orig_texts: list[str] = [str(s.get("text") or "") for s in segs]
+        translated = translator.translate_texts(orig_texts, src_lang, dst_lang)
+        new_segs: list[SegmentDict] = []
+        for s, tt in zip(segs, translated, strict=False):
+            seg_out: SegmentDict = {}
+            if "start" in s:
+                seg_out["start"] = float(s["start"])  # s['start'] is float in SegmentDict
+            if "end" in s:
+                seg_out["end"] = float(s["end"])  # s['end'] is float in SegmentDict
+            seg_out["text"] = str(tt)
+            new_segs.append(seg_out)
+        joined_text = "".join([str(s.get("text", "")) for s in new_segs])
+        return {"text": joined_text, "segments": new_segs}
+    # Fallback: no segments, translate whole text
+    whole = result.get("text", "")
+    tt = translator.translate_texts([whole], src_lang, dst_lang)[0]
+    return {"text": tt, "segments": []}
+
+
+def wait_for_packages(
+    translator: ArgosTranslator,
+    src_lang: str,
+    targets: list[str],
+    max_wait_s: float = 120.0,
+    verbose: bool = False,
+) -> set[str]:
+    """Wait until required packages are installed or timeout expires.
+
+    Returns the set of target codes that are ready. This function polls the
+    translator for installed status, while a background installer may be running.
+    """
+    start = time.perf_counter()
+    ready: set[str] = set()
+    targets_norm = [t.lower() for t in targets]
+
+    while True:
+        for t in targets_norm:
+            if t in ready:
+                continue
+            if translator.has_package(src_lang, t):
+                ready.add(t)
+        if set(targets_norm) == ready:
+            break
+        elapsed = time.perf_counter() - start
+        if elapsed >= max_wait_s:
+            break
+        if verbose:
+            pending = ", ".join(sorted(set(targets_norm) - ready))
+            print(
+                f"Waiting for Argos packages ({src_lang}->[{pending}])… {int(elapsed)}s",
+                flush=True,
+            )
+        time.sleep(1.0)
+    return ready

s2t/types.py

@@ -9,6 +9,8 @@ class SegmentDict(TypedDict, total=False):
     text: str
 
 
-class TranscriptionResult(TypedDict):
+class TranscriptionResult(TypedDict, total=False):
     text: str
     segments: list[SegmentDict]
+    # Optional: Whisper-detected language code (e.g., 'de', 'en')
+    language: str

s2t/whisper_engine.py

@@ -111,6 +111,7 @@ class WhisperEngine:
         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()
+        lang_code = str(res.get("language", "") or "")
         if self.native_segmentation:
             segs_raw = res.get("segments", []) or []
             segs_typed: list[SegmentDict] = []
@@ -122,15 +123,21 @@ class WhisperEngine:
                     segs_typed.append({"start": start, "end": end, "text": text})
                 except Exception:
                     continue
-            return {"text": text_c, "segments": segs_typed}
+            out: TranscriptionResult = {"text": text_c, "segments": segs_typed}
+            if lang_code:
+                out["language"] = lang_code
+            return out
         # 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 {
+        out2: TranscriptionResult = {
             "text": text_c,
             "segments": ([{"start": start, "end": end, "text": text_c}] if text_c else []),
         }
+        if lang_code:
+            out2["language"] = lang_code
+        return out2
 
     def write_chunk_outputs(self, result: TranscriptionResult, audio_path: Path) -> None:
         try:

{s2t-0.1.2.dist-info → s2t-0.1.3.post1.dev1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: s2t
-Version: 0.1.2
+Version: 0.1.3.post1.dev1
 Summary: Speech to Text (s2t): Record audio, run Whisper, export formats, and copy transcript to clipboard.
 Author: Maintainers
 License-Expression: LicenseRef-Proprietary
@@ -23,6 +23,8 @@ 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"
+Provides-Extra: translate
+Requires-Dist: argostranslate>=1.9.0; extra == "translate"
 
 # s2t
 

s2t-0.1.3.post1.dev1.dist-info/RECORD

@@ -0,0 +1,16 @@
+s2t/__init__.py,sha256=wV4E9i-7KrUn1dOtLUQB3ZGEKx9gRWH3hPHlpw-ZdWc,332
+s2t/cli.py,sha256=Qf6Hz0Ew9ncLbQQoCPDG7ZiYWeGbwBcZMZi_WbEu54w,20018
+s2t/config.py,sha256=lFc_x5fIx_q0JpTcI4Lm4aubxhIXVH34foBvLMUNFGs,437
+s2t/outputs.py,sha256=Lo8VcARZ7QPuuQQNu8myD5J4c4NO1Rs0L1DLnzLe9tM,1546
+s2t/py.typed,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+s2t/recorder.py,sha256=0sw1UJqQIRdiJO5dugUxRjTN5kFU0CBETVjoQz99a8E,16055
+s2t/types.py,sha256=jBiRN-tr0qVw-lhaXvnsyKrVGDyLkqEbxs9qkQ6qGqI,339
+s2t/utils.py,sha256=YU6YhiuONmqhrKte4DY5tiC5PP-yFExJMMBzFUiA8qA,3416
+s2t/whisper_engine.py,sha256=x-V7ST9e3JnwMWdbMh4C7dHjA420jaOtXH2-igeh7vc,6492
+s2t/translator/__init__.py,sha256=K-MKves7kZ4-62POfrmWeOcBaTjsTzeFSu8QNHqYuus,239
+s2t/translator/argos_backend.py,sha256=VW_OYFFBuNZgcWM-fbvR6XGokuxS2fptkCMFIO9MD1I,19068
+s2t-0.1.3.post1.dev1.dist-info/METADATA,sha256=zSKU9KAPs8fX1KTZF3WNLnz3FaqxWHecCrV5SE6JsEA,4653
+s2t-0.1.3.post1.dev1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+s2t-0.1.3.post1.dev1.dist-info/entry_points.txt,sha256=JISIUlZAJ3DX1dB6zT3X_E3vcXI-eWEQKwHiT35fPKs,37
+s2t-0.1.3.post1.dev1.dist-info/top_level.txt,sha256=o8N0JcuHdIrfX3iGHvntHiDC2XgN7__joyNu08ZOh0s,4
+s2t-0.1.3.post1.dev1.dist-info/RECORD,,

s2t-0.1.2.dist-info/RECORD

@@ -1,14 +0,0 @@
-s2t/__init__.py,sha256=wV4E9i-7KrUn1dOtLUQB3ZGEKx9gRWH3hPHlpw-ZdWc,332
-s2t/cli.py,sha256=_7zIhcdI7DI_3Dxs2EcvQkE-fSGclkJ2TjCvDYlI65E,15871
-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=Y7kTYnB-LtsVj2KvF60VcI37MNAVfmMcGSJMMxFyZgA,6220
-s2t-0.1.2.dist-info/METADATA,sha256=YPufi9Xb9aqCARVeRkzrDQ_b2UNi7Pkq1dJAJ7vkr68,4557
-s2t-0.1.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-s2t-0.1.2.dist-info/entry_points.txt,sha256=JISIUlZAJ3DX1dB6zT3X_E3vcXI-eWEQKwHiT35fPKs,37
-s2t-0.1.2.dist-info/top_level.txt,sha256=o8N0JcuHdIrfX3iGHvntHiDC2XgN7__joyNu08ZOh0s,4
-s2t-0.1.2.dist-info/RECORD,,