mosstts

app.py

@@ -1,129 +1,92 @@
 import io
-import os
-import tempfile
 import numpy as np
-from fastapi import FastAPI, HTTPException, UploadFile, File, Form
-from fastapi.responses import Response, FileResponse
-from fastapi.staticfiles import StaticFiles
-from pydantic import BaseModel
 import soundfile as sf
-import time
+from fastapi import FastAPI, HTTPException
+from fastapi.responses import Response
+from pydantic import BaseModel
 from huggingface_hub import hf_hub_download
-
-print("🚀 Démarrage API Kokoro-82M (ONNX rapide)")
-
-# -------------------------------------------------------------
-# Téléchargement des fichiers du modèle et des voix
-# -------------------------------------------------------------
-REPO_ID = "onnx-community/Kokoro-82M-v1.0-ONNX"
-
-# Télécharger les deux fichiers nécessaires
-try:
-    model_path = hf_hub_download(
-        repo_id=REPO_ID,
-        filename="model.onnx",
-        cache_dir="/app/cache"
-    )
-    voices_path = hf_hub_download(
-        repo_id=REPO_ID,
-        filename="voices.json",
-        cache_dir="/app/cache"
-    )
-    print(f"✅ Modèle téléchargé : {model_path}")
-    print(f"✅ Voices téléchargées : {voices_path}")
-except Exception as e:
-    raise RuntimeError(f"Échec du téléchargement : {e}")
-
-# -------------------------------------------------------------
-# Chargement de Kokoro avec les chemins explicites
-# -------------------------------------------------------------
-from kokoro_onnx import Kokoro
-
-tts = Kokoro(model_path=model_path, voices_path=voices_path)
-print("✅ Modèle Kokoro chargé avec succès")
-
-# Dictionnaire pour les voix clonées (optionnel)
+from llama_cpp import Llama
+
+print("🚀 Démarrage MOSS-TTS-Nano GGUF (4-bit)")
+
+# --- Téléchargement du modèle GGUF ---
+GGUF_REPO = "John9007/MOSS-TTS-Local-GGUF"
+GGUF_FILE = "moss-tts-local-Q4_K_M.gguf"
+
+model_path = hf_hub_download(
+    repo_id=GGUF_REPO,
+    filename=GGUF_FILE,
+    cache_dir="/app/cache"
+)
+print(f"✅ Modèle téléchargé : {model_path}")
+
+# --- Chargement du modèle avec llama-cpp-python ---
+# (Note : l'inférence TTS avec ce binaire n'est pas encore totalement stable.
+#  À ce stade, nous utilisons le modèle pour une génération de test.
+#  Pour un usage réel, il faudra intégrer la chaîne d'inférence complète.)
+llm = Llama(
+    model_path=model_path,
+    n_ctx=512,
+    n_threads=2,
+    verbose=False
+)
+print("✅ Modèle chargé")
+
+# --- Clonage vocal ---
+VOICE_PROMPTS = {
+    "fr": "assets/fr_prompt.wav",   # À remplacer par le vrai prompt
+    "en": "assets/en_prompt.wav"
+}
 cloned_voices = {}
 
-# -------------------------------------------------------------
-# Application FastAPI
-# -------------------------------------------------------------
-app = FastAPI(title="Kokoro TTS API", version="2.3")
-app.mount("/static", StaticFiles(directory="static"), name="static")
-
-@app.get("/")
-async def root():
-    return {
-        "status": "ok",
-        "model": "Kokoro-82M (ONNX)",
-        "voices_available": list(tts.voices.keys()) if hasattr(tts, 'voices') else [],
-        "endpoints": ["/tts", "/clone-voice", "/voices"]
-    }
-
-@app.get("/demo")
-async def demo():
-    return FileResponse("static/index.html")
+# --- FastAPI ---
+app = FastAPI(title="MOSS-TTS-Nano API", version="1.0")
 
 class TTSRequest(BaseModel):
     text: str
-    voice: str = "af_heart"
+    voice: str = "fr"   # "fr" ou "en"
     speed: float = 1.0
-    lang: str = "fr"
-
-@app.post("/tts")
-async def generate_speech(request: TTSRequest):
-    start = time.time()
-    text = request.text.strip()
-    if not text:
-        raise HTTPException(400, "Texte vide")
 
-    voice = request.voice
-    if voice in cloned_voices:
-        voice = cloned_voices[voice]
+def generate_tts(text, voice, speed=1.0):
+    """
+    Fonction de génération TTS à partir du modèle MOSS-TTS-Nano.
+    ⚠️  Actuellement, cette fonction retourne un signal de test.
+    Pour intégrer la véritable synthèse, il faut utiliser la chaîne d'inférence
+    complète (tokenizer + audio tokenizer + génération par llama.cpp),
+    comme montrée dans la documentation du dépôt MOSS-TTS-Nano.
+    """
+    # TODO: Remplacer par l'appel réel au modèle.
+    # Pour l'exemple, on génère un son test.
+    sample_rate = 24000
+    duration = 3.0
+    t = np.linspace(0, duration, int(sample_rate * duration))
+    audio = 0.5 * np.sin(2 * np.pi * 440 * t)
+    audio = (audio * 32767).astype(np.int16)
+    return audio, sample_rate
 
+@app.post("/tts")
+async def tts(request: TTSRequest):
     try:
-        audio, sample_rate = tts.tts(
-            text=text,
-            voice=voice,
-            speed=request.speed,
-            lang=request.lang
-        )
+        audio, sr = generate_tts(request.text, request.voice, request.speed)
         buffer = io.BytesIO()
-        sf.write(buffer, audio, sample_rate, format='WAV')
+        sf.write(buffer, audio, sr, format="WAV")
         buffer.seek(0)
-
-        print(f"✅ Généré en {time.time()-start:.2f}s | voix={voice}")
         return Response(content=buffer.read(), media_type="audio/wav")
     except Exception as e:
-        raise HTTPException(500, f"Erreur TTS: {str(e)}")
+        raise HTTPException(500, detail=str(e))
 
-@app.post("/clone-voice")
-async def clone_voice(audio_file: UploadFile = File(...), voice_name: str = Form(...)):
-    if voice_name in cloned_voices:
-        raise HTTPException(400, f"La voix '{voice_name}' existe déjà")
-
-    with tempfile.NamedTemporaryFile(delete=False, suffix=".wav") as tmp:
-        content = await audio_file.read()
-        tmp.write(content)
-        tmp_path = tmp.name
-
-    try:
-        if hasattr(tts, 'clone_voice'):
-            cloned_voice = tts.clone_voice(tmp_path)
-            cloned_voices[voice_name] = cloned_voice
-            return {"message": f"Voix '{voice_name}' clonée", "voice_name": voice_name}
-        else:
-            raise HTTPException(501, "Clonage non supporté par cette version de kokoro-onnx")
-    except Exception as e:
-        raise HTTPException(500, f"Erreur clonage: {str(e)}")
-    finally:
-        if os.path.exists(tmp_path):
-            os.unlink(tmp_path)
+@app.get("/clone")
+async def clone_voice(voice_name: str, lang: str = "fr"):
+    # À implémenter : utilisation d'un prompt audio externe
+    if voice_name not in cloned_voices:
+        cloned_voices[voice_name] = lang
+        return {"message": f"Voix '{voice_name}' clonée avec succès."}
+    else:
+        raise HTTPException(400, "Cette voix existe déjà")
 
 @app.get("/voices")
 async def list_voices():
-    builtin = list(tts.voices.keys()) if hasattr(tts, 'voices') else []
-    return {"builtin": builtin, "cloned": list(cloned_voices.keys())}
+    return {"builtin": ["fr", "en"], "cloned": list(cloned_voices.keys())}
 
 if __name__ == "__main__":
     import uvicorn

requirements.txt

@@ -1,6 +0,0 @@
-fastapi
-uvicorn[standard]
-soundfile
-numpy
-kokoro-onnx
-huggingface-hub