lectura-multispeaker 3.0.0__tar.gz

lectura_multispeaker-3.0.0/PKG-INFO

@@ -0,0 +1,22 @@
+Metadata-Version: 2.4
+Name: lectura-multispeaker
+Version: 3.0.0
+Summary: Synthese vocale neuronale multi-speaker francais — Matcha-Conformer + HiFi-GAN (ONNX)
+Author-email: Max Carriere <admin@lectura.world>
+License: AGPL-3.0-or-later
+Project-URL: Homepage, https://www.lectura.world/developpement/modules/outils/tts-multi/
+Project-URL: Repository, https://github.com/maxcarriere/lectura-modules/tree/main/MultiSpeaker
+Project-URL: Issues, https://github.com/maxcarriere/lectura-modules/issues
+Keywords: tts,french,speech-synthesis,onnx,matcha,conformer,multi-speaker
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Multimedia :: Sound/Audio :: Speech
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Provides-Extra: onnx
+Requires-Dist: onnxruntime>=1.16; extra == "onnx"
+Requires-Dist: numpy>=1.24; extra == "onnx"

lectura_multispeaker-3.0.0/pyproject.toml

@@ -0,0 +1,37 @@
+[build-system]
+requires = ["setuptools>=68.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "lectura-multispeaker"
+version = "3.0.0"
+description = "Synthese vocale neuronale multi-speaker francais — Matcha-Conformer + HiFi-GAN (ONNX)"
+readme = "README.md"
+requires-python = ">=3.10"
+license = {text = "AGPL-3.0-or-later"}
+authors = [{name = "Max Carriere", email = "admin@lectura.world"}]
+keywords = ["tts", "french", "speech-synthesis", "onnx", "matcha", "conformer", "multi-speaker"]
+classifiers = [
+    "Development Status :: 5 - Production/Stable",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Multimedia :: Sound/Audio :: Speech",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+]
+dependencies = []
+
+[project.optional-dependencies]
+onnx = ["onnxruntime>=1.16", "numpy>=1.24"]
+
+[project.urls]
+Homepage = "https://www.lectura.world/developpement/modules/outils/tts-multi/"
+Repository = "https://github.com/maxcarriere/lectura-modules/tree/main/MultiSpeaker"
+Issues = "https://github.com/maxcarriere/lectura-modules/issues"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+lectura_multispeaker = ["data/*.json", "modeles/*.onnx", "modeles/*.enc", "modeles/*.json"]

lectura_multispeaker-3.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

lectura_multispeaker-3.0.0/src/lectura_multispeaker/__init__.py

@@ -0,0 +1,181 @@
+"""lectura-multispeaker — Synthese vocale neuronale multi-speaker francais.
+
+Exports publics :
+    - creer_engine(mode, speaker, models_dir, ...) -> engine
+    - synthetiser(texte, speaker, **kwargs) -> numpy array float32
+    - liste_speakers() -> list[dict]
+    - OnnxTTSEngine, ApiTTSEngine
+    - TTSResult, PhonemeTiming
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+from pathlib import Path
+from typing import Any
+
+log = logging.getLogger(__name__)
+
+__version__ = "3.0.0"
+
+_SPEAKERS_DATA: list[dict] | None = None
+_DEFAULT_SPEAKER: str | None = None
+
+
+def _load_speakers() -> tuple[list[dict], str]:
+    """Charge le fichier speakers.json (singleton)."""
+    global _SPEAKERS_DATA, _DEFAULT_SPEAKER
+    if _SPEAKERS_DATA is not None:
+        return _SPEAKERS_DATA, _DEFAULT_SPEAKER
+
+    speakers_path = Path(__file__).parent / "data" / "speakers.json"
+    with open(speakers_path, encoding="utf-8") as f:
+        data = json.load(f)
+    _SPEAKERS_DATA = data["speakers"]
+    _DEFAULT_SPEAKER = data.get("default", "siwis")
+    return _SPEAKERS_DATA, _DEFAULT_SPEAKER
+
+
+def liste_speakers() -> list[dict]:
+    """Retourne la liste des speakers disponibles avec metadata.
+
+    Returns
+    -------
+    list[dict]
+        Chaque dict contient : id, name, gender, label
+    """
+    speakers, _ = _load_speakers()
+    return list(speakers)
+
+
+def creer_engine(
+    mode: str = "auto",
+    speaker: str = "siwis",
+    models_dir: str | Path | None = None,
+    api_url: str | None = None,
+    api_key: str | None = None,
+):
+    """Factory pour creer un engine d'inference TTS multi-speaker.
+
+    Parameters
+    ----------
+    mode : str
+        "auto" : ONNX local si disponible, sinon API
+        "local" : force l'inference ONNX locale
+        "api" : force l'API distante
+    speaker : str
+        Nom du speaker (siwis, ezwa, nadine, bernard, gilles, zeckou)
+    models_dir : Path | None
+        Repertoire des modeles ONNX (override la detection auto)
+    api_url : str | None
+        URL du serveur API
+    api_key : str | None
+        Cle API
+
+    Returns
+    -------
+    OnnxTTSEngine | ApiTTSEngine
+        Engine avec interface unifiee (synthesize, synthesize_phonemes)
+    """
+    if mode in ("auto", "local"):
+        engine = _try_local(speaker, models_dir)
+        if engine is not None:
+            return engine
+        if mode == "local":
+            raise FileNotFoundError(
+                "Modeles ONNX introuvables. Verifiez l'installation ou "
+                "specifiez models_dir. Voir README pour les emplacements."
+            )
+        log.info("Modeles locaux non disponibles, fallback vers API")
+
+    from lectura_multispeaker.inference_api import ApiTTSEngine
+    return ApiTTSEngine(api_url=api_url, api_key=api_key, speaker=speaker)
+
+
+def _try_local(speaker: str, models_dir: str | Path | None = None):
+    """Tente de creer un engine ONNX local."""
+    try:
+        import onnxruntime  # noqa: F401
+        import numpy  # noqa: F401
+    except ImportError:
+        return None
+
+    from lectura_multispeaker._chargeur import find_models_dir
+
+    resolved = find_models_dir(speaker, models_dir)
+    if resolved is None:
+        return None
+
+    from lectura_multispeaker.inference_onnx import OnnxTTSEngine
+    return OnnxTTSEngine(resolved, speaker=speaker)
+
+
+def synthetiser(
+    texte: str,
+    speaker: str = "siwis",
+    mode: str = "auto",
+    models_dir: str | Path | None = None,
+    api_url: str | None = None,
+    api_key: str | None = None,
+    phrase_type: int | None = None,
+    duration_scale: float = 1.0,
+    pitch_shift: float = 0.0,
+    pitch_range: float = 1.0,
+    energy_scale: float = 1.0,
+    pause_scale: float = 1.0,
+    style: str | None = None,
+    style_vector: list[float] | None = None,
+    n_ode_steps: int | None = None,
+    duration_noise: float | None = None,
+) -> Any:
+    """Convenience : texte -> numpy audio float32.
+
+    Parameters
+    ----------
+    texte : str
+        Texte francais a synthetiser
+    speaker : str
+        Nom du speaker (siwis, ezwa, nadine, bernard, gilles, zeckou)
+    mode, models_dir, api_url, api_key :
+        Parametres de creer_engine()
+    phrase_type, duration_scale, pitch_shift, pitch_range, energy_scale, pause_scale :
+        Controles prosodiques
+    style : str | None
+        Nom d'un preset de style (ex: "narratif", "dialogue")
+    style_vector : list[float] | None
+        Vecteur de style explicite [n_style_dims]
+    n_ode_steps : int | None
+        Nombre de pas ODE (Matcha-Conformer uniquement, defaut: config)
+    duration_noise : float | None
+        Bruit de duree lisse (0.0=off, 0.1=subtil, 0.2=prononce)
+
+    Returns
+    -------
+    numpy.ndarray
+        Audio float32 mono, 22050 Hz
+    """
+    engine = creer_engine(mode=mode, speaker=speaker, models_dir=models_dir,
+                          api_url=api_url, api_key=api_key)
+    result = engine.synthesize(
+        texte,
+        phrase_type=phrase_type,
+        duration_scale=duration_scale,
+        pitch_shift=pitch_shift,
+        pitch_range=pitch_range,
+        energy_scale=energy_scale,
+        pause_scale=pause_scale,
+        style=style,
+        style_vector=style_vector,
+        n_ode_steps=n_ode_steps,
+        duration_noise=duration_noise,
+    )
+    return result.samples
+
+
+__all__ = [
+    "creer_engine",
+    "synthetiser",
+    "liste_speakers",
+    "__version__",
+]

lectura_multispeaker-3.0.0/src/lectura_multispeaker/_chargeur.py

@@ -0,0 +1,127 @@
+"""Localisateur de modeles multi-speaker — cascade de chemins.
+
+Ordre de recherche :
+1. Parametre explicite models_dir
+2. Variable d'environnement LECTURA_MODELS_DIR/tts_multispeaker
+3. Repertoire utilisateur ~/.lectura/models/tts_multispeaker/
+4. Modeles embarques dans le package (site-packages, version privee)
+"""
+
+from __future__ import annotations
+
+import logging
+import os
+from pathlib import Path
+
+log = logging.getLogger(__name__)
+
+_PACKAGE_MODELS = Path(__file__).parent / "modeles"
+
+# Fichiers partages requis pour l'inference ONNX locale
+# Matcha-Conformer (v2) : matcha_unet.onnx + hifigan.onnx
+# FastPitch (v1 legacy) : decoder.onnx + hifigan.onnx
+SHARED_FILES_MATCHA = [
+    "matcha_unet.onnx",
+    "hifigan.onnx",
+]
+SHARED_FILES_FASTPITCH = [
+    "decoder.onnx",
+    "hifigan.onnx",
+]
+
+
+def find_models_dir(
+    speaker: str = "siwis",
+    models_dir: str | Path | None = None,
+) -> Path | None:
+    """Trouve le repertoire contenant les modeles ONNX.
+
+    Args:
+        speaker: Nom du speaker dont on verifie la presence de l'encodeur.
+        models_dir: Override explicite.
+
+    Returns:
+        Path du repertoire ou None si aucun modele trouve.
+    """
+    candidates: list[Path] = []
+
+    # 1. Parametre explicite
+    if models_dir is not None:
+        candidates.append(Path(models_dir))
+
+    # 2. Variable d'environnement
+    env_dir = os.environ.get("LECTURA_MODELS_DIR", "")
+    if env_dir:
+        candidates.append(Path(env_dir) / "tts_multispeaker")
+
+    # 3. Repertoire utilisateur
+    candidates.append(Path.home() / ".lectura" / "models" / "tts_multispeaker")
+
+    # 4. Embarques dans le package
+    candidates.append(_PACKAGE_MODELS)
+
+    for candidate in candidates:
+        if _has_models(candidate, speaker):
+            log.debug("Modeles trouves : %s", candidate)
+            return candidate
+
+    return None
+
+
+def _file_exists(directory: Path, filename: str) -> bool:
+    """Verifie si un fichier .onnx ou .enc existe."""
+    return ((directory / filename).exists()
+            or (directory / filename.replace(".onnx", ".enc")).exists())
+
+
+def _has_models(directory: Path, speaker: str = "siwis") -> bool:
+    """Verifie que le repertoire contient les fichiers ONNX necessaires.
+
+    Detecte Matcha-Conformer d'abord, puis fallback FastPitch.
+    """
+    if not directory.is_dir():
+        return False
+
+    # --- Matcha-Conformer (v2) ---
+    matcha_shared_ok = all(
+        _file_exists(directory, f) for f in SHARED_FILES_MATCHA
+    )
+    if matcha_shared_ok:
+        # Unified matcha encoder
+        if _file_exists(directory, "matcha_encoder.onnx"):
+            return True
+        # Per-speaker matcha encoder
+        if _file_exists(directory, f"matcha_encoder_{speaker}.onnx"):
+            return True
+
+    # --- FastPitch (v1 legacy) ---
+    fastpitch_shared_ok = all(
+        _file_exists(directory, f) for f in SHARED_FILES_FASTPITCH
+    )
+    if fastpitch_shared_ok:
+        # Unified encoder
+        if _file_exists(directory, "encoder.onnx"):
+            return True
+        # Per-speaker encoder
+        if _file_exists(directory, f"encoder_{speaker}.onnx"):
+            return True
+
+    return False
+
+
+def load_model_bytes(models_dir: Path, filename: str) -> bytes | None:
+    """Charge un modele (clair ou chiffre) depuis le repertoire.
+
+    Returns:
+        bytes du modele ONNX ou None si introuvable.
+    """
+    onnx_path = models_dir / filename
+    enc_path = models_dir / filename.replace(".onnx", ".enc")
+
+    if onnx_path.exists():
+        return onnx_path.read_bytes()
+    elif enc_path.exists():
+        from lectura_multispeaker._crypto import load_encrypted_model
+        return load_encrypted_model(enc_path)
+
+    return None

lectura_multispeaker-3.0.0/src/lectura_multispeaker/_crypto.py

@@ -0,0 +1,48 @@
+"""Dechiffrement des modeles ONNX chiffres (.enc) au runtime.
+
+Les constantes de derivation sont specifiques au module TTS multi-speaker.
+"""
+
+from __future__ import annotations
+
+import hashlib
+from pathlib import Path
+
+# Fragments de sel — specifiques TTS multi-speaker
+_P1 = "Lectura-TTS-MultiSpeaker"
+_P2 = 0x4D53
+_P3 = "2025-FastPitch-HiFiGAN-6voices"
+_P4 = "ONNX-PerSpeaker-Encoder"
+
+
+def _derive_key() -> bytes:
+    """Derive une cle de 256 bytes depuis les constantes."""
+    material = f"{_P1}:{_P2:#06x}:{_P3}:{_P4}"
+    key = hashlib.sha256(material.encode("utf-8")).digest()
+    extended = key
+    for _ in range(7):
+        key = hashlib.sha256(key + material.encode("utf-8")).digest()
+        extended += key
+    return extended[:256]
+
+
+def load_encrypted_model(enc_path: Path) -> bytes:
+    """Lit un fichier .enc et retourne les bytes ONNX dechiffres."""
+    data = enc_path.read_bytes()
+    key = _derive_key()
+    key_len = len(key)
+    out = bytearray(len(data))
+    for i, b in enumerate(data):
+        out[i] = b ^ key[i % key_len]
+    return bytes(out)
+
+
+def encrypt_model(onnx_path: Path, enc_path: Path) -> None:
+    """Chiffre un fichier ONNX en .enc (pour la preparation du package)."""
+    data = onnx_path.read_bytes()
+    key = _derive_key()
+    key_len = len(key)
+    out = bytearray(len(data))
+    for i, b in enumerate(data):
+        out[i] = b ^ key[i % key_len]
+    enc_path.write_bytes(bytes(out))

lectura_multispeaker-3.0.0/src/lectura_multispeaker/_enhance.py

@@ -0,0 +1,148 @@
+"""Enhancement mel-spectrogramme — numpy pur (pas de scipy).
+
+Compense le lissage L1 du FastPitch :
+- Contraste spectral (inter-bande par frame)
+- Sharpening temporel (unsharp mask avec kernel gaussien numpy)
+- Noise gate (frames silencieuses)
+- Fade-out (anti-pop fin d'utterance)
+"""
+
+from __future__ import annotations
+
+import numpy as np
+
+
+def _gaussian_kernel_1d(sigma: float) -> np.ndarray:
+    """Cree un kernel gaussien 1D normalise."""
+    ksize = int(sigma * 4) | 1  # taille impaire
+    x = np.arange(ksize) - ksize // 2
+    kernel = np.exp(-0.5 * (x / sigma) ** 2)
+    kernel /= kernel.sum()
+    return kernel
+
+
+def _smooth_temporal(mel: np.ndarray, sigma: float = 3.0) -> np.ndarray:
+    """Lissage temporel par convolution gaussienne, bande par bande."""
+    T = mel.shape[1]
+    kernel = _gaussian_kernel_1d(sigma)
+    # Pour les sequences tres courtes (< taille kernel), tronquer le kernel
+    if T < len(kernel):
+        center = len(kernel) // 2
+        half = T // 2
+        kernel = kernel[center - half : center + half + (T % 2)]
+        if kernel.sum() > 0:
+            kernel /= kernel.sum()
+    smoothed = np.zeros_like(mel)
+    for i in range(mel.shape[0]):
+        smoothed[i] = np.convolve(mel[i], kernel, mode="same")[:T]
+    return smoothed
+
+
+def enhance_mel(
+    mel: np.ndarray,
+    spectral_alpha: float = 0.20,
+    temporal_alpha: float = 0.20,
+    clip_min: float = -11.5,
+    clip_max: float = 2.0,
+) -> np.ndarray:
+    """Enhancement spectral + temporel du mel-spectrogramme.
+
+    Args:
+        mel: [n_mels, T] mel-spectrogram
+        spectral_alpha: force du boost de contraste inter-bandes
+        temporal_alpha: force du sharpening temporel
+        clip_min: borne basse (log(1e-5) ~ -11.5)
+        clip_max: borne haute
+
+    Returns:
+        mel enhance, memes dimensions
+    """
+    # 1. Contraste spectral : eloigner les bandes de la moyenne par frame
+    frame_mean = mel.mean(axis=0, keepdims=True)  # [1, T]
+    spectral_detail = mel - frame_mean
+    mel = frame_mean + spectral_detail * (1.0 + spectral_alpha)
+
+    # 2. Sharpening temporel : unsharp mask
+    smoothed = _smooth_temporal(mel, sigma=3.0)
+    temporal_detail = mel - smoothed
+    mel = mel + temporal_detail * temporal_alpha
+
+    return np.clip(mel, clip_min, clip_max)
+
+
+def noise_gate(
+    mel: np.ndarray,
+    threshold: float = -8.0,
+    silence_val: float = -11.5,
+) -> np.ndarray:
+    """Gate les frames dont l'energie moyenne est sous le seuil."""
+    frame_mean = mel.mean(axis=0)  # [T]
+    gate_strength = np.clip(
+        (threshold - frame_mean) / (threshold - silence_val), 0, 1
+    )
+    return mel * (1 - gate_strength) + silence_val * gate_strength
+
+
+def fade_out(
+    mel: np.ndarray,
+    n_frames: int = 5,
+    silence_val: float = -11.5,
+) -> np.ndarray:
+    """Fade-out lineaire sur les derniers frames."""
+    n = min(n_frames, mel.shape[1])
+    if n > 0:
+        fade = np.linspace(1.0, 0.0, n)
+        mel[:, -n:] = mel[:, -n:] * fade + silence_val * (1.0 - fade)
+    return mel
+
+
+def waveform_silence_gate(
+    audio: np.ndarray,
+    sample_rate: int = 22050,
+    window_ms: float = 15.0,
+    threshold_db: float = -35.0,
+    fade_samples: int = 128,
+) -> np.ndarray:
+    """Gate les zones silencieuses de la forme d'onde (post-vocoder)."""
+    if len(audio) == 0:
+        return audio
+
+    win_size = max(1, int(sample_rate * window_ms / 1000))
+    threshold_lin = 10 ** (threshold_db / 20)
+
+    n_windows = len(audio) // win_size
+    if n_windows == 0:
+        return audio
+
+    gate = np.ones(len(audio), dtype=np.float32)
+
+    for i in range(n_windows):
+        start = i * win_size
+        end = start + win_size
+        rms = np.sqrt(np.mean(audio[start:end] ** 2))
+        if rms < threshold_lin:
+            gate[start:end] = 0.0
+
+    remainder = len(audio) - n_windows * win_size
+    if remainder > 0:
+        start = n_windows * win_size
+        rms = np.sqrt(np.mean(audio[start:] ** 2))
+        if rms < threshold_lin:
+            gate[start:] = 0.0
+
+    diff = np.diff(gate, prepend=gate[0])
+    opens = np.where(diff > 0.5)[0]
+    for idx in opens:
+        start = max(0, idx - fade_samples)
+        length = idx - start
+        if length > 0:
+            gate[start:idx] = np.linspace(0.0, 1.0, length)
+
+    closes = np.where(diff < -0.5)[0]
+    for idx in closes:
+        end = min(len(audio), idx + fade_samples)
+        length = end - idx
+        if length > 0:
+            gate[idx:end] = np.linspace(1.0, 0.0, length)
+
+    return audio * gate

lectura_multispeaker-3.0.0/src/lectura_multispeaker/data/phoneme_vocab.json

@@ -0,0 +1,108 @@
+{
+  "vocab": [
+    "<PAD>",
+    "<UNK>",
+    "#",
+    "|",
+    "a",
+    "e",
+    "i",
+    "o",
+    "u",
+    "y",
+    "ɛ",
+    "ɔ",
+    "ø",
+    "œ",
+    "ə",
+    "ɑ",
+    "ɛ̃",
+    "ɔ̃",
+    "ɑ̃",
+    "œ̃",
+    "p",
+    "b",
+    "t",
+    "d",
+    "k",
+    "ɡ",
+    "f",
+    "v",
+    "s",
+    "z",
+    "ʃ",
+    "ʒ",
+    "m",
+    "n",
+    "ɲ",
+    "l",
+    "ʁ",
+    "j",
+    "w",
+    "ɥ",
+    "tʃ",
+    "dʒ",
+    "x",
+    "ɣ",
+    "ŋ",
+    "ɹ",
+    ",",
+    ".",
+    "?",
+    "!",
+    "…"
+  ],
+  "phone2id": {
+    "<PAD>": 0,
+    "<UNK>": 1,
+    "#": 2,
+    "|": 3,
+    "a": 4,
+    "e": 5,
+    "i": 6,
+    "o": 7,
+    "u": 8,
+    "y": 9,
+    "ɛ": 10,
+    "ɔ": 11,
+    "ø": 12,
+    "œ": 13,
+    "ə": 14,
+    "ɑ": 15,
+    "ɛ̃": 16,
+    "ɔ̃": 17,
+    "ɑ̃": 18,
+    "œ̃": 19,
+    "p": 20,
+    "b": 21,
+    "t": 22,
+    "d": 23,
+    "k": 24,
+    "ɡ": 25,
+    "f": 26,
+    "v": 27,
+    "s": 28,
+    "z": 29,
+    "ʃ": 30,
+    "ʒ": 31,
+    "m": 32,
+    "n": 33,
+    "ɲ": 34,
+    "l": 35,
+    "ʁ": 36,
+    "j": 37,
+    "w": 38,
+    "ɥ": 39,
+    "tʃ": 40,
+    "dʒ": 41,
+    "x": 42,
+    "ɣ": 43,
+    "ŋ": 44,
+    "ɹ": 45,
+    ",": 46,
+    ".": 47,
+    "?": 48,
+    "!": 49,
+    "…": 50
+  }
+}