Fix Modal deployment and Magpie runtime integration

app.py

@@ -40,9 +40,16 @@ synthesis_service = SynthesisService(session_root=TEMP_ROOT)
 
 
 def _warn_about_modal_configuration() -> None:
-    warning = synthesis_service.modal_client.configuration_warning()
+    client = synthesis_service.modal_client
+    warning = client.configuration_warning()
     if warning:
         print(f"Modal configuration warning: {warning}")
+        return
+    if client.is_configured():
+        print(
+            "Modal backend configured: "
+            f"base_url={client.base_url} timeout={client.timeout_seconds}s poll_interval={client.poll_interval_seconds}s"
+        )
 
 
 _warn_about_modal_configuration()

backend/magpie_adapter.py

@@ -1,10 +1,7 @@
-import base64
-import math
 import os
 from pathlib import Path
 from typing import Dict, Optional
 
-import numpy as np
 import soundfile as sf
 
 from backend.synthesis_catalog import MAGPIE_LANGUAGES, MAGPIE_MODEL, MAGPIE_SPEAKERS
@@ -25,12 +22,12 @@ except ImportError:
 
     spaces = _SpacesShim()
 
-
 MAGPIE_SPEAKER_IDS = {
-    speaker["value"]: index
-    for index, speaker in enumerate(
-        sorted(MAGPIE_SPEAKERS, key=lambda item: ["John", "Sofia", "Aria", "Jason", "Leo"].index(item["value"]))
-    )
+    "John": 0,
+    "Sofia": 1,
+    "Aria": 2,
+    "Jason": 3,
+    "Leo": 4,
 }
 MAGPIE_SUPPORTED_LANGUAGES = {language["value"] for language in MAGPIE_LANGUAGES}
 
@@ -46,7 +43,8 @@ class MagpieAdapter:
         self.checkpoint_filename = checkpoint_filename
         self.codec_model_path = codec_model_path
         self._model = None
-        self._engine = "fallback"
+        self._engine = "unloaded"
+        self._load_error: Optional[Exception] = None
 
     def _checkpoint_path(self) -> str:
         from huggingface_hub import hf_hub_download
@@ -66,8 +64,9 @@ class MagpieAdapter:
                 ModelLoadConfig,
                 load_magpie_model,
             )
-        except Exception:
-            self._engine = "fallback"
+        except Exception as exc:
+            self._engine = "load_failed"
+            self._load_error = exc
             return None
 
         config = ModelLoadConfig(
@@ -83,8 +82,14 @@ class MagpieAdapter:
             model.cuda()
         self._model = model
         self._engine = "magpie"
+        self._load_error = None
         return self._model
 
+    def speaker_index_for(self, speaker: str) -> int:
+        if speaker not in MAGPIE_SPEAKER_IDS:
+            raise ValueError(f"Unsupported Magpie speaker: {speaker}")
+        return MAGPIE_SPEAKER_IDS[speaker]
+
     @spaces.GPU(duration=300)
     def synthesize(
         self,
@@ -99,19 +104,18 @@ class MagpieAdapter:
         del diffusion_steps, speed
         output_path.parent.mkdir(parents=True, exist_ok=True)
         speaker = voice_config.speaker or "Sofia"
-        if speaker not in MAGPIE_SPEAKER_IDS:
-            raise ValueError(f"Unsupported Magpie speaker: {speaker}")
+        speaker_index = self.speaker_index_for(speaker)
         target_language = voice_config.language or language or "en"
         if target_language not in MAGPIE_SUPPORTED_LANGUAGES:
             raise ValueError(f"Unsupported Magpie language: {target_language}")
 
         model = self._load_model()
         if model is None:
-            return self._synthesize_fallback(
-                text=text,
-                output_path=output_path,
-                speaker=speaker,
-                apply_text_normalization=voice_config.apply_text_normalization,
+            detail = f"{type(self._load_error).__name__}: {self._load_error}" if self._load_error else "unknown error"
+            raise ValueError(
+                "Magpie TTS runtime is unavailable. "
+                "This app must install NVIDIA NeMo Magpie dependencies to synthesize real speech. "
+                f"Model load failed with {detail}."
             )
 
         cleaned_text = text.strip()
@@ -121,9 +125,9 @@ class MagpieAdapter:
             cleaned_text,
             language=target_language,
             apply_TN=voice_config.apply_text_normalization,
-            speaker_index=MAGPIE_SPEAKER_IDS[speaker],
+            speaker_index=speaker_index,
         )
-        waveform = audio[0, : audio_len[0]].detach().cpu().numpy().astype(np.float32)
+        waveform = audio[0, : audio_len[0]].detach().cpu().numpy()
         sample_rate = int(getattr(model, "sample_rate", 22050))
         sf.write(str(output_path), waveform, sample_rate)
         duration_seconds = int(round(len(waveform) / sample_rate))
@@ -134,33 +138,3 @@ class MagpieAdapter:
             "model": MAGPIE_MODEL,
             "engine": self._engine,
         }
-
-    def _synthesize_fallback(
-        self,
-        *,
-        text: str,
-        output_path: Path,
-        speaker: str,
-        apply_text_normalization: bool,
-    ) -> Dict[str, object]:
-        sample_rate = 22050
-        duration_seconds = max(1.0, min(20.0, len(text.split()) * 0.42))
-        total_samples = int(sample_rate * duration_seconds)
-        speaker_index = MAGPIE_SPEAKER_IDS.get(speaker, 0)
-        base_freq = 170.0 + (speaker_index * 28.0)
-        if apply_text_normalization:
-            base_freq += 8.0
-
-        timeline = np.linspace(0, duration_seconds, total_samples, endpoint=False)
-        waveform = (
-            0.16 * np.sin(2 * math.pi * base_freq * timeline)
-            + 0.04 * np.sin(2 * math.pi * (base_freq * 1.5) * timeline)
-        ).astype(np.float32)
-        sf.write(str(output_path), waveform, sample_rate)
-        return {
-            "duration_seconds": int(round(duration_seconds)),
-            "sample_rate": sample_rate,
-            "backend": "local",
-            "model": MAGPIE_MODEL,
-            "engine": self._engine,
-        }

backend/modal_client.py

@@ -17,7 +17,7 @@ class ModalSynthesisClient:
         *,
         base_url: Optional[str],
         auth_token: Optional[str] = None,
-        timeout_seconds: float = 60.0,
+        timeout_seconds: float = 300.0,
         poll_interval_seconds: float = 1.0,
     ) -> None:
         self.base_url = base_url.rstrip("/") if base_url else None
@@ -30,7 +30,7 @@ class ModalSynthesisClient:
         return cls(
             base_url=os.getenv("SCRIPTORIUM_MODAL_BASE_URL"),
             auth_token=os.getenv("SCRIPTORIUM_MODAL_AUTH_TOKEN"),
-            timeout_seconds=float(os.getenv("SCRIPTORIUM_MODAL_TIMEOUT_SECONDS", "60")),
+            timeout_seconds=float(os.getenv("SCRIPTORIUM_MODAL_TIMEOUT_SECONDS", "300")),
             poll_interval_seconds=float(os.getenv("SCRIPTORIUM_MODAL_POLL_INTERVAL_SECONDS", "1")),
         )
 
@@ -163,25 +163,41 @@ class ModalSynthesisClient:
 
     def _post_json(self, path: str, payload: Dict[str, object]) -> Dict[str, object]:
         self._ensure_configured()
-        response = requests.post(
-            self._absolute_url(path),
-            json=payload,
-            headers=self._headers(),
-            timeout=self.timeout_seconds,
-        )
-        response.raise_for_status()
-        return response.json()
+        try:
+            response = requests.post(
+                self._absolute_url(path),
+                json=payload,
+                headers=self._headers(),
+                timeout=self.timeout_seconds,
+            )
+            response.raise_for_status()
+            return response.json()
+        except requests.Timeout as exc:
+            raise ValueError(
+                "Modal request timed out. The remote worker may still be cold-starting or loading models. "
+                "Try again, or increase SCRIPTORIUM_MODAL_TIMEOUT_SECONDS."
+            ) from exc
+        except requests.RequestException as exc:
+            raise ValueError(f"Modal request failed: {exc}") from exc
 
     def _get_json(self, path: str, *, params: Dict[str, object]) -> Dict[str, object]:
         self._ensure_configured()
-        response = requests.get(
-            self._absolute_url(path),
-            params=params,
-            headers=self._headers(),
-            timeout=self.timeout_seconds,
-        )
-        response.raise_for_status()
-        return response.json()
+        try:
+            response = requests.get(
+                self._absolute_url(path),
+                params=params,
+                headers=self._headers(),
+                timeout=self.timeout_seconds,
+            )
+            response.raise_for_status()
+            return response.json()
+        except requests.Timeout as exc:
+            raise ValueError(
+                "Modal request timed out. The remote worker may still be cold-starting or loading models. "
+                "Try again, or increase SCRIPTORIUM_MODAL_TIMEOUT_SECONDS."
+            ) from exc
+        except requests.RequestException as exc:
+            raise ValueError(f"Modal request failed: {exc}") from exc
 
     def _absolute_url(self, path: str) -> str:
         if path.startswith("http://") or path.startswith("https://"):

modal_app.py

@@ -19,6 +19,7 @@ from backend.types import VoiceConfig
 app = modal.App("scriptorium-tts")
 image = (
     modal.Image.debian_slim(python_version="3.12")
+    .apt_install("git")
     .pip_install(
         "fastapi[standard]",
         "numpy>=1.26.0",
@@ -28,9 +29,10 @@ image = (
         "omnivoice>=0.1.5",
         "requests>=2.32.0",
         "huggingface_hub>=0.33.0",
-        "nemo-toolkit[tts]",
+        "nemo_toolkit[tts]@git+https://github.com/NVIDIA/NeMo.git@main",
         "kaldialign",
     )
+    .add_local_python_source("backend")
 )
 jobs = modal.Dict.from_name("scriptorium-modal-jobs", create_if_missing=True)
 artifacts = modal.Dict.from_name("scriptorium-modal-artifacts", create_if_missing=True)

requirements.txt

@@ -10,3 +10,5 @@ torchaudio>=2.8.0
 omnivoice>=0.1.5
 requests>=2.32.0
 huggingface_hub>=0.33.0
+nemo_toolkit[tts]@git+https://github.com/NVIDIA/NeMo.git@main
+kaldialign

tests/test_app_startup.py

@@ -48,3 +48,20 @@ def test_app_import_warns_for_modal_dashboard_url(monkeypatch) -> None:
 
     assert any("SCRIPTORIUM_MODAL_BASE_URL" in line for line in printed)
     assert any("modal.run" in line for line in printed)
+
+
+def test_app_import_reports_modal_runtime_configuration(monkeypatch) -> None:
+    sys.modules.pop("app", None)
+    printed = []
+
+    monkeypatch.setenv(
+        "SCRIPTORIUM_MODAL_BASE_URL",
+        "https://scriptorium-tts--mattkevan.modal.run",
+    )
+    monkeypatch.setenv("SCRIPTORIUM_MODAL_TIMEOUT_SECONDS", "300")
+    monkeypatch.setattr("builtins.print", lambda *args, **kwargs: printed.append(" ".join(str(arg) for arg in args)))
+
+    importlib.import_module("app")
+
+    assert any("Modal backend configured" in line for line in printed)
+    assert any("timeout=300.0s" in line for line in printed)

tests/test_magpie_adapter.py

@@ -0,0 +1,30 @@
+from pathlib import Path
+
+import pytest
+
+from backend.magpie_adapter import MagpieAdapter
+from backend.types import VoiceConfig
+
+
+def test_magpie_adapter_raises_when_runtime_is_unavailable(tmp_path: Path) -> None:
+    adapter = MagpieAdapter()
+    adapter._load_error = ModuleNotFoundError("No module named 'nemo'")
+
+    with pytest.raises(ValueError, match="Magpie TTS runtime is unavailable"):
+        adapter.synthesize(
+            text="Hello from Magpie.",
+            output_path=tmp_path / "magpie.wav",
+            voice_config=VoiceConfig(model="magpie", speaker="Sofia", language="en"),
+            diffusion_steps=32,
+            speed=1.0,
+        )
+
+
+def test_magpie_adapter_uses_official_speaker_mapping() -> None:
+    adapter = MagpieAdapter()
+
+    assert adapter.speaker_index_for("John") == 0
+    assert adapter.speaker_index_for("Sofia") == 1
+    assert adapter.speaker_index_for("Aria") == 2
+    assert adapter.speaker_index_for("Jason") == 3
+    assert adapter.speaker_index_for("Leo") == 4

tests/test_magpie_dependencies.py

@@ -0,0 +1,15 @@
+from pathlib import Path
+
+
+def test_requirements_include_official_magpie_runtime_dependencies() -> None:
+    requirements = Path("requirements.txt").read_text(encoding="utf-8")
+
+    assert "nemo_toolkit[tts]@git+https://github.com/NVIDIA/NeMo.git@main" in requirements
+    assert "kaldialign" in requirements
+
+
+def test_modal_app_uses_official_magpie_runtime_dependencies() -> None:
+    source = Path("modal_app.py").read_text(encoding="utf-8")
+
+    assert '"nemo_toolkit[tts]@git+https://github.com/NVIDIA/NeMo.git@main"' in source
+    assert '"kaldialign"' in source

tests/test_modal_app_file.py

@@ -0,0 +1,15 @@
+from pathlib import Path
+
+
+def test_modal_app_includes_backend_python_source_in_image() -> None:
+    source = Path("modal_app.py").read_text(encoding="utf-8")
+
+    assert '.add_local_python_source("backend")' in source
+    assert source.index(".pip_install(") < source.index('.add_local_python_source("backend")')
+
+
+def test_modal_app_installs_git_before_git_based_pip_dependencies() -> None:
+    source = Path("modal_app.py").read_text(encoding="utf-8")
+
+    assert '.apt_install("git")' in source
+    assert source.index('.apt_install("git")') < source.index(".pip_install(")

tests/test_modal_client.py

@@ -1,4 +1,6 @@
 from backend.modal_client import ModalSynthesisClient
+import pytest
+import requests
 
 
 def test_modal_client_warns_when_configured_with_dashboard_url() -> None:
@@ -15,3 +17,37 @@ def test_modal_client_accepts_modal_run_base_url() -> None:
     client = ModalSynthesisClient(base_url="https://scriptorium-tts--mattkevan.modal.run")
 
     assert client.configuration_warning() is None
+
+
+def test_modal_client_defaults_to_longer_timeout() -> None:
+    client = ModalSynthesisClient(base_url="https://scriptorium-tts--mattkevan.modal.run")
+
+    assert client.timeout_seconds == 300.0
+
+
+def test_modal_client_uses_longer_default_timeout_from_env(monkeypatch) -> None:
+    monkeypatch.delenv("SCRIPTORIUM_MODAL_TIMEOUT_SECONDS", raising=False)
+    monkeypatch.delenv("SCRIPTORIUM_MODAL_POLL_INTERVAL_SECONDS", raising=False)
+
+    client = ModalSynthesisClient.from_env()
+
+    assert client.timeout_seconds == 300.0
+    assert client.poll_interval_seconds == 1.0
+
+
+def test_modal_client_surfaces_read_timeout_as_user_facing_error(monkeypatch, tmp_path) -> None:
+    client = ModalSynthesisClient(base_url="https://scriptorium-tts--mattkevan.modal.run", timeout_seconds=1)
+
+    def fake_post(*args, **kwargs):
+        raise requests.ReadTimeout("timed out")
+
+    monkeypatch.setattr("backend.modal_client.requests.post", fake_post)
+
+    with pytest.raises(ValueError, match="Modal request timed out"):
+        client.generate_preview(
+            text="Hello",
+            output_path=tmp_path / "preview.wav",
+            voice_config=type("Voice", (), {"to_dict": lambda self: {}, "model": "omnivoice"})(),
+            diffusion_steps=32,
+            speed=1.0,
+        )