Add brick tests and CLI runners

scripts/bootstrap.py

@@ -0,0 +1,10 @@
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+
+REPO_ROOT = Path(__file__).resolve().parents[1]
+if str(REPO_ROOT) not in sys.path:
+    sys.path.insert(0, str(REPO_ROOT))
+

scripts/test_asl_brick.py

@@ -0,0 +1,25 @@
+from __future__ import annotations
+
+import argparse
+import json
+
+import bootstrap  # noqa: F401
+
+from signspeak.pipeline import run_asl_video
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Run only the ASL video brick.")
+    parser.add_argument("video", nargs="?", default=None, help="Video path. Creates a demo clip if omitted.")
+    args = parser.parse_args()
+
+    intent_json, result, summary = run_asl_video(args.video)
+    print(summary)
+    print("\nIntent JSON:")
+    print(intent_json)
+    print("\nFull ASL output:")
+    print(json.dumps(result, indent=2, ensure_ascii=False))
+
+
+if __name__ == "__main__":
+    main()

scripts/test_full_pipeline.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+import argparse
+
+import bootstrap  # noqa: F401
+
+from signspeak.llm import generate_subtitle_and_instruction
+from signspeak.pipeline import run_asl_video
+from signspeak.tts import generate_tts
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Run ASL -> llama.cpp -> Qwen3-TTS.")
+    parser.add_argument("video", nargs="?", default=None, help="Video path. Creates a demo clip if omitted.")
+    parser.add_argument("--language", default="English")
+    parser.add_argument("--speaker", default="Ryan")
+    args = parser.parse_args()
+
+    intent_json, _, summary = run_asl_video(args.video)
+    subtitle, instruction, _ = generate_subtitle_and_instruction(intent_json)
+    audio_path = generate_tts(subtitle, args.language, args.speaker, instruction)
+
+    print(summary)
+    print(f"Subtitle: {subtitle}")
+    print(f"Voice instruction: {instruction}")
+    print(f"Audio: {audio_path}")
+
+
+if __name__ == "__main__":
+    main()

scripts/test_llm_brick.py

@@ -0,0 +1,25 @@
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+
+import bootstrap  # noqa: F401
+
+from signspeak.llm import generate_subtitle_and_instruction
+from signspeak.pipeline import DEFAULT_INTENT, json_text
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Run only the llama.cpp intent-to-text brick.")
+    parser.add_argument("--intent", help="Path to an intent JSON file. Uses default mock intent if omitted.")
+    args = parser.parse_args()
+
+    intent_json = Path(args.intent).read_text(encoding="utf-8") if args.intent else json_text(DEFAULT_INTENT)
+    subtitle, instruction, raw = generate_subtitle_and_instruction(intent_json)
+    print(f"Subtitle: {subtitle}")
+    print(f"Voice instruction: {instruction}")
+    print(f"Structured output: {raw}")
+
+
+if __name__ == "__main__":
+    main()

scripts/test_tts_brick.py

@@ -0,0 +1,23 @@
+from __future__ import annotations
+
+import argparse
+
+import bootstrap  # noqa: F401
+
+from signspeak.tts import generate_tts
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Run only the Qwen3-TTS brick.")
+    parser.add_argument("--text", default="I am happy to see you.")
+    parser.add_argument("--instruction", default="Speak warmly, joyfully, and clearly.")
+    parser.add_argument("--language", default="English")
+    parser.add_argument("--speaker", default="Ryan")
+    args = parser.parse_args()
+
+    output_path = generate_tts(args.text, args.language, args.speaker, args.instruction)
+    print(output_path)
+
+
+if __name__ == "__main__":
+    main()

tests/test_asl_pipeline.py

@@ -0,0 +1,38 @@
+from signspeak.asl.pipeline import build_intent_input
+from signspeak.pipeline import summarize_asl_result
+
+
+def test_build_intent_input_matches_llm_schema():
+    asl = {
+        "status": "ok",
+        "gloss_sequence": ["I", "HAPPY", "SEE", "YOU"],
+        "confidence": 0.91,
+        "frames_used": 30,
+    }
+    emotion = {
+        "status": "ok",
+        "dominant_emotion": "happy",
+        "intensity": 0.82,
+        "emotion_scores": {"happy": 0.82, "neutral": 0.18},
+    }
+
+    intent = build_intent_input(asl, emotion)
+
+    assert intent["detected_glosses"] == ["I", "HAPPY", "SEE", "YOU"]
+    assert intent["detected_facial_expression"] == "happy"
+    assert intent["emotion_profile"]["confidence"] == 0.82
+    assert intent["sign_confidence"] == 0.91
+    assert intent["diagnostics"]["asl_status"] == "ok"
+
+
+def test_summarize_asl_result_is_stable_for_missing_fields():
+    summary = summarize_asl_result(
+        {
+            "asl": {"status": "model_missing"},
+            "emotion": {"dominant_emotion": "unknown", "intensity": 0.0},
+        }
+    )
+
+    assert "ASL status: model_missing" in summary
+    assert "Emotion: unknown (0.00)" in summary
+

tests/test_llm_parsing.py

@@ -0,0 +1,43 @@
+from signspeak.llm import extract_json_object, normalize_llm_output, safe_json_loads
+
+
+def test_extract_json_object_from_markdown_fence():
+    raw = """```json
+{"subtitle": "I'm happy to see you!", "voice_instruction": "Speak warmly."}
+```"""
+
+    parsed = extract_json_object(raw)
+
+    assert parsed["subtitle"] == "I'm happy to see you!"
+    assert parsed["voice_instruction"] == "Speak warmly."
+
+
+def test_extract_json_object_from_text_wrapper():
+    raw = 'Result: {"subtitle": "Hello.", "voice_instruction": "Speak clearly."} Done.'
+
+    parsed = extract_json_object(raw)
+
+    assert parsed == {
+        "subtitle": "Hello.",
+        "voice_instruction": "Speak clearly.",
+    }
+
+
+def test_normalize_llm_output_blocks_json_subtitle():
+    normalized = normalize_llm_output(
+        {
+            "subtitle": '{"subtitle": "Bad nested payload"}',
+            "voice_instruction": "Speak warmly.",
+        }
+    )
+
+    assert normalized["subtitle"] == "I am happy to see you."
+    assert normalized["voice_instruction"] == "Speak warmly."
+
+
+def test_safe_json_loads_falls_back_to_raw_text():
+    parsed = safe_json_loads("not json")
+
+    assert parsed["raw_input"] == "not json"
+    assert "warning" in parsed
+

tests/test_tts.py

@@ -0,0 +1,37 @@
+import sys
+from types import SimpleNamespace
+
+import pytest
+
+import signspeak.tts as tts_module
+
+
+class FakeTTS:
+    def generate_custom_voice(self, text, language, speaker, instruct):
+        assert text == "Hello."
+        assert language == "English"
+        assert speaker == "Ryan"
+        assert instruct == "Speak clearly."
+        return [[0.0, 0.1, 0.0]], 24000
+
+
+def test_generate_tts_uses_model_and_writes_file(monkeypatch, tmp_path):
+    writes = []
+
+    def fake_write(path, data, sample_rate):
+        writes.append((path, data, sample_rate))
+
+    monkeypatch.setattr(tts_module, "get_tts_model", lambda: FakeTTS())
+    monkeypatch.setattr(tts_module.tempfile, "gettempdir", lambda: str(tmp_path))
+    monkeypatch.setitem(sys.modules, "soundfile", SimpleNamespace(write=fake_write))
+
+    output_path = tts_module.generate_tts("Hello.", "English", "Ryan", "Speak clearly.")
+
+    assert output_path.startswith(str(tmp_path))
+    assert writes == [(output_path, [0.0, 0.1, 0.0], 24000)]
+
+
+def test_generate_tts_rejects_empty_text():
+    with pytest.raises(ValueError):
+        tts_module.generate_tts("", "English", "Ryan", "Speak clearly.")
+