stackvox 0.8.0__tar.gz → 0.10.0__tar.gz

{stackvox-0.8.0/stackvox.egg-info → stackvox-0.10.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: stackvox
-Version: 0.8.0
+Version: 0.10.0
 Summary: Offline TTS library using Kokoro-82M
 Author-email: "StackOne Technologies Ltd." <support@stackone.com>
 License-Expression: Apache-2.0

{stackvox-0.8.0 → stackvox-0.10.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "stackvox"
-version = "0.8.0"
+version = "0.10.0"
 description = "Offline TTS library using Kokoro-82M"
 readme = "README.md"
 requires-python = ">=3.10"

{stackvox-0.8.0 → stackvox-0.10.0}/stackvox/cli.py

@@ -26,6 +26,7 @@ def _configure_logging() -> None:
 SUBCOMMANDS = {
     "serve",
     "stop",
+    "cancel",
     "status",
     "say",
     "speak",
@@ -51,7 +52,7 @@ _stackvox_completion() {
     subcommand="${COMP_WORDS[1]:-}"
 
     if [[ ${COMP_CWORD} -eq 1 ]]; then
-        COMPREPLY=( $(compgen -W "speak say normalize serve stop status voices welcome paths config completion install-helper" -- "$cur") )
+        COMPREPLY=( $(compgen -W "speak say normalize serve stop cancel status voices welcome paths config completion install-helper" -- "$cur") )
         return 0
     fi
 
@@ -155,6 +156,7 @@ def _build_parser(defaults: config.Defaults | None = None) -> argparse.ArgumentP
     _add_voice_args(p_serve, defaults)
 
     sub.add_parser("stop", help="Stop the running daemon")
+    sub.add_parser("cancel", help="Stop the current utterance without shutting down the daemon")
     sub.add_parser("status", help="Print daemon status")
     sub.add_parser("voices", help="List available voices")
     sub.add_parser("welcome", help="Play a multilingual welcome message")
@@ -388,10 +390,28 @@ def _cmd_stop(_: argparse.Namespace) -> int:
     return 0 if ok else 1
 
 
+def _cmd_cancel(_: argparse.Namespace) -> int:
+    # Interrupt the current utterance but leave the daemon running (no model
+    # reload). Nothing playing / no daemon is not an error.
+    if not daemon.is_running():
+        return 0
+    ok, _resp = daemon.cancel()
+    return 0 if ok else 1
+
+
 def _cmd_status(_: argparse.Namespace) -> int:
+    installed = updates._current_version()
     if daemon.is_running():
         print(f"running (pid {daemon.PID_PATH.read_text().strip()}) on {daemon.SOCKET_PATH}")
         rc = 0
+        # The running daemon can lag the installed package if it wasn't restarted
+        # after an upgrade — surface that skew instead of trusting it blindly.
+        got, running_version = daemon.version()
+        if got and running_version != installed:
+            print(
+                f"daemon running {running_version}, but {installed} is installed "
+                f"— restart the daemon (stackvox stop; stackvox serve) to pick it up"
+            )
     else:
         print("stopped")
         rc = 1
@@ -521,6 +541,7 @@ def main() -> int:
         "normalize": _cmd_normalize,
         "serve": _cmd_serve,
         "stop": _cmd_stop,
+        "cancel": _cmd_cancel,
         "status": _cmd_status,
         "voices": _cmd_voices,
         "welcome": _cmd_welcome,

{stackvox-0.8.0 → stackvox-0.10.0}/stackvox/daemon.py

@@ -5,8 +5,10 @@ Protocol: one JSON object per connection (line-terminated), reply is a status li
 
 Request shapes:
     {"text": "...", "voice": "af_sarah", "speed": 1.0, "lang": "en-us"}
-    {"command": "stop"}
+    {"command": "stop"}     # shut the daemon down
+    {"command": "cancel"}   # stop the current utterance, keep the daemon up
     {"command": "ping"}
+    {"command": "version"}
 
 Replies: "ok", "busy", "err: <msg>".
 """
@@ -203,6 +205,17 @@ class _DaemonState:
     def shutdown(self) -> None:
         self.stop_event.set()
 
+    def cancel(self) -> None:
+        """Stop the current utterance and drop anything queued, without shutting
+        the daemon down. Drains the queue first so the worker can't immediately
+        pick up a pending item, then aborts the in-flight playback."""
+        while True:
+            try:
+                self.queue.get_nowait()
+            except queue.Empty:
+                break
+        self.tts.stop()
+
 
 class _Handler(socketserver.StreamRequestHandler):
     def handle(self) -> None:
@@ -222,11 +235,20 @@ class _Handler(socketserver.StreamRequestHandler):
             self.wfile.write(b"ok\n")
             return
 
+        if command == "version":
+            self.wfile.write(f"{updates._current_version()}\n".encode())
+            return
+
         if command == "stop":
             self.wfile.write(b"ok\n")
             threading.Thread(target=self.server.shutdown, daemon=True).start()
             return
 
+        if command == "cancel":
+            state.cancel()
+            self.wfile.write(b"ok\n")
+            return
+
         text = req.get("text")
         if not text:
             self.wfile.write(b"err: missing text\n")
@@ -341,5 +363,22 @@ def stop() -> tuple[bool, str]:
     return send({"command": "stop"})
 
 
+def cancel() -> tuple[bool, str]:
+    """Stop the daemon's current utterance (and drop the queue) without shutting
+    it down."""
+    return send({"command": "cancel"})
+
+
 def ping() -> tuple[bool, str]:
     return send({"command": "ping"}, timeout=PING_TIMEOUT_SECONDS)
+
+
+def version(timeout: float = PING_TIMEOUT_SECONDS) -> tuple[bool, str]:
+    """(got_version, version_or_error) reported by the running daemon.
+
+    The running daemon can differ from the installed package if it wasn't
+    restarted after an upgrade, so this reports what is actually serving — not
+    what's on disk. A version reply starts with a digit; error strings don't.
+    """
+    _, resp = send({"command": "version"}, timeout=timeout)
+    return resp[:1].isdigit(), resp

{stackvox-0.8.0 → stackvox-0.10.0}/stackvox/text.py

@@ -18,6 +18,7 @@ __all__ = [
     "markdown_to_paragraphs",
     "strip_emoji",
     "strip_thousands_separators",
+    "versions_to_words",
     "decimals_to_words",
     "expand_units",
     "apply_pronunciations",
@@ -84,6 +85,21 @@ def strip_thousands_separators(text: str) -> str:
     return re.sub(r"(?<=\d),(?=\d)", "", text)
 
 
+_VERSION = re.compile(r"(?<!\d)\d+(?:\.\d+){2,}(?!\d)")
+
+
+def versions_to_words(text: str) -> str:
+    """1.2.3 -> "1 point 2 point 3"; 0.7.0 -> "0 point 7 point 0".
+
+    A dotted version string has more than one decimal point, which
+    `decimals_to_words` can't handle — it splits only the first, leaving a stray
+    full stop mid-number ("0.7.0" -> "0 point 7.0"). Run this before it. Two-part
+    numbers are left untouched so ordinary decimals still read digit-by-digit,
+    and a trailing sentence stop (``upgrade to 1.2.3.``) is preserved.
+    """
+    return _VERSION.sub(lambda m: m.group(0).replace(".", " point "), text)
+
+
 def decimals_to_words(text: str) -> str:
     """1198.9 -> "1198 point 9"; 770.72 -> "770 point 7 2". Removes the bare
     "." between digits, which TTS can otherwise read as a full stop."""
@@ -117,14 +133,15 @@ _DEV_PRONUNCIATIONS: dict[str, str] = {
     "cli": "C L I",
     "ci": "C I",
     "ide": "I D E",
-    "aws": "A W S",
+    "aws": "A.W.S.",  # dotted: espeak reads a lone "A" as the article "uh"; dots force the letter name "ay"
     "uri": "U R I",
-    "iam": "I A M",
+    "iam": "I.A.M.",  # ditto — the middle "A" needs the dot
     "saas": "sass",
     "paas": "pass",
     "tui": "T U I",
     "postgresql": "postgres",
     "kubectl": "kube control",
+    "stackone": "stack one",  # org name espeak garbles as "stac kone"
 }
 
 
@@ -287,6 +304,7 @@ def _shape_paragraph(
     if expand_units_flag:  # units BEFORE decimals (see note above)
         text = expand_units(text, locale)
     if expand_numbers_flag:
+        text = versions_to_words(text)  # multi-dot versions BEFORE the decimal split
         text = decimals_to_words(text)
     return re.sub(r"[ \t]{2,}", " ", text).strip()
 

{stackvox-0.8.0 → stackvox-0.10.0/stackvox.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: stackvox
-Version: 0.8.0
+Version: 0.10.0
 Summary: Offline TTS library using Kokoro-82M
 Author-email: "StackOne Technologies Ltd." <support@stackone.com>
 License-Expression: Apache-2.0

{stackvox-0.8.0 → stackvox-0.10.0}/tests/test_cli.py

@@ -261,6 +261,9 @@ class TestCmdStatus:
         pid_path.read_text.return_value = "12345\n"
         mocker.patch.object(cli.daemon, "PID_PATH", pid_path)
         mocker.patch.object(cli.daemon, "SOCKET_PATH", "/tmp/x.sock")
+        # status now queries the running daemon's version; stub it so the test
+        # doesn't reach a real socket.
+        mocker.patch.object(cli.daemon, "version", return_value=(False, "n/a"))
 
         rc = cli._cmd_status(_ns())
 
@@ -269,6 +272,23 @@ class TestCmdStatus:
         assert "running" in out
         assert "12345" in out
 
+    def test_running_flags_daemon_version_skew(self, mocker, capsys):
+        mocker.patch.object(cli.daemon, "is_running", return_value=True)
+        pid_path = mocker.MagicMock()
+        pid_path.read_text.return_value = "1\n"
+        mocker.patch.object(cli.daemon, "PID_PATH", pid_path)
+        mocker.patch.object(cli.daemon, "SOCKET_PATH", "/tmp/x.sock")
+        mocker.patch.object(cli.daemon, "version", return_value=(True, "0.5.0"))
+        mocker.patch.object(cli.updates, "_current_version", return_value="0.8.0")
+        mocker.patch.object(cli.updates, "check_for_update", return_value=None)
+
+        rc = cli._cmd_status(_ns())
+
+        assert rc == 0
+        out = capsys.readouterr().out
+        assert "0.5.0" in out and "0.8.0" in out  # the skew is surfaced
+        assert "restart" in out.lower()
+
     def test_stopped_returns_one(self, mocker, capsys):
         mocker.patch.object(cli.daemon, "is_running", return_value=False)
         rc = cli._cmd_status(_ns())
@@ -503,3 +523,17 @@ class TestNormalizeParsing:
         mocker.patch.object(cli.sys, "argv", ["stackvox", "paths"])
         assert cli.main() == 0
         assert paths_handler.called
+
+
+class TestCmdCancel:
+    def test_running_calls_daemon_cancel(self, mocker):
+        mocker.patch.object(cli.daemon, "is_running", return_value=True)
+        cancel = mocker.patch.object(cli.daemon, "cancel", return_value=(True, "ok"))
+        assert cli._cmd_cancel(_ns()) == 0
+        cancel.assert_called_once()
+
+    def test_no_daemon_is_a_noop(self, mocker):
+        mocker.patch.object(cli.daemon, "is_running", return_value=False)
+        cancel = mocker.patch.object(cli.daemon, "cancel")
+        assert cli._cmd_cancel(_ns()) == 0
+        cancel.assert_not_called()

{stackvox-0.8.0 → stackvox-0.10.0}/tests/test_daemon_protocol.py

@@ -76,6 +76,22 @@ def test_ping_returns_ok(server: ServerHarness):
     assert _roundtrip(server.sock, json.dumps({"command": "ping"}) + "\n") == "ok"
 
 
+def test_version_returns_installed_version(server: ServerHarness):
+    from stackvox import updates
+
+    reply = _roundtrip(server.sock, json.dumps({"command": "version"}) + "\n")
+    assert reply == updates._current_version()
+
+
+def test_version_client_helper_reports_running_version(server: ServerHarness, monkeypatch):
+    from stackvox import daemon, updates
+
+    monkeypatch.setattr(daemon, "SOCKET_PATH", server.sock)
+    got, resp = daemon.version()
+    assert got is True
+    assert resp == updates._current_version()
+
+
 def test_plain_text_is_treated_as_text_field(server: ServerHarness):
     """Non-JSON payloads are accepted and wrapped as `{"text": line}`."""
     import time
@@ -153,3 +169,11 @@ def test_send_helper_when_daemon_not_running(tmp_path, monkeypatch):
     ok, resp = daemon.send({"command": "ping"})
     assert not ok
     assert resp == "daemon not running"
+
+
+def test_cancel_stops_playback_and_keeps_daemon_up(server: ServerHarness):
+    reply = _roundtrip(server.sock, json.dumps({"command": "cancel"}) + "\n")
+    assert reply == "ok"
+    server.tts.stop.assert_called()  # current utterance aborted
+    # unlike `stop`, the daemon stays up
+    assert _roundtrip(server.sock, json.dumps({"command": "ping"}) + "\n") == "ok"

{stackvox-0.8.0 → stackvox-0.10.0}/tests/test_text.py

@@ -10,6 +10,7 @@ from stackvox.text import (
     shape_pauses,
     strip_emoji,
     strip_thousands_separators,
+    versions_to_words,
 )
 
 # --- numbers ---------------------------------------------------------------
@@ -28,6 +29,31 @@ def test_year_is_not_a_decimal():
     assert decimals_to_words("built in 2023") == "built in 2023"
 
 
+def test_semver_all_parts_spoken():
+    assert versions_to_words("0.7.0") == "0 point 7 point 0"
+    assert versions_to_words("1.2.3") == "1 point 2 point 3"
+
+
+def test_semver_multi_digit_component():
+    assert versions_to_words("1.20.3") == "1 point 20 point 3"
+
+
+def test_version_preserves_trailing_sentence_stop():
+    assert versions_to_words("upgrade to 1.2.3.") == "upgrade to 1 point 2 point 3."
+
+
+def test_two_part_number_is_left_for_the_decimal_pass():
+    # Only two components — an ordinary decimal, not a version.
+    assert versions_to_words("3.14") == "3.14"
+    assert decimals_to_words(versions_to_words("3.14")) == "3 point 1 4"
+
+
+def test_semver_normalizes_end_to_end():
+    out = normalize_for_speech("Upgraded to 0.7.0 today.", markdown=False)
+    assert "0 point 7 point 0" in out
+    assert "0 point 7.0" not in out
+
+
 # --- units -----------------------------------------------------------------
 
 
@@ -200,11 +226,17 @@ def test_plain_text_mode_splits_paragraphs():
 def test_dev_acronyms_are_spelled_out():
     assert normalize_for_speech("Use the CLI.", markdown=False) == "Use the C L I."
     assert "C L I" in normalize_for_speech("the cli tool", markdown=False)  # lowercase too
-    assert "A W S" in normalize_for_speech("deploy to AWS", markdown=False)
+    assert "A.W.S." in normalize_for_speech("deploy to AWS", markdown=False)  # dotted → "ay"
+    assert "I.A.M." in normalize_for_speech("set up IAM", markdown=False)
     assert "U R I" in normalize_for_speech("parse the URI", markdown=False)
     assert "C I C D" in normalize_for_speech("the CI/CD pipeline", markdown=False)
 
 
+def test_org_names_are_spoken_word_by_word():
+    assert "stack one" in normalize_for_speech("deployed to StackOne today", markdown=False)
+    assert "stack one" in normalize_for_speech("the stackone api", markdown=False)  # case-insensitive
+
+
 def test_dev_terms_leave_correctly_voiced_acronyms_alone():
     out = normalize_for_speech("Send JSON over HTTP to the API.", markdown=False)
     assert "JSON" in out