vocalize-cli 0.2.0__tar.gz → 0.2.1__tar.gz

{vocalize_cli-0.2.0 → vocalize_cli-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: vocalize-cli
-Version: 0.2.0
+Version: 0.2.1
 Summary: A CLI that turns text, markdown, or piped stdin into speech via the ElevenLabs API, with markdown-table-aware preprocessing.
 Project-URL: Homepage, https://github.com/matthager12-collab/vocalize
 Project-URL: Repository, https://github.com/matthager12-collab/vocalize
@@ -133,7 +133,8 @@ the highlighted one), model, and speed — shows you a summary, and writes the
 config file below. Unrecognised top-level keys already in that file are
 carried through; comments and layout are not preserved. A file containing a
 TOML table or array is left alone entirely, with a message saying to edit it
-by hand.
+by hand. The wizard paints on the controlling terminal rather than on stdout,
+so it still works under output-capturing wrappers like `op run`.
 
 ```bash
 vocalize config

{vocalize_cli-0.2.0 → vocalize_cli-0.2.1}/README.md

@@ -100,7 +100,8 @@ the highlighted one), model, and speed — shows you a summary, and writes the
 config file below. Unrecognised top-level keys already in that file are
 carried through; comments and layout are not preserved. A file containing a
 TOML table or array is left alone entirely, with a message saying to edit it
-by hand.
+by hand. The wizard paints on the controlling terminal rather than on stdout,
+so it still works under output-capturing wrappers like `op run`.
 
 ```bash
 vocalize config

{vocalize_cli-0.2.0 → vocalize_cli-0.2.1}/tests/test_wizard.py

@@ -1,3 +1,4 @@
+import io
 import sys
 from types import SimpleNamespace
 
@@ -27,6 +28,17 @@ class FakeStdin:
         return self._tty
 
 
+class FakeTTY(io.StringIO):
+    """A /dev/tty stand-in that stays readable after the wizard closes it."""
+
+    def __init__(self):
+        super().__init__()
+        self.closed_by_wizard = False
+
+    def close(self):
+        self.closed_by_wizard = True
+
+
 class Keyboard:
     """A scripted keyboard: each getchar() call returns the next key."""
 
@@ -42,8 +54,22 @@ class Keyboard:
         return key
 
 
-def _setup(monkeypatch, tmp_path, keys, *, voices=None, prompts=(), confirm=True, api_key="fake-key"):
-    """Point the wizard at a throwaway config file and a scripted keyboard."""
+def _setup(
+    monkeypatch,
+    tmp_path,
+    keys,
+    *,
+    voices=None,
+    prompts=(),
+    confirm=True,
+    api_key="fake-key",
+    patch_ui=True,
+):
+    """Point the wizard at a throwaway config file and a scripted keyboard.
+
+    patch_ui=True aims the wizard's UI stream at sys.stdout, so capsys sees
+    the frames; the tty-seam tests pass False and drive the real factory.
+    """
     monkeypatch.setenv("XDG_CONFIG_HOME", str(tmp_path / "config"))
     for var in ("VOCALIZE_VOICE", "VOCALIZE_MODEL", "VOCALIZE_SPEED"):
         monkeypatch.delenv(var, raising=False)
@@ -51,19 +77,21 @@ def _setup(monkeypatch, tmp_path, keys, *, voices=None, prompts=(), confirm=True
     monkeypatch.setenv("LINES", "40")
 
     monkeypatch.setattr(sys, "stdin", FakeStdin(tty=True))
-    monkeypatch.setattr(click, "clear", lambda: None)
+    if patch_ui:
+        # Resolved lazily: sys.stdout is whatever capsys has installed.
+        monkeypatch.setattr(wizard, "_open_ui_stream", lambda: (sys.stdout, False))
     keyboard = Keyboard(keys)
     monkeypatch.setattr(click, "getchar", keyboard)
 
     answers = list(prompts)
 
-    def fake_prompt(text, **kwargs):
+    def fake_ask(ui, label, **kwargs):
         if not answers:
-            raise AssertionError(f"unexpected prompt: {text}")
+            raise AssertionError(f"unexpected prompt: {label}")
         return answers.pop(0)
 
-    monkeypatch.setattr(click, "prompt", fake_prompt)
-    monkeypatch.setattr(click, "confirm", lambda *args, **kwargs: confirm)
+    monkeypatch.setattr(wizard, "_ask", fake_ask)
+    monkeypatch.setattr(wizard, "_confirm", lambda *args, **kwargs: confirm)
 
     if api_key is None:
 
@@ -282,6 +310,64 @@ def test_keep_current_names_the_file_value_not_the_env_var(monkeypatch, tmp_path
     assert ctx.path.read_text() == 'voice = "from-the-file"\n'
 
 
+def _piped(monkeypatch):
+    """stdout relayed down a pipe (`op run`), with /dev/tty still openable."""
+    tty = FakeTTY()
+    monkeypatch.setattr(sys, "stdout", io.StringIO())
+    monkeypatch.setattr(wizard, "_open_tty", lambda: tty)
+    assert not sys.stdout.isatty()
+    return tty
+
+
+def test_piped_stdout_paints_to_dev_tty(monkeypatch, tmp_path):
+    keys = [DOWN, ENTER, DOWN, ENTER, DOWN, DOWN, DOWN, DOWN, ENTER]
+    ctx = _setup(monkeypatch, tmp_path, keys, patch_ui=False)
+    tty = _piped(monkeypatch)
+
+    wizard.run_wizard()  # not refused: the keyboard and /dev/tty are both there
+
+    painted = tty.getvalue()
+    assert "\x1b[2J\x1b[H" in painted  # our own clear; click.clear() would no-op
+    assert "Step 1 of 3 — Voice" in painted
+    assert "Step 2 of 3 — Model" in painted
+    assert "Step 3 of 3 — Speed" in painted
+    assert wizard.VOICE_HOTKEYS in painted
+    assert "About to write:" in painted
+    # None of it went down the pipe, and the stream we opened got closed
+    assert "Step 1 of 3 — Voice" not in sys.stdout.getvalue()
+    assert tty.closed_by_wizard
+    assert ctx.path.read_text() == (
+        'voice = "abc123"\n'
+        'model = "eleven_flash_v2_5"\n'
+        "speed = 0.9\n"
+    )
+
+
+def test_headless_still_refused(monkeypatch, tmp_path):
+    monkeypatch.setenv("XDG_CONFIG_HOME", str(tmp_path / "config"))
+    monkeypatch.setattr(sys, "stdin", FakeStdin(tty=False))
+    opened = []
+    monkeypatch.setattr(wizard, "_open_tty", lambda: opened.append(True))
+
+    with pytest.raises(ConfigError, match="interactive terminal"):
+        wizard.run_wizard()
+
+    assert opened == []  # a dead stdin is decided on its own, before any tty
+    assert not (tmp_path / "config" / "vocalize" / "config.toml").exists()
+
+
+def test_confirmation_line_reaches_stdout_too(monkeypatch, tmp_path):
+    keys = [DOWN, ENTER, DOWN, ENTER, DOWN, DOWN, DOWN, DOWN, ENTER]
+    ctx = _setup(monkeypatch, tmp_path, keys, patch_ui=False)
+    tty = _piped(monkeypatch)
+
+    wizard.run_wizard()
+
+    assert f"Wrote {ctx.path}" in tty.getvalue()
+    # Wrappers and logs only capture stdout, so the outcome has to land there
+    assert sys.stdout.getvalue().strip() == f"Wrote {ctx.path}"
+
+
 def test_the_current_voice_starts_under_the_cursor(monkeypatch, tmp_path, capsys):
     ctx = _setup(monkeypatch, tmp_path, [ENTER, ENTER, ENTER])
     monkeypatch.setenv("VOCALIZE_VOICE", "def456")  # after _setup, which clears it

{vocalize_cli-0.2.0 → vocalize_cli-0.2.1}/vocalize/__init__.py

@@ -7,4 +7,4 @@ formatting into something that actually sounds good spoken aloud
 which is close to useless).
 """
 
-__version__ = "0.2.0"
+__version__ = "0.2.1"

{vocalize_cli-0.2.0 → vocalize_cli-0.2.1}/vocalize/wizard.py

@@ -4,6 +4,13 @@ Three steps — voice, model, speed — each a keyboard-driven list rendered
 with click.echo and driven by click.getchar(). click is already a
 dependency, so this needs no curses, prompt_toolkit, or anything else.
 
+Every frame is painted on the controlling terminal rather than on
+stdout. Wrappers that relay a child's output — `op run`, the documented
+way this project injects its API key — leave sys.stdout non-tty while
+the keyboard still works, which makes click.clear() a no-op and lets the
+relay's writes land in the middle of a raw-mode read. Painting at
+/dev/tty sidesteps both.
+
 This module owns the *interaction* only. Every default, bound, and
 validation rule still comes from vocalize.config, and the voice list and
 previews go through the same tts/audio functions the rest of the CLI
@@ -61,15 +68,61 @@ _CHROME_LINES = 8
 _KEEP = object()
 _UNSET = object()
 
+_NO_TERMINAL = (
+    "The config wizard needs an interactive terminal. "
+    "Run `vocalize config` in a terminal, not from a pipe or a script."
+)
+
 
 class _Cancelled(Exception):
     """Raised inside a step on q, Escape, or EOF."""
 
 
-def _render(title: str, rows: list, cursor: int, legend: str, notes: list) -> None:
-    click.clear()
-    click.echo(title)
-    click.echo()
+def _open_tty():
+    """The controlling terminal as a writable stream, or None."""
+    try:
+        return open("/dev/tty", "w", encoding="utf-8")
+    except OSError:
+        return None
+
+
+def _open_ui_stream():
+    """Where to paint the wizard: (stream, did_we_open_it).
+
+    Returns (None, False) when there's no terminal to paint on at all.
+    """
+    stdout = sys.stdout
+    if stdout is not None and stdout.isatty():
+        return stdout, False
+    tty = _open_tty()
+    return (tty, True) if tty is not None else (None, False)
+
+
+def _clear(ui) -> None:
+    # click.clear() only ever writes to stdout, and no-ops when stdout
+    # isn't a tty — which is the whole case this wizard has to survive.
+    ui.write("\x1b[2J\x1b[H")
+    ui.flush()
+
+
+def _ask(ui, label: str) -> str:
+    """Read one typed line. The tty driver echoes the typing itself."""
+    click.echo(f"{label}: ", file=ui, nl=False)
+    try:
+        return input()
+    except (EOFError, KeyboardInterrupt):
+        return ""
+
+
+def _confirm(ui, label: str) -> bool:
+    """Default no: an empty answer, or an EOF, must not write the file."""
+    return _ask(ui, f"{label} [y/N]").strip().lower() in ("y", "yes")
+
+
+def _render(ui, title: str, rows: list, cursor: int, legend: str, notes: list) -> None:
+    _clear(ui)
+    click.echo(title, file=ui)
+    click.echo(file=ui)
 
     # A full ElevenLabs voice list is longer than an 80x24 terminal, so the
     # list is windowed onto the cursor rather than echoed whole — otherwise
@@ -79,21 +132,21 @@ def _render(title: str, rows: list, cursor: int, legend: str, notes: list) -> No
     end = min(start + height, len(rows))
 
     if start > 0:
-        click.echo("  …")
+        click.echo("  …", file=ui)
     for index in range(start, end):
-        click.echo(f"{'>' if index == cursor else ' '} {rows[index][1]}")
+        click.echo(f"{'>' if index == cursor else ' '} {rows[index][1]}", file=ui)
     if end < len(rows):
-        click.echo("  …")
+        click.echo("  …", file=ui)
 
-    click.echo()
+    click.echo(file=ui)
     if notes:
         for note in notes:
-            click.echo(note)
-        click.echo()
-    click.echo(legend)
+            click.echo(note, file=ui)
+        click.echo(file=ui)
+    click.echo(legend, file=ui)
 
 
-def _select(title, rows, cursor, *, legend=HOTKEYS, notes=(), manual=None, preview=None):
+def _select(ui, title, rows, cursor, *, legend=HOTKEYS, notes=(), manual=None, preview=None):
     """Run one step of the wizard and return the chosen row value.
 
     `manual` and `preview` are callables for the m and p hotkeys; either
@@ -103,7 +156,7 @@ def _select(title, rows, cursor, *, legend=HOTKEYS, notes=(), manual=None, previ
     status = None
 
     while True:
-        _render(title, rows, cursor, legend, notes + ([status] if status else []))
+        _render(ui, title, rows, cursor, legend, notes + ([status] if status else []))
         key = click.getchar()
 
         # An empty read means EOF (a closed pty). It matches no key set, so
@@ -126,22 +179,21 @@ def _select(title, rows, cursor, *, legend=HOTKEYS, notes=(), manual=None, previ
             status = preview(rows[cursor][0])
 
 
-def _manual_text(label: str) -> str | None:
+def _manual_text(ui, label: str) -> str | None:
     """Type a value by hand. An empty answer means 'never mind'."""
-    value = click.prompt(label, default="", show_default=False).strip()
-    return value or None
+    return _ask(ui, label).strip() or None
 
 
-def _manual_speed() -> float | None:
+def _manual_speed(ui) -> float | None:
     """Type a speed by hand, re-asking until it passes the config check."""
     while True:
-        raw = click.prompt(f"Speed ({SPEED_MIN}–{SPEED_MAX})", default="", show_default=False).strip()
+        raw = _ask(ui, f"Speed ({SPEED_MIN}–{SPEED_MAX})").strip()
         if not raw:
             return None
         try:
             return validate_speed(raw, "manual entry")
         except ConfigError as exc:
-            click.echo(str(exc))
+            click.echo(str(exc), file=ui)
 
 
 def _speed_choices() -> list[float]:
@@ -163,7 +215,7 @@ def _keep_label(existing: dict, key: str, resolved) -> str:
     return f"{resolved} — not in the file"
 
 
-def _voice_step(current: str, keep: str):
+def _voice_step(ui, current: str, keep: str):
     rows = [(_KEEP, f"keep current ({keep})")]
     cursor = 0
     notes = []
@@ -194,7 +246,7 @@ def _voice_step(current: str, keep: str):
             return "Preview needs an API key."
         # Synthesis and playback both block; say so, or the frozen frame
         # reads as a hang.
-        click.echo(f"Previewing {voice_id}…")
+        click.echo(f"Previewing {voice_id}…", file=ui)
         try:
             play(save(synthesize(client, PREVIEW_TEXT, Settings(voice_id=voice_id)), PREVIEW_PATH))
         except VocalizeError as exc:
@@ -202,17 +254,18 @@ def _voice_step(current: str, keep: str):
         return f"Previewed {voice_id}."
 
     return _select(
+        ui,
         "Step 1 of 3 — Voice",
         rows,
         cursor,
         legend=VOICE_HOTKEYS,
         notes=notes,
-        manual=lambda: _manual_text("Voice ID"),
+        manual=lambda: _manual_text(ui, "Voice ID"),
         preview=preview,
     )
 
 
-def _model_step(current: str, keep: str):
+def _model_step(ui, current: str, keep: str):
     rows = [(_KEEP, f"keep current ({keep})")]
     cursor = 0
 
@@ -224,14 +277,15 @@ def _model_step(current: str, keep: str):
         rows.append((model_id, label))
 
     return _select(
+        ui,
         "Step 2 of 3 — Model",
         rows,
         cursor,
-        manual=lambda: _manual_text("Model ID"),
+        manual=lambda: _manual_text(ui, "Model ID"),
     )
 
 
-def _speed_step(current: float | None, keep: str):
+def _speed_step(ui, current: float | None, keep: str):
     rows = [(_KEEP, f"keep current ({keep})"), (_UNSET, "unset (API default)")]
     cursor = 0
 
@@ -242,7 +296,7 @@ def _speed_step(current: float | None, keep: str):
             cursor = len(rows)
         rows.append((value, label))
 
-    return _select("Step 3 of 3 — Speed", rows, cursor, manual=_manual_speed)
+    return _select(ui, "Step 3 of 3 — Speed", rows, cursor, manual=lambda: _manual_speed(ui))
 
 
 def _toml_value(key: str, value) -> str:
@@ -287,11 +341,21 @@ def run_wizard() -> None:
     """Walk through voice, model and speed, then write the config file."""
     stdin = sys.stdin
     if stdin is None or not stdin.isatty():
-        raise ConfigError(
-            "The config wizard needs an interactive terminal. "
-            "Run `vocalize config` in a terminal, not from a pipe or a script."
-        )
+        raise ConfigError(_NO_TERMINAL)
+
+    # The keyboard is only half of it — there also has to be somewhere to
+    # paint. A relayed stdout is fine as long as /dev/tty opens.
+    ui, opened = _open_ui_stream()
+    if ui is None:
+        raise ConfigError(_NO_TERMINAL)
+    try:
+        _walk(ui)
+    finally:
+        if opened:
+            ui.close()
+
 
+def _walk(ui) -> None:
     path = config_path()
     existing = load_config_file()
     # Dry-run the serialiser before asking any questions: fail fast rather
@@ -315,12 +379,12 @@ def run_wizard() -> None:
 
     try:
         chosen = {
-            "voice": _voice_step(current.voice_id, keep["voice"]),
-            "model": _model_step(current.model_id, keep["model"]),
-            "speed": _speed_step(current.speed, keep["speed"]),
+            "voice": _voice_step(ui, current.voice_id, keep["voice"]),
+            "model": _model_step(ui, current.model_id, keep["model"]),
+            "speed": _speed_step(ui, current.speed, keep["speed"]),
         }
     except _Cancelled:
-        click.echo("Cancelled — nothing changed.")
+        click.echo("Cancelled — nothing changed.", file=ui)
         return
 
     data = dict(existing)  # unknown keys ride through untouched
@@ -332,20 +396,24 @@ def run_wizard() -> None:
         else:
             data[key] = value
 
-    click.clear()
-    click.echo("About to write:")
-    click.echo()
+    _clear(ui)
+    click.echo("About to write:", file=ui)
+    click.echo(file=ui)
     for key, value in chosen.items():
-        click.echo(f"  {key:<5} → {_summary_value(value, keep[key])}")
-    click.echo()
-    click.echo(f"File: {path}")
-    click.echo()
+        click.echo(f"  {key:<5} → {_summary_value(value, keep[key])}", file=ui)
+    click.echo(file=ui)
+    click.echo(f"File: {path}", file=ui)
+    click.echo(file=ui)
 
-    if not click.confirm("Write these settings?", default=False):
-        click.echo("Cancelled — nothing changed.")
+    if not _confirm(ui, "Write these settings?"):
+        click.echo("Cancelled — nothing changed.", file=ui)
         return
 
     text = _write_config(path, data)
-    click.echo(f"Wrote {path}")
-    click.echo()
-    click.echo(text.rstrip("\n") or "(empty — every setting is back to its default)")
+    click.echo(f"Wrote {path}", file=ui)
+    if ui is not sys.stdout:
+        # The outcome line is the one thing a wrapper or a log should still
+        # see when the UI went to the terminal instead of down the pipe.
+        click.echo(f"Wrote {path}", file=sys.stdout)
+    click.echo(file=ui)
+    click.echo(text.rstrip("\n") or "(empty — every setting is back to its default)", file=ui)