Deploy from Achraf-cyber/hackton-locallang@76aa2de3965e28e4be5261c706fe0cd7a30d1778

.gitattributes

@@ -1,35 +0,0 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text

Dockerfile

@@ -0,0 +1,15 @@
+FROM python:3.11-slim
+
+RUN apt-get update && apt-get install -y --no-install-recommends ffmpeg \
+    && rm -rf /var/lib/apt/lists/*
+
+WORKDIR /app
+
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY . .
+
+EXPOSE 7860
+
+CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -1,10 +1,44 @@
 ---
-title: Model Service
-emoji: 👀
-colorFrom: pink
-colorTo: purple
+title: model-service
+emoji: 🗣️
+colorFrom: blue
+colorTo: green
 sdk: docker
-pinned: false
+app_port: 7860
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# model-service
+
+Service Python FastAPI dont le seul role est d'exposer l'acces aux langues
+Dioula et Moore : reconnaissance vocale (ASR), traduction et synthese vocale
+(TTS). Aucune logique de LLM, de base de donnees ou de simplification n'est
+geree ici.
+
+## Structure
+
+```
+model-service/
+├── app/
+│   ├── main.py          # point d'entree FastAPI
+│   ├── deps.py          # configuration (Settings)
+│   └── services/
+│       ├── asr.py       # reconnaissance vocale
+│       ├── translation.py  # traduction
+│       └── tts.py       # synthese vocale
+└── tests/
+```
+
+## Developpement local
+
+```bash
+pip install -r requirements.txt
+uvicorn app.main:app --reload --port 8000
+```
+
+## Deploiement sur Hugging Face Spaces
+
+Ce dossier est deploye comme un Space Docker (header YAML ci-dessus :
+`sdk: docker`, `app_port: 7860`), automatiquement a chaque push sur `main`
+via le workflow `.github/workflows/deploy-model-service.yml` (voir la racine
+du monorepo). Le Space lit `ALLOWED_ORIGINS` et `HF_TOKEN` depuis ses propres
+"Secrets" (Settings > Variables and secrets du Space), pas depuis ce repo.

app/deps.py

@@ -0,0 +1,20 @@
+from functools import lru_cache
+from typing import Literal
+
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+
+class Settings(BaseSettings):
+    model_config = SettingsConfigDict(env_file=".env", env_file_encoding="utf-8")
+
+    ALLOWED_ORIGINS: list[str] = ["*"]
+
+    # ASR temporaire via l'API d'inference Hugging Face pendant que
+    # facebook/mms-1b-all finit de telecharger en local (voir asr.py).
+    ASR_BACKEND: Literal["local", "hf_api"] = "local"
+    HF_TOKEN: str | None = None
+
+
+@lru_cache
+def get_settings() -> Settings:
+    return Settings()

app/main.py

@@ -0,0 +1,127 @@
+"""model-service - FastAPI app.
+
+Lancement local :
+    uvicorn app.main:app --reload --port 8000
+"""
+
+import logging
+import time
+import uuid
+from pathlib import Path
+from typing import Literal
+
+from fastapi import FastAPI, File, Form, UploadFile
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.staticfiles import StaticFiles
+from pydantic import BaseModel
+
+from app.deps import get_settings
+from app.services.asr import ASR
+from app.services.translator import Translator
+from app.services.tts import TTS
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger("model-service")
+
+settings = get_settings()
+
+MEDIA_DIR = Path(__file__).resolve().parent.parent / "media"
+MEDIA_DIR.mkdir(parents=True, exist_ok=True)
+
+app = FastAPI(
+    title="model-service",
+    description="Expose ASR, traduction et TTS pour le Dioula et le Mooré.",
+)
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=settings.ALLOWED_ORIGINS,
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+app.mount("/media", StaticFiles(directory=str(MEDIA_DIR)), name="media")
+
+
+class TranscribeResponse(BaseModel):
+    text: str
+
+
+class LocalizeRequest(BaseModel):
+    text_fr: str
+    lang: Literal["dyu", "mos"]
+
+
+class LocalizeResponse(BaseModel):
+    translated: str
+    audio_url: str
+
+
+class ToFrenchRequest(BaseModel):
+    text: str
+    lang: Literal["dyu", "mos"]
+
+
+class ToFrenchResponse(BaseModel):
+    text_fr: str
+
+
+@app.get("/health")
+def health() -> dict[str, str]:
+    return {"status": "ok"}
+
+
+@app.post("/transcribe", response_model=TranscribeResponse)
+async def transcribe(
+    file: UploadFile = File(...),
+    lang: Literal["dyu", "mos", "fra"] = Form(...),
+) -> TranscribeResponse:
+    start = time.perf_counter()
+
+    suffix = Path(file.filename or "audio").suffix or ".wav"
+    tmp_path = MEDIA_DIR / f"{uuid.uuid4()}{suffix}"
+    contents = await file.read()
+    tmp_path.write_bytes(contents)
+
+    try:
+        asr = ASR.get_instance()
+        text = asr.transcribe(str(tmp_path), lang)
+    finally:
+        tmp_path.unlink(missing_ok=True)
+
+    elapsed = time.perf_counter() - start
+    logger.info("POST /transcribe lang=%s duration=%.3fs", lang, elapsed)
+
+    return TranscribeResponse(text=text)
+
+
+@app.post("/localize", response_model=LocalizeResponse)
+def localize(payload: LocalizeRequest) -> LocalizeResponse:
+    start = time.perf_counter()
+
+    translator = Translator.get_instance()
+    translated = translator.translate(payload.text_fr, src="fr", tgt=payload.lang)
+
+    tts = TTS.get_instance()
+    filename = f"{uuid.uuid4()}.wav"
+    output_path = MEDIA_DIR / filename
+    tts.speak(translated, lang=payload.lang, output_path=str(output_path))
+
+    elapsed = time.perf_counter() - start
+    logger.info("POST /localize lang=%s duration=%.3fs", payload.lang, elapsed)
+
+    return LocalizeResponse(translated=translated, audio_url=f"/media/{filename}")
+
+
+@app.post("/to-french", response_model=ToFrenchResponse)
+def to_french(payload: ToFrenchRequest) -> ToFrenchResponse:
+    start = time.perf_counter()
+
+    translator = Translator.get_instance()
+    text_fr = translator.translate(payload.text, src=payload.lang, tgt="fr")
+
+    elapsed = time.perf_counter() - start
+    logger.info("POST /to-french lang=%s duration=%.3fs", payload.lang, elapsed)
+
+    return ToFrenchResponse(text_fr=text_fr)

app/services/asr.py

@@ -0,0 +1,137 @@
+"""Reconnaissance vocale (speech-to-text) pour le Dioula, le Moore et le francais
+via facebook/mms-1b-all.
+
+Deux backends, choisis par Settings.ASR_BACKEND :
+- "local" (defaut) : Wav2Vec2ForCTC + AutoProcessor charges en local.
+- "hf_api" : pont temporaire vers l'API d'inference Hugging Face, utile tant
+  que le modele local (~3.86 Go) n'est pas entierement telecharge.
+  ATTENTION : facebook/mms-1b-all n'est deploye sur AUCUN provider
+  d'inference HF (verifie : liste de providers vide). Le backend "hf_api"
+  utilise donc openai/whisper-large-v3 a la place, qui NE supporte PAS
+  officiellement le Dioula ni le Moore (~99 langues entrainees, dyu/mos
+  absentes) : fiable seulement pour lang="fra", best-effort pour dyu/mos.
+Le contrat de transcribe(audio_path, lang) est identique dans les deux cas.
+"""
+
+import logging
+
+import numpy as np
+import torch
+from huggingface_hub import InferenceClient
+from pydub import AudioSegment
+from transformers import AutoProcessor, Wav2Vec2ForCTC
+
+from app.deps import get_settings
+
+logger = logging.getLogger("model-service.asr")
+
+MODEL_NAME = "facebook/mms-1b-all"
+HF_API_MODEL_NAME = "openai/whisper-large-v3"
+
+MMS_LANG_CODES = {
+    "dyu": "dyu",
+    "mos": "mos",
+    "fra": "fra",
+}
+
+TARGET_SAMPLE_RATE = 16_000
+WINDOW_SECONDS = 30
+OVERLAP_SECONDS = 2
+
+
+class ASR:
+    _instance = None
+
+    def __init__(self) -> None:
+        settings = get_settings()
+        self.backend = settings.ASR_BACKEND
+
+        if self.backend == "hf_api":
+            self._client = InferenceClient(model=HF_API_MODEL_NAME, token=settings.HF_TOKEN)
+            return
+
+        self.device = "cuda" if torch.cuda.is_available() else "cpu"
+        self.processor = AutoProcessor.from_pretrained(MODEL_NAME)
+        self.model = Wav2Vec2ForCTC.from_pretrained(MODEL_NAME).to(self.device)
+        self.model.eval()
+        self._current_lang: str | None = None
+
+    @classmethod
+    def get_instance(cls) -> "ASR":
+        if cls._instance is None:
+            cls._instance = cls()
+        return cls._instance
+
+    def _set_lang(self, lang: str) -> None:
+        if lang not in MMS_LANG_CODES:
+            raise ValueError(f"Langue non supportee: {lang}")
+        target_lang = MMS_LANG_CODES[lang]
+        if self._current_lang == target_lang:
+            return
+        self.processor.tokenizer.set_target_lang(target_lang)
+        self.model.load_adapter(target_lang)
+        self._current_lang = target_lang
+
+    def _load_audio(self, audio_path: str) -> np.ndarray:
+        audio = AudioSegment.from_file(audio_path)
+        audio = audio.set_channels(1).set_frame_rate(TARGET_SAMPLE_RATE)
+        samples = np.array(audio.get_array_of_samples()).astype(np.float32)
+        max_val = float(1 << (8 * audio.sample_width - 1))
+        samples /= max_val
+        return samples
+
+    def _transcribe_chunk(self, chunk: np.ndarray) -> str:
+        inputs = self.processor(
+            chunk, sampling_rate=TARGET_SAMPLE_RATE, return_tensors="pt"
+        ).to(self.device)
+        with torch.no_grad():
+            logits = self.model(**inputs).logits
+        ids = torch.argmax(logits, dim=-1)
+        return self.processor.batch_decode(ids)[0]
+
+    def _transcribe_hf_api(self, audio_path: str, lang: str) -> str:
+        if lang not in MMS_LANG_CODES:
+            raise ValueError(f"Langue non supportee: {lang}")
+        if lang != "fra":
+            logger.warning(
+                "ASR hf_api (whisper-large-v3) ne supporte pas officiellement '%s' "
+                "(dyu/mos absents des langues entrainees) : resultat best-effort.",
+                lang,
+            )
+        output = self._client.automatic_speech_recognition(audio_path)
+        return output.text.strip()
+
+    def transcribe(self, audio_path: str, lang: str) -> str:
+        if self.backend == "hf_api":
+            return self._transcribe_hf_api(audio_path, lang)
+
+        self._set_lang(lang)
+        samples = self._load_audio(audio_path)
+
+        window_size = WINDOW_SECONDS * TARGET_SAMPLE_RATE
+        overlap_size = OVERLAP_SECONDS * TARGET_SAMPLE_RATE
+        step = window_size - overlap_size
+
+        if len(samples) <= window_size:
+            return self._transcribe_chunk(samples).strip()
+
+        transcripts = []
+        start = 0
+        while start < len(samples):
+            chunk = samples[start : start + window_size]
+            if len(chunk) == 0:
+                break
+            transcripts.append(self._transcribe_chunk(chunk))
+            start += step
+
+        return " ".join(t.strip() for t in transcripts if t.strip())
+
+
+if __name__ == "__main__":
+    import sys
+
+    asr = ASR.get_instance()
+    path = sys.argv[1] if len(sys.argv) > 1 else "sample.wav"
+    lang_arg = sys.argv[2] if len(sys.argv) > 2 else "dyu"
+    text = asr.transcribe(path, lang_arg)
+    print(f"Transcription ({lang_arg}): {text}")

app/services/translation.py

@@ -0,0 +1 @@
+"""Traduction entre le francais et le Dioula / Moore."""

app/services/translator.py

@@ -0,0 +1,64 @@
+"""Traduction entre le francais et le Dioula / Moore via facebook/nllb-200-distilled-600M."""
+
+import re
+
+import torch
+from transformers import AutoModelForSeq2SeqLM, AutoTokenizer
+
+MODEL_NAME = "facebook/nllb-200-distilled-600M"
+
+NLLB_LANG_CODES = {
+    "fr": "fra_Latn",
+    "dyu": "dyu_Latn",
+    "mos": "mos_Latn",
+}
+
+_SENTENCE_SPLIT_RE = re.compile(r"(?<=[.!?])\s+")
+
+
+class Translator:
+    _instance = None
+
+    def __init__(self) -> None:
+        self.device = "cuda" if torch.cuda.is_available() else "cpu"
+        self.tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME)
+        self.model = AutoModelForSeq2SeqLM.from_pretrained(MODEL_NAME).to(self.device)
+        self.model.eval()
+
+    @classmethod
+    def get_instance(cls) -> "Translator":
+        if cls._instance is None:
+            cls._instance = cls()
+        return cls._instance
+
+    def _split_sentences(self, text: str) -> list[str]:
+        sentences = [s.strip() for s in _SENTENCE_SPLIT_RE.split(text.strip()) if s.strip()]
+        return sentences or [text.strip()]
+
+    def _translate_sentence(self, sentence: str, src: str, tgt: str) -> str:
+        self.tokenizer.src_lang = NLLB_LANG_CODES[src]
+        inputs = self.tokenizer(sentence, return_tensors="pt").to(self.device)
+        forced_bos_token_id = self.tokenizer.convert_tokens_to_ids(NLLB_LANG_CODES[tgt])
+        with torch.no_grad():
+            generated = self.model.generate(
+                **inputs,
+                forced_bos_token_id=forced_bos_token_id,
+                num_beams=4,
+                max_length=256,
+            )
+        return self.tokenizer.batch_decode(generated, skip_special_tokens=True)[0]
+
+    def translate(self, text: str, src: str, tgt: str) -> str:
+        if src not in NLLB_LANG_CODES or tgt not in NLLB_LANG_CODES:
+            raise ValueError(f"Langue non supportee: src={src}, tgt={tgt}")
+        sentences = self._split_sentences(text)
+        translated = [self._translate_sentence(s, src, tgt) for s in sentences]
+        return " ".join(translated)
+
+
+if __name__ == "__main__":
+    translator = Translator.get_instance()
+    example = "Bonjour. Comment allez-vous aujourd'hui ? J'espere que tout va bien."
+    result = translator.translate(example, src="fr", tgt="dyu")
+    print(f"FR: {example}")
+    print(f"DYU: {result}")

app/services/tts.py

@@ -0,0 +1,102 @@
+"""Synthese vocale (text-to-speech) pour le Dioula et le Moore via les modeles
+VITS facebook/mms-tts-dyu et facebook/mms-tts-mos."""
+
+import re
+
+import numpy as np
+import soundfile as sf
+import torch
+from transformers import VitsModel, VitsTokenizer
+
+MMS_TTS_MODEL_NAMES = {
+    "dyu": "facebook/mms-tts-dyu",
+    "mos": "facebook/mms-tts-mos",
+}
+
+MAX_CHARS_BEFORE_SPLIT = 500
+SILENCE_SECONDS = 0.3
+MIN_SEGMENT_LETTERS = 4
+
+_SENTENCE_SPLIT_RE = re.compile(r"(?<=[.!?])\s+")
+_LETTERS_RE = re.compile(r"[^a-zA-ZÀ-ÖØ-öø-ÿ]")
+
+
+class TTS:
+    _instance = None
+
+    def __init__(self) -> None:
+        self.device = "cuda" if torch.cuda.is_available() else "cpu"
+        self._models: dict[str, VitsModel] = {}
+        self._tokenizers: dict[str, VitsTokenizer] = {}
+
+    @classmethod
+    def get_instance(cls) -> "TTS":
+        if cls._instance is None:
+            cls._instance = cls()
+        return cls._instance
+
+    def _get_model(self, lang: str) -> tuple[VitsModel, VitsTokenizer]:
+        if lang not in MMS_TTS_MODEL_NAMES:
+            raise ValueError(f"Langue non supportee: {lang}")
+        if lang not in self._models:
+            model_name = MMS_TTS_MODEL_NAMES[lang]
+            self._tokenizers[lang] = VitsTokenizer.from_pretrained(model_name)
+            model = VitsModel.from_pretrained(model_name).to(self.device)
+            model.eval()
+            self._models[lang] = model
+        return self._models[lang], self._tokenizers[lang]
+
+    def _split_text(self, text: str) -> list[str]:
+        text = text.strip()
+        if len(text) <= MAX_CHARS_BEFORE_SPLIT:
+            return [text]
+        raw_segments = [s.strip() for s in _SENTENCE_SPLIT_RE.split(text) if s.strip()]
+        return self._merge_short_segments(raw_segments)
+
+    def _merge_short_segments(self, segments: list[str]) -> list[str]:
+        """Fusionne les fragments trop courts (ex. '1.' d'une liste numerotee)
+        avec le fragment suivant : VITS plante (narrow(): length must be
+        non-negative) sur une sequence phonemisee trop courte."""
+        merged: list[str] = []
+        buffer = ""
+        for seg in segments:
+            buffer = f"{buffer} {seg}".strip() if buffer else seg
+            if len(_LETTERS_RE.sub("", buffer)) >= MIN_SEGMENT_LETTERS:
+                merged.append(buffer)
+                buffer = ""
+        if buffer:
+            if merged:
+                merged[-1] = f"{merged[-1]} {buffer}".strip()
+            else:
+                merged.append(buffer)
+        return merged
+
+    def _synthesize_segment(self, text: str, lang: str) -> np.ndarray:
+        model, tokenizer = self._get_model(lang)
+        inputs = tokenizer(text, return_tensors="pt").to(self.device)
+        with torch.no_grad():
+            output = model(**inputs).waveform
+        return output.squeeze().cpu().numpy()
+
+    def speak(self, text: str, lang: str, output_path: str) -> str:
+        model, _ = self._get_model(lang)
+        sample_rate = model.config.sampling_rate
+
+        segments = self._split_text(text)
+        silence = np.zeros(int(SILENCE_SECONDS * sample_rate), dtype=np.float32)
+
+        waveforms = []
+        for i, segment in enumerate(segments):
+            waveforms.append(self._synthesize_segment(segment, lang))
+            if i < len(segments) - 1:
+                waveforms.append(silence)
+
+        audio = np.concatenate(waveforms) if len(waveforms) > 1 else waveforms[0]
+        sf.write(output_path, audio, sample_rate)
+        return output_path
+
+
+if __name__ == "__main__":
+    tts = TTS.get_instance()
+    out = tts.speak("I ni ce. An be here?", lang="dyu", output_path="demo_dyu.wav")
+    print(f"Audio genere: {out}")

pytest.ini

@@ -0,0 +1,3 @@
+[pytest]
+markers =
+    slow: tests lents qui chargent de vrais modeles (exclus par defaut avec -m "not slow")

requirements.txt

@@ -0,0 +1,17 @@
+fastapi
+uvicorn[standard]
+python-multipart
+transformers
+torch
+accelerate
+sentencepiece
+pydantic-settings
+python-dotenv
+soundfile
+scipy
+pydub
+audioop-lts; python_version >= "3.13"
+pillow
+requests
+pytest
+httpx

tests/conftest.py

@@ -0,0 +1,51 @@
+import numpy as np
+import pytest
+import soundfile as sf
+from fastapi.testclient import TestClient
+
+from app.main import app
+from app.services.asr import ASR
+from app.services.translator import Translator
+from app.services.tts import TTS
+
+FIXED_TRANSCRIPT = "ceci est un texte fixe"
+FIXED_TRANSLATION = "traduction fixe"
+
+
+class FakeASR:
+    def transcribe(self, audio_path: str, lang: str) -> str:
+        return FIXED_TRANSCRIPT
+
+
+class FakeTranslator:
+    def translate(self, text: str, src: str, tgt: str) -> str:
+        return FIXED_TRANSLATION
+
+
+class FakeTTS:
+    def speak(self, text: str, lang: str, output_path: str) -> str:
+        silence = np.zeros(1, dtype=np.float32)
+        sf.write(output_path, silence, 16_000)
+        return output_path
+
+
+@pytest.fixture(autouse=True)
+def mock_heavy_services(request, monkeypatch):
+    """Evite le chargement de vrais modeles pendant les tests rapides.
+
+    Les tests marques @pytest.mark.slow veulent les vrais services : on ne
+    patche rien pour eux.
+    """
+    if request.node.get_closest_marker("slow"):
+        yield
+        return
+
+    monkeypatch.setattr(ASR, "get_instance", classmethod(lambda cls: FakeASR()))
+    monkeypatch.setattr(Translator, "get_instance", classmethod(lambda cls: FakeTranslator()))
+    monkeypatch.setattr(TTS, "get_instance", classmethod(lambda cls: FakeTTS()))
+    yield
+
+
+@pytest.fixture
+def client():
+    return TestClient(app)

tests/test_api.py

@@ -0,0 +1,45 @@
+def test_health(client):
+    response = client.get("/health")
+    assert response.status_code == 200
+    assert response.json() == {"status": "ok"}
+
+
+def test_localize_mocked(client):
+    response = client.post(
+        "/localize",
+        json={"text_fr": "Bonjour tout le monde", "lang": "dyu"},
+    )
+    assert response.status_code == 200
+    data = response.json()
+    assert "translated" in data
+    assert "audio_url" in data
+
+
+def test_localize_missing_lang(client):
+    response = client.post(
+        "/localize",
+        json={"text_fr": "Bonjour tout le monde"},
+    )
+    assert response.status_code == 422
+
+
+def test_to_french_mocked(client):
+    response = client.post(
+        "/to-french",
+        json={"text": "i ni ce", "lang": "dyu"},
+    )
+    assert response.status_code == 200
+    assert "text_fr" in response.json()
+
+
+def test_to_french_missing_lang(client):
+    response = client.post("/to-french", json={"text": "i ni ce"})
+    assert response.status_code == 422
+
+
+def test_transcribe_missing_file(client):
+    response = client.post(
+        "/transcribe",
+        data={"lang": "dyu"},
+    )
+    assert response.status_code == 422

tests/test_services.py

@@ -0,0 +1,50 @@
+import pytest
+
+from app.services.translator import Translator
+from app.services.tts import TTS
+
+
+@pytest.mark.slow
+def test_translate_fr_to_dyu_real():
+    translator = Translator.get_instance()
+    result = translator.translate("Bonjour, comment allez-vous ?", src="fr", tgt="dyu")
+    assert isinstance(result, str)
+    assert result.strip() != ""
+
+
+def test_tts_merges_bare_numbered_list_markers():
+    """Regression : une liste numerotee ('1. Xxx. 2. Yyy.') donne des segments
+    '1.'/'2.' de 2 caracteres apres decoupe par phrase ; VITS plante
+    (narrow(): length must be non-negative) si on les synthetise seuls."""
+    # Instanciation directe (pas get_instance()) : construire un TTS ne charge
+    # aucun modele (lazy par langue), donc pas besoin du mock get_instance()
+    # utilise pour les autres tests rapides.
+    tts = TTS()
+    text = (
+        "1. " + ("Allez a la mairie avec vos papiers d identite. " * 6)
+        + "2. " + ("Presentez votre demande au guichet. " * 6)
+    )
+    assert len(text) > 500  # declenche la decoupe en segments
+
+    segments = tts._split_text(text)
+
+    assert all(len(s) > 5 for s in segments), segments
+
+
+@pytest.mark.slow
+def test_tts_speak_numbered_list_real():
+    """Reproduit le crash original avec une vraie synthese VITS."""
+    tts = TTS.get_instance()
+    text = (
+        "1. Allez a la mairie avec vos papiers d identite et un justificatif de "
+        "domicile recent, puis attendez votre tour dans la file d attente prevue "
+        "a cet effet pour les demandes administratives courantes. "
+        "2. Presentez votre demande au guichet approprie et attendez votre tour "
+        "patiemment en respectant les horaires d ouverture affiches devant le "
+        "batiment principal de la mairie. "
+        "3. Payez les frais administratifs requis pour le traitement de votre "
+        "dossier officiel aupres du caissier designe et conservez precieusement "
+        "votre recu de paiement."
+    )
+    out = tts.speak(text, lang="dyu", output_path="test_numbered_list.wav")
+    assert out == "test_numbered_list.wav"