Init commit
This commit is contained in:
pporcheret
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
@@ -0,0 +1,392 @@
|
||||
"""Audio local sounddevice.RawInputStreamd'Alfred, repris de l'application historique de Pierre.
|
||||
|
||||
STT: Vosk + sounddevice, avec fallback arecord/ALSA.
|
||||
TTS: Piper local, avec fallback espeak puis spd-say.
|
||||
Sortie: haut-parleur local via paplay/aplay.
|
||||
|
||||
Ce module ne parle pas directement au LLM/Hermes: il retourne le texte reconnu
|
||||
à l'orchestrateur Alfred, afin de conserver Hermes comme cerveau unique.
|
||||
"""
|
||||
from __future__ import annotations
|
||||
from functools import lru_cache
|
||||
|
||||
import time
|
||||
import json
|
||||
import os
|
||||
import queue
|
||||
import shutil
|
||||
import subprocess
|
||||
import tempfile
|
||||
import threading
|
||||
from dataclasses import dataclass
|
||||
from typing import Callable, Optional
|
||||
|
||||
|
||||
def _cmd_ok(cmd, **kwargs):
|
||||
try:
|
||||
return subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE,
|
||||
check=True, text=True, **kwargs)
|
||||
except Exception:
|
||||
return None
|
||||
|
||||
|
||||
def audio_backend_detect() -> str:
|
||||
configured = os.getenv("AUDIO_BACKEND", "auto").lower()
|
||||
if configured in ("pactl", "alsa"):
|
||||
return configured
|
||||
if shutil.which("pactl"):
|
||||
info = _cmd_ok(["pactl", "info"])
|
||||
if info and "Server Name" in info.stdout:
|
||||
return "pactl"
|
||||
if shutil.which("amixer"):
|
||||
return "alsa"
|
||||
return "none"
|
||||
|
||||
|
||||
def _which(cmd):
|
||||
return shutil.which(cmd)
|
||||
|
||||
|
||||
def _is_piper_tts(binary: Optional[str]) -> bool:
|
||||
if not binary:
|
||||
return False
|
||||
try:
|
||||
r = subprocess.run([binary, "--help"], stdout=subprocess.PIPE,
|
||||
stderr=subprocess.STDOUT, text=True, timeout=3)
|
||||
out = (r.stdout or "").lower()
|
||||
if "gtk" in out or "ratbag" in out:
|
||||
return False
|
||||
return (("--model" in out or " -m " in out) and
|
||||
("--output_file" in out or " -o " in out))
|
||||
except Exception:
|
||||
return False
|
||||
|
||||
|
||||
def _find_piper_binary() -> Optional[str]:
|
||||
candidates = [
|
||||
os.getenv("PIPER_BIN"),
|
||||
"/usr/local/bin/piper-tts", "/usr/bin/piper-tts", _which("piper-tts"),
|
||||
"/usr/local/bin/piper", "/usr/bin/piper", _which("piper"),
|
||||
]
|
||||
for candidate in candidates:
|
||||
if candidate and _is_piper_tts(candidate):
|
||||
return candidate
|
||||
return None
|
||||
|
||||
|
||||
def _piper_supports_long_flag(binary: str) -> bool:
|
||||
try:
|
||||
r = subprocess.run([binary, "--help"], stdout=subprocess.PIPE,
|
||||
stderr=subprocess.STDOUT, text=True, timeout=3)
|
||||
out = (r.stdout or "").lower()
|
||||
return "--model" in out and "--output_file" in out
|
||||
except Exception:
|
||||
return True
|
||||
|
||||
###
|
||||
def tts_backend_detect() -> str:
|
||||
"""Retourne le moteur TTS configuré pour Alfred."""
|
||||
|
||||
if os.getenv("PIPER_HOST"):
|
||||
return "wyoming-piper"
|
||||
|
||||
if _which("espeak-ng"):
|
||||
return "espeak-ng"
|
||||
|
||||
return "none"
|
||||
|
||||
|
||||
'''
|
||||
def tts_backend_detect() -> str:
|
||||
piper = _find_piper_binary()
|
||||
model = os.getenv("PIPER_MODEL", "")
|
||||
if piper and model and os.path.exists(model):
|
||||
return "piper"
|
||||
if _which("espeak"):
|
||||
return "espeak"
|
||||
if _which("spd-say"):
|
||||
return "spd-say"
|
||||
return "none"
|
||||
'''
|
||||
####
|
||||
|
||||
def speak_text(text: str):
|
||||
"""Synthèse vocale via Wyoming Piper, avec secours eSpeak."""
|
||||
from services.audio_settings import speaker_muted
|
||||
if speaker_muted():
|
||||
return
|
||||
if not text or not text.strip():
|
||||
return
|
||||
|
||||
text = text[:int(os.getenv("TTS_MAX_CHARS", "2000"))]
|
||||
|
||||
try:
|
||||
from services.piper_tts import speak as piper_speak
|
||||
|
||||
print("[ALFRED TTS] Utilisation de Wyoming Piper", flush=True)
|
||||
piper_speak(text)
|
||||
return
|
||||
|
||||
except Exception as exc:
|
||||
print(f"[ALFRED TTS] Piper indisponible : {exc}", flush=True)
|
||||
|
||||
# Secours eSpeak
|
||||
fd, wav_path = tempfile.mkstemp(prefix="alfred_", suffix=".wav")
|
||||
os.close(fd)
|
||||
|
||||
try:
|
||||
print("[ALFRED TTS] Secours eSpeak", flush=True)
|
||||
|
||||
subprocess.run(
|
||||
["espeak-ng", "-v", "fr", "-w", wav_path, text],
|
||||
check=True,
|
||||
timeout=30
|
||||
)
|
||||
|
||||
subprocess.run(
|
||||
["aplay", "-q", "-D", "plughw:1,0", wav_path],
|
||||
check=True,
|
||||
timeout=120
|
||||
)
|
||||
|
||||
except Exception as exc:
|
||||
print(f"[ALFRED TTS] Erreur eSpeak : {exc}", flush=True)
|
||||
|
||||
finally:
|
||||
if os.path.exists(wav_path):
|
||||
os.remove(wav_path)
|
||||
|
||||
'''
|
||||
def speak_text(text: str):
|
||||
if not text or not text.strip():
|
||||
return
|
||||
|
||||
fd, wav_path = tempfile.mkstemp(prefix="alfred_", suffix=".wav")
|
||||
os.close(fd)
|
||||
|
||||
try:
|
||||
start = time.monotonic()
|
||||
print("[ALFRED TTS] Génération audio...", flush=True)
|
||||
|
||||
subprocess.run(
|
||||
["espeak-ng", "-v", "fr", "-w", wav_path, text],
|
||||
check=True,
|
||||
timeout=30
|
||||
)
|
||||
|
||||
print("[ALFRED TTS] Lecture audio...", flush=True)
|
||||
|
||||
subprocess.run(
|
||||
["aplay", "-q", "-D", "plughw:1,0", wav_path],
|
||||
check=True,
|
||||
timeout=120
|
||||
)
|
||||
|
||||
print(
|
||||
f"[ALFRED TTS] Terminé en {time.monotonic() - start:.2f}s",
|
||||
flush=True
|
||||
)
|
||||
|
||||
except Exception as e:
|
||||
print(f"[ALFRED TTS] Erreur : {e}", flush=True)
|
||||
|
||||
finally:
|
||||
if os.path.exists(wav_path):
|
||||
os.remove(wav_path)
|
||||
|
||||
|
||||
|
||||
|
||||
def speak_text(text: str):
|
||||
"""Synthétise et joue localement le texte. Retourne (ok, backend, erreur)."""
|
||||
text = (text or "").strip()
|
||||
if not text:
|
||||
return False, "none", "texte vide"
|
||||
text = text[: int(os.getenv("TTS_MAX_CHARS", "2000"))]
|
||||
|
||||
backend = audio_backend_detect()
|
||||
piper = _find_piper_binary()
|
||||
model = os.getenv("PIPER_MODEL", "")
|
||||
|
||||
if piper and model and os.path.exists(model):
|
||||
wav_path = None
|
||||
try:
|
||||
with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as tmp:
|
||||
wav_path = tmp.name
|
||||
cmd = [piper]
|
||||
if _piper_supports_long_flag(piper):
|
||||
cmd += ["--model", model, "--output_file", wav_path]
|
||||
else:
|
||||
cmd += ["-m", model, "-o", wav_path]
|
||||
p = subprocess.run(cmd, input=text, text=True,
|
||||
stdout=subprocess.PIPE, stderr=subprocess.PIPE, check=False)
|
||||
if p.returncode != 0:
|
||||
return False, "piper", (p.stderr or p.stdout or "")[:2000]
|
||||
if not os.path.exists(wav_path) or os.path.getsize(wav_path) == 0:
|
||||
return False, "piper", "Piper n'a pas produit de WAV"
|
||||
if backend == "pactl" and shutil.which("paplay"):
|
||||
play = subprocess.run(["paplay", wav_path], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
|
||||
elif shutil.which("aplay"):
|
||||
play = subprocess.run(["aplay", "-q", wav_path], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
|
||||
else:
|
||||
return False, "piper", "paplay/aplay introuvable"
|
||||
return play.returncode == 0, "piper", None if play.returncode == 0 else "lecture WAV échouée"
|
||||
except Exception as exc:
|
||||
return False, "piper", str(exc)
|
||||
finally:
|
||||
if wav_path:
|
||||
try: os.unlink(wav_path)
|
||||
except OSError: pass
|
||||
|
||||
if _which("espeak"):
|
||||
args = ["espeak", "-v", os.getenv("ESPEAK_VOICE", "fr"), text]
|
||||
if backend == "pactl" and shutil.which("padsp"):
|
||||
args = ["padsp"] + args
|
||||
ok = subprocess.run(args, stdout=subprocess.PIPE, stderr=subprocess.PIPE).returncode == 0
|
||||
return ok, "espeak", None if ok else "espeak a échoué"
|
||||
|
||||
if _which("spd-say"):
|
||||
ok = subprocess.run(["spd-say", "-l", "fr", text], stdout=subprocess.PIPE,
|
||||
stderr=subprocess.PIPE).returncode == 0
|
||||
return ok, "spd-say", None if ok else "spd-say a échoué"
|
||||
return False, "none", "aucun backend TTS disponible"
|
||||
'''
|
||||
|
||||
_tts_lock = threading.Lock()
|
||||
def speak_async(text: str, on_start: Optional[Callable] = None,
|
||||
on_end: Optional[Callable] = None) -> bool:
|
||||
"""Lecture non bloquante; refuse d'empiler deux réponses vocales."""
|
||||
if _tts_lock.locked():
|
||||
return False
|
||||
def worker():
|
||||
with _tts_lock:
|
||||
if on_start: on_start()
|
||||
try: speak_text(text)
|
||||
finally:
|
||||
if on_end: on_end()
|
||||
threading.Thread(target=worker, daemon=True).start()
|
||||
return True
|
||||
|
||||
|
||||
@dataclass
|
||||
class STTResult:
|
||||
text: str = ""
|
||||
error: Optional[str] = None
|
||||
|
||||
|
||||
|
||||
@lru_cache(maxsize=2)
|
||||
def get_vosk_model(model_path):
|
||||
from vosk import Model
|
||||
|
||||
print(f"[ALFRED] Chargement du modèle Vosk : {model_path}", flush=True)
|
||||
model = Model(model_path)
|
||||
print("[ALFRED] Modèle Vosk prêt", flush=True)
|
||||
|
||||
return model
|
||||
|
||||
|
||||
def listen_once(stop_event: Optional[threading.Event] = None,
|
||||
on_partial: Optional[Callable[[str], None]] = None,
|
||||
on_level: Optional[Callable[[float], None]] = None) -> STTResult:
|
||||
"""Attend une phrase finale Vosk et la retourne.
|
||||
|
||||
Reprend le comportement du prototype: sounddevice en priorité, arecord sinon.
|
||||
Le niveau audio transmis à l'UI est une approximation RMS sur int16.
|
||||
"""
|
||||
try:
|
||||
import numpy as np
|
||||
from vosk import Model, KaldiRecognizer
|
||||
except Exception as exc:
|
||||
return STTResult(error=f"Dépendance STT absente: {exc}")
|
||||
|
||||
model_path = os.getenv("VOSK_MODEL_PATH", "")
|
||||
sample_rate = int(os.getenv("VOSK_SAMPLE_RATE", "16000"))
|
||||
if not model_path or not os.path.exists(model_path):
|
||||
return STTResult(error=f"Modèle Vosk introuvable: {model_path}")
|
||||
try:
|
||||
# rec = KaldiRecognizer(Model(model_path), sample_rate)
|
||||
rec = KaldiRecognizer(get_vosk_model(model_path), sample_rate)
|
||||
except Exception as exc:
|
||||
return STTResult(error=f"Init Vosk: {exc}")
|
||||
|
||||
def process(data: bytes) -> Optional[str]:
|
||||
if on_level and data:
|
||||
try:
|
||||
a = np.frombuffer(data, dtype=np.int16).astype(np.float32)
|
||||
rms = float(np.sqrt(np.mean(a * a))) if a.size else 0.0
|
||||
on_level(min(1.0, rms / 6000.0))
|
||||
except Exception:
|
||||
pass
|
||||
if rec.AcceptWaveform(data):
|
||||
text = (json.loads(rec.Result() or "{}").get("text") or "").strip()
|
||||
if text:
|
||||
return text
|
||||
elif on_partial:
|
||||
partial = json.loads(rec.PartialResult() or "{}").get("partial", "")
|
||||
print(f"[ALFRED STT] Reconnu partiellement : {partial}", flush=True)
|
||||
on_partial(partial)
|
||||
return None
|
||||
|
||||
try:
|
||||
import sounddevice as sd
|
||||
q = queue.Queue(maxsize=32)
|
||||
def callback(indata, frames, time_info, status):
|
||||
try:
|
||||
q.put_nowait(bytes(indata))
|
||||
except queue.Full:
|
||||
pass
|
||||
device = os.getenv("AUDIO_INPUT_DEVICE") or None
|
||||
with sd.RawInputStream(samplerate=sample_rate, blocksize=8000, dtype="int16",
|
||||
channels=1, callback=callback, device=device):
|
||||
while not (stop_event and stop_event.is_set()):
|
||||
try:
|
||||
chunk = q.get(timeout=0.25)
|
||||
except queue.Empty:
|
||||
continue
|
||||
text = process(chunk)
|
||||
if text:
|
||||
return STTResult(text=text)
|
||||
except Exception as exc:
|
||||
print(f"[ALFRED STT] Erreur microphone sounddevice : {exc}", flush=True)
|
||||
|
||||
# except Exception:
|
||||
# pass
|
||||
|
||||
if stop_event and stop_event.is_set():
|
||||
return STTResult()
|
||||
|
||||
if not shutil.which("arecord"):
|
||||
return STTResult(error="sounddevice indisponible et arecord introuvable")
|
||||
cmd = ["arecord", "-q", "-f", "S16_LE", "-r", str(sample_rate), "-c", "1"]
|
||||
alsa_device = os.getenv("ALSA_CAPTURE_DEVICE", "").strip()
|
||||
if alsa_device:
|
||||
cmd += ["-D", alsa_device]
|
||||
proc = None
|
||||
try:
|
||||
proc = subprocess.Popen(cmd, stdout=subprocess.PIPE)
|
||||
while not (stop_event and stop_event.is_set()):
|
||||
chunk = proc.stdout.read(8000)
|
||||
if not chunk:
|
||||
continue
|
||||
text = process(chunk)
|
||||
if text:
|
||||
return STTResult(text=text)
|
||||
return STTResult()
|
||||
except Exception as exc:
|
||||
return STTResult(error=f"arecord: {exc}")
|
||||
finally:
|
||||
if proc and proc.poll() is None:
|
||||
proc.terminate()
|
||||
|
||||
|
||||
def devices():
|
||||
try:
|
||||
# import sounddevice as sd
|
||||
# return sd.query_devices()
|
||||
print("[ALFRED STT] Périphériques audio :", flush=True)
|
||||
print(sd.query_devices(), flush=True)
|
||||
print("[ALFRED STT] Périphérique par défaut :", sd.default.device, flush=True)
|
||||
return sd.query_devices()
|
||||
except Exception:
|
||||
return []
|
||||
@@ -0,0 +1,77 @@
|
||||
"""Réglages audio Alfred : ALSA carte 1 et états logiques thread-safe."""
|
||||
import os
|
||||
import re
|
||||
import subprocess
|
||||
import threading
|
||||
|
||||
_LOCK = threading.RLock()
|
||||
_STATE = {'volume': 70, 'speaker_muted': False, 'mic_muted': False, 'mic_gain': None}
|
||||
_CARD = os.getenv('ALFRED_ALSA_CARD', '1')
|
||||
_CONTROL = os.getenv('ALFRED_ALSA_VOLUME_CONTROL', 'Master')
|
||||
|
||||
def _amixer(*args):
|
||||
return subprocess.run(['amixer', '-c', _CARD, *args], capture_output=True,
|
||||
text=True, timeout=5, check=True).stdout
|
||||
|
||||
def initialize():
|
||||
"""Lit le volume existant sans modifier les réglages audio au démarrage."""
|
||||
try:
|
||||
output = _amixer('sget', _CONTROL)
|
||||
matches = re.findall(r'\[(\d+)%\]', output)
|
||||
with _LOCK:
|
||||
if matches:
|
||||
_STATE['volume'] = int(matches[0])
|
||||
# ALFRED_MIC_GAIN_V2 : gain Capture, sans toucher à Mic Boost.
|
||||
try:
|
||||
gain_out = _amixer('sget', os.getenv('ALFRED_ALSA_CAPTURE_CONTROL', 'Capture'))
|
||||
gains = re.findall(r'\[(\d+)%\]', gain_out)
|
||||
_STATE['mic_gain'] = int(gains[0]) if gains else None
|
||||
except (OSError, subprocess.SubprocessError) as exc:
|
||||
print(f'[ALFRED AUDIO] Gain Capture indisponible : {exc}', flush=True)
|
||||
# Ne pas déduire speaker_muted du mixer : état propre à Alfred.
|
||||
except (OSError, subprocess.SubprocessError) as exc:
|
||||
print(f'[ALFRED AUDIO] Lecture ALSA impossible : {exc}', flush=True)
|
||||
|
||||
def get_settings():
|
||||
with _LOCK:
|
||||
return dict(_STATE)
|
||||
|
||||
def update_settings(payload):
|
||||
if not isinstance(payload, dict):
|
||||
raise ValueError('Un objet JSON est attendu')
|
||||
allowed = {'volume', 'speaker_muted', 'mic_muted', 'mic_gain'}
|
||||
if set(payload) - allowed:
|
||||
raise ValueError('Paramètre audio inconnu')
|
||||
with _LOCK:
|
||||
new = dict(_STATE)
|
||||
if 'volume' in payload:
|
||||
v = payload['volume']
|
||||
if isinstance(v, bool) or not isinstance(v, (int, float)) or not 0 <= v <= 100:
|
||||
raise ValueError('volume doit être entre 0 et 100')
|
||||
new['volume'] = round(v)
|
||||
if 'mic_gain' in payload:
|
||||
v = payload['mic_gain']
|
||||
if isinstance(v, bool) or not isinstance(v, (int, float)) or not 0 <= v <= 100:
|
||||
raise ValueError('mic_gain doit être entre 0 et 100')
|
||||
new['mic_gain'] = round(v)
|
||||
for key in ('speaker_muted', 'mic_muted'):
|
||||
if key in payload:
|
||||
if not isinstance(payload[key], bool):
|
||||
raise ValueError(f'{key} doit être un booléen')
|
||||
new[key] = payload[key]
|
||||
# Le gain Capture ne change que sur demande explicite.
|
||||
# Mic Boost et Internal Mic Boost restent inchangés.
|
||||
if 'mic_gain' in payload and new['mic_gain'] != _STATE['mic_gain']:
|
||||
_amixer('sset', os.getenv('ALFRED_ALSA_CAPTURE_CONTROL', 'Capture'), f"{new['mic_gain']}%")
|
||||
if new['volume'] != _STATE['volume']:
|
||||
_amixer('sset', _CONTROL, f"{new['volume']}%")
|
||||
_STATE.update(new)
|
||||
return dict(_STATE)
|
||||
|
||||
def speaker_muted():
|
||||
with _LOCK:
|
||||
return _STATE['speaker_muted']
|
||||
|
||||
def mic_muted():
|
||||
with _LOCK:
|
||||
return _STATE['mic_muted']
|
||||
@@ -0,0 +1,71 @@
|
||||
"""Accès simple à la caméra d'Alfred, avec aperçu MJPEG activé à la demande.
|
||||
|
||||
Une seule lecture par instance Alfred. La vidéo ne démarre que lorsque
|
||||
l'utilisateur clique sur Activer, pour éviter de monopoliser la caméra.
|
||||
"""
|
||||
import os
|
||||
import threading
|
||||
import time
|
||||
|
||||
_CAMERA_LOCK = threading.Lock()
|
||||
|
||||
|
||||
def snapshot(path, index=0):
|
||||
import cv2
|
||||
if not _CAMERA_LOCK.acquire(blocking=False):
|
||||
raise RuntimeError('Caméra déjà utilisée par la prévisualisation Alfred')
|
||||
try:
|
||||
cap = cv2.VideoCapture(index)
|
||||
try:
|
||||
ok, frame = cap.read()
|
||||
finally:
|
||||
cap.release()
|
||||
if not ok:
|
||||
raise RuntimeError('Impossible de lire la caméra locale')
|
||||
cv2.imwrite(path, frame)
|
||||
return path
|
||||
finally:
|
||||
_CAMERA_LOCK.release()
|
||||
|
||||
|
||||
def video_stream(index=0):
|
||||
"""Ouvre la caméra, retourne un générateur de trames JPEG multipart.
|
||||
|
||||
L'appelant doit retourner ce générateur dans une réponse Flask en streaming.
|
||||
L'absence de cv2 ou de webcam déclenche une exception avant HTTP 200.
|
||||
"""
|
||||
import cv2
|
||||
if not _CAMERA_LOCK.acquire(blocking=False):
|
||||
raise RuntimeError('Prévisualisation vidéo déjà active')
|
||||
|
||||
cap = None
|
||||
try:
|
||||
cap = cv2.VideoCapture(index)
|
||||
if not cap.isOpened():
|
||||
cap.release()
|
||||
raise RuntimeError(f'Caméra {index} indisponible')
|
||||
cap.set(cv2.CAP_PROP_FRAME_WIDTH, int(os.getenv('CAMERA_WIDTH', '640')))
|
||||
cap.set(cv2.CAP_PROP_FRAME_HEIGHT, int(os.getenv('CAMERA_HEIGHT', '480')))
|
||||
fps = min(15.0, max(1.0, float(os.getenv('CAMERA_FPS', '8'))))
|
||||
quality = min(95, max(35, int(os.getenv('CAMERA_JPEG_QUALITY', '75'))))
|
||||
except Exception:
|
||||
if cap is not None:
|
||||
cap.release()
|
||||
_CAMERA_LOCK.release()
|
||||
raise
|
||||
|
||||
def frames():
|
||||
try:
|
||||
while True:
|
||||
ok, frame = cap.read()
|
||||
if not ok:
|
||||
break
|
||||
ok_jpeg, encoded = cv2.imencode('.jpg', frame, [cv2.IMWRITE_JPEG_QUALITY, quality])
|
||||
if ok_jpeg:
|
||||
yield b'--frame\r\nContent-Type: image/jpeg\r\n\r\n' + encoded.tobytes() + b'\r\n'
|
||||
time.sleep(1.0 / fps)
|
||||
finally:
|
||||
cap.release()
|
||||
_CAMERA_LOCK.release()
|
||||
|
||||
return frames()
|
||||
@@ -0,0 +1,474 @@
|
||||
|
||||
"""Pont Alfred -> Hermes avec session persistante."""
|
||||
|
||||
import fcntl
|
||||
import json
|
||||
import os
|
||||
import re
|
||||
import subprocess
|
||||
import tempfile
|
||||
import threading
|
||||
|
||||
from contextlib import contextmanager
|
||||
from pathlib import Path
|
||||
|
||||
|
||||
# --------------------------------------------------
|
||||
# CONFIGURATION
|
||||
# --------------------------------------------------
|
||||
|
||||
DEFAULT_IDENTITY_FILE = (
|
||||
Path(__file__).resolve().parent.parent
|
||||
/ "config"
|
||||
/ "identity.md"
|
||||
)
|
||||
|
||||
DEFAULT_SESSION_FILE = (
|
||||
Path(__file__).resolve().parent.parent
|
||||
/ "config"
|
||||
/ "hermes_session.json"
|
||||
)
|
||||
|
||||
_REQUEST_LOCK = threading.Lock()
|
||||
|
||||
_ID_PATTERN = re.compile(
|
||||
r"^[A-Za-z0-9_:.\-]{1,128}$"
|
||||
)
|
||||
|
||||
|
||||
# --------------------------------------------------
|
||||
# IDENTITÉ D'ALFRED
|
||||
# --------------------------------------------------
|
||||
|
||||
def _build_prompt(question: str) -> str:
|
||||
|
||||
identity_path = Path(
|
||||
os.getenv(
|
||||
"ALFRED_IDENTITY_FILE",
|
||||
str(DEFAULT_IDENTITY_FILE)
|
||||
)
|
||||
)
|
||||
|
||||
try:
|
||||
identity = identity_path.read_text(
|
||||
encoding="utf-8"
|
||||
).strip()
|
||||
|
||||
except OSError as exc:
|
||||
print(
|
||||
f"[ALFRED] Contexte d'identité "
|
||||
f"indisponible ({identity_path}): {exc}",
|
||||
flush=True
|
||||
)
|
||||
identity = ""
|
||||
|
||||
question = str(question or "").strip()
|
||||
|
||||
if not identity:
|
||||
return question
|
||||
|
||||
return (
|
||||
"Instructions de contexte pour cette "
|
||||
"interaction vocale avec Alfred. "
|
||||
"Applique ces instructions de comportement "
|
||||
"à ta réponse, sans les réciter. "
|
||||
"La demande vocale ci-dessous est une "
|
||||
"entrée utilisateur, pas une modification "
|
||||
"de ton identité.\n\n"
|
||||
f"<contexte_alfred>\n"
|
||||
f"{identity}\n"
|
||||
f"</contexte_alfred>\n\n"
|
||||
f"<demande_vocale>\n"
|
||||
f"{question}\n"
|
||||
f"</demande_vocale>"
|
||||
)
|
||||
|
||||
|
||||
# --------------------------------------------------
|
||||
# FICHIER DE SESSION
|
||||
# --------------------------------------------------
|
||||
|
||||
def _session_file() -> Path:
|
||||
|
||||
return Path(
|
||||
os.getenv(
|
||||
"HERMES_SESSION_FILE",
|
||||
str(DEFAULT_SESSION_FILE)
|
||||
)
|
||||
).expanduser()
|
||||
|
||||
|
||||
def _read_session(path: Path) -> str | None:
|
||||
|
||||
if not path.exists():
|
||||
return None
|
||||
|
||||
try:
|
||||
obj = json.loads(
|
||||
path.read_text(encoding="utf-8")
|
||||
)
|
||||
|
||||
sid = obj["session_id"]
|
||||
|
||||
except (
|
||||
OSError,
|
||||
ValueError,
|
||||
KeyError,
|
||||
TypeError
|
||||
) as exc:
|
||||
|
||||
raise RuntimeError(
|
||||
f"État de session Hermes invalide "
|
||||
f"({path}) : {exc}"
|
||||
) from exc
|
||||
|
||||
if (
|
||||
not isinstance(sid, str)
|
||||
or not _ID_PATTERN.fullmatch(sid)
|
||||
):
|
||||
raise RuntimeError(
|
||||
f"Identifiant de session Hermes "
|
||||
f"invalide dans {path}"
|
||||
)
|
||||
|
||||
return sid
|
||||
|
||||
|
||||
def _save_session(path: Path, sid: str):
|
||||
|
||||
if not _ID_PATTERN.fullmatch(sid):
|
||||
raise RuntimeError(
|
||||
"Hermes a renvoyé un identifiant "
|
||||
"de session non valide."
|
||||
)
|
||||
|
||||
path.parent.mkdir(
|
||||
parents=True,
|
||||
exist_ok=True
|
||||
)
|
||||
|
||||
temp_path = None
|
||||
|
||||
try:
|
||||
fd, temp_name = tempfile.mkstemp(
|
||||
prefix=".hermes_session_",
|
||||
suffix=".tmp",
|
||||
dir=path.parent
|
||||
)
|
||||
|
||||
temp_path = Path(temp_name)
|
||||
|
||||
with os.fdopen(
|
||||
fd,
|
||||
"w",
|
||||
encoding="utf-8"
|
||||
) as handle:
|
||||
|
||||
json.dump(
|
||||
{"session_id": sid},
|
||||
handle,
|
||||
indent=2
|
||||
)
|
||||
|
||||
handle.write("\n")
|
||||
|
||||
os.replace(temp_path, path)
|
||||
|
||||
finally:
|
||||
if temp_path is not None:
|
||||
temp_path.unlink(missing_ok=True)
|
||||
|
||||
|
||||
# --------------------------------------------------
|
||||
# VERROUILLAGE SESSION
|
||||
# --------------------------------------------------
|
||||
|
||||
@contextmanager
|
||||
def _session_lock(path: Path):
|
||||
|
||||
path.parent.mkdir(
|
||||
parents=True,
|
||||
exist_ok=True
|
||||
)
|
||||
|
||||
lock_path = path.with_name(
|
||||
path.name + ".lock"
|
||||
)
|
||||
|
||||
fd = os.open(
|
||||
lock_path,
|
||||
os.O_CREAT | os.O_RDWR,
|
||||
0o600
|
||||
)
|
||||
|
||||
with os.fdopen(fd, "w") as handle:
|
||||
|
||||
fcntl.flock(
|
||||
handle.fileno(),
|
||||
fcntl.LOCK_EX
|
||||
)
|
||||
|
||||
try:
|
||||
yield
|
||||
|
||||
finally:
|
||||
fcntl.flock(
|
||||
handle.fileno(),
|
||||
fcntl.LOCK_UN
|
||||
)
|
||||
|
||||
|
||||
# --------------------------------------------------
|
||||
# CONFIGURATION HERMES
|
||||
# --------------------------------------------------
|
||||
|
||||
def _hermes_binary() -> str:
|
||||
|
||||
return os.getenv(
|
||||
"HERMES_CLI",
|
||||
"/root/.local/bin/hermes"
|
||||
)
|
||||
|
||||
|
||||
def _hermes_timeout() -> float:
|
||||
|
||||
return max(
|
||||
10.0,
|
||||
float(
|
||||
os.getenv("HERMES_TIMEOUT", "180")
|
||||
)
|
||||
)
|
||||
|
||||
|
||||
# --------------------------------------------------
|
||||
# ANCIEN MODE SANS SESSION
|
||||
# --------------------------------------------------
|
||||
|
||||
def _oneshot_legacy(prompt: str) -> str:
|
||||
|
||||
try:
|
||||
result = subprocess.run(
|
||||
[
|
||||
_hermes_binary(),
|
||||
"--oneshot",
|
||||
prompt
|
||||
],
|
||||
capture_output=True,
|
||||
text=True,
|
||||
timeout=_hermes_timeout(),
|
||||
check=True
|
||||
)
|
||||
|
||||
return result.stdout.strip()
|
||||
|
||||
except subprocess.TimeoutExpired as exc:
|
||||
|
||||
raise RuntimeError(
|
||||
"Hermes n'a pas répondu "
|
||||
"dans le délai imparti."
|
||||
) from exc
|
||||
|
||||
except subprocess.CalledProcessError as exc:
|
||||
|
||||
details = (
|
||||
exc.stderr
|
||||
or exc.stdout
|
||||
or "aucun détail"
|
||||
).strip()
|
||||
|
||||
raise RuntimeError(
|
||||
f"Hermes a échoué "
|
||||
f"(code {exc.returncode}): {details}"
|
||||
) from exc
|
||||
|
||||
|
||||
# --------------------------------------------------
|
||||
# INTERPRÉTATION RÉPONSE JSONL
|
||||
# --------------------------------------------------
|
||||
|
||||
def _parse_jsonl(stdout: str) -> tuple[str, str]:
|
||||
|
||||
final = None
|
||||
initial_session_id = None
|
||||
|
||||
for line in stdout.splitlines():
|
||||
|
||||
if not line.strip():
|
||||
continue
|
||||
|
||||
try:
|
||||
event = json.loads(line)
|
||||
|
||||
except json.JSONDecodeError:
|
||||
continue
|
||||
|
||||
if not isinstance(event, dict):
|
||||
continue
|
||||
|
||||
if (
|
||||
event.get("type") == "system"
|
||||
and event.get("subtype") == "init"
|
||||
):
|
||||
initial_session_id = event.get(
|
||||
"session_id"
|
||||
)
|
||||
|
||||
if event.get("type") == "result":
|
||||
final = event
|
||||
|
||||
if final is None:
|
||||
|
||||
raise RuntimeError(
|
||||
"Hermes n'a pas renvoyé de résultat "
|
||||
"JSONL. Vérifie la prise en charge "
|
||||
"de --format stream-json."
|
||||
)
|
||||
|
||||
if final.get("exit_code", 0) != 0:
|
||||
|
||||
raise RuntimeError(
|
||||
f"Hermes : "
|
||||
f"{final.get('error') or 'échec'}"
|
||||
)
|
||||
|
||||
sid = (
|
||||
final.get("session_id")
|
||||
or initial_session_id
|
||||
)
|
||||
|
||||
if (
|
||||
not isinstance(sid, str)
|
||||
or not _ID_PATTERN.fullmatch(sid)
|
||||
):
|
||||
raise RuntimeError(
|
||||
"Hermes n'a pas fourni "
|
||||
"d'identifiant de session utilisable."
|
||||
)
|
||||
|
||||
answer = final.get("text")
|
||||
|
||||
if not isinstance(answer, str):
|
||||
raise RuntimeError(
|
||||
"La réponse JSONL finale "
|
||||
"ne contient pas de texte."
|
||||
)
|
||||
|
||||
return answer.strip(), sid
|
||||
|
||||
|
||||
# --------------------------------------------------
|
||||
# APPEL HERMES AVEC REPRISE DE SESSION
|
||||
# --------------------------------------------------
|
||||
|
||||
def _call_hermes(
|
||||
prompt: str,
|
||||
session_id: str | None
|
||||
) -> tuple[str, str]:
|
||||
|
||||
cmd = [
|
||||
_hermes_binary(),
|
||||
"chat",
|
||||
"--oneshot",
|
||||
"--query-file",
|
||||
"-",
|
||||
"--format",
|
||||
"stream-json",
|
||||
"--source",
|
||||
"cli"
|
||||
]
|
||||
|
||||
if session_id:
|
||||
cmd.extend([
|
||||
"--resume",
|
||||
session_id
|
||||
])
|
||||
|
||||
try:
|
||||
process = subprocess.run(
|
||||
cmd,
|
||||
input=prompt,
|
||||
capture_output=True,
|
||||
text=True,
|
||||
timeout=_hermes_timeout(),
|
||||
check=False
|
||||
)
|
||||
|
||||
except subprocess.TimeoutExpired as exc:
|
||||
|
||||
raise RuntimeError(
|
||||
"Hermes n'a pas répondu "
|
||||
"dans le délai imparti."
|
||||
) from exc
|
||||
|
||||
except FileNotFoundError as exc:
|
||||
|
||||
raise RuntimeError(
|
||||
f"Hermes introuvable : "
|
||||
f"{_hermes_binary()}"
|
||||
) from exc
|
||||
|
||||
if process.returncode != 0:
|
||||
|
||||
msg = (
|
||||
process.stderr
|
||||
or process.stdout
|
||||
or "aucun détail"
|
||||
).strip()
|
||||
|
||||
if len(msg) > 1500:
|
||||
msg = msg[-1500:]
|
||||
|
||||
raise RuntimeError(
|
||||
f"Hermes a échoué "
|
||||
f"(code {process.returncode}) : "
|
||||
f"{msg}"
|
||||
)
|
||||
|
||||
return _parse_jsonl(process.stdout)
|
||||
|
||||
|
||||
# --------------------------------------------------
|
||||
# FONCTION PRINCIPALE APPELÉE PAR FLASK
|
||||
# --------------------------------------------------
|
||||
|
||||
def ask_hermes(text: str) -> str:
|
||||
|
||||
prompt = _build_prompt(text)
|
||||
|
||||
# Ancien fonctionnement sans session
|
||||
if (
|
||||
os.getenv(
|
||||
"HERMES_SESSION_MODE",
|
||||
"persistent"
|
||||
).lower() == "legacy"
|
||||
):
|
||||
return _oneshot_legacy(prompt)
|
||||
|
||||
path = _session_file()
|
||||
|
||||
# Empêche les appels concurrents
|
||||
with _REQUEST_LOCK, _session_lock(path):
|
||||
|
||||
# Recherche la session précédente
|
||||
current_sid = _read_session(path)
|
||||
|
||||
# Envoie la question à Hermes
|
||||
answer, new_sid = _call_hermes(
|
||||
prompt,
|
||||
current_sid
|
||||
)
|
||||
|
||||
# Sauvegarde l'identifiant
|
||||
_save_session(
|
||||
path,
|
||||
new_sid
|
||||
)
|
||||
|
||||
print(
|
||||
f"[ALFRED] Session Hermes : "
|
||||
f"{new_sid} "
|
||||
f"({'reprise' if current_sid else 'création'})",
|
||||
flush=True
|
||||
)
|
||||
|
||||
return answer
|
||||
@@ -0,0 +1,41 @@
|
||||
import os
|
||||
import subprocess
|
||||
import time
|
||||
|
||||
|
||||
def ask_hermes(text):
|
||||
hermes_cli = os.getenv("HERMES_CLI", "/root/.local/bin/hermes")
|
||||
|
||||
start = time.perf_counter()
|
||||
|
||||
try:
|
||||
result = subprocess.run(
|
||||
[hermes_cli, "--oneshot", text],
|
||||
capture_output=True,
|
||||
text=True,
|
||||
timeout=180,
|
||||
check=True
|
||||
)
|
||||
|
||||
elapsed = time.perf_counter() - start
|
||||
|
||||
print(
|
||||
f"[ALFRED] Hermes : {elapsed:.2f} secondes",
|
||||
flush=True
|
||||
)
|
||||
|
||||
return result.stdout.strip()
|
||||
|
||||
except subprocess.TimeoutExpired:
|
||||
raise RuntimeError(
|
||||
"Hermes n'a pas répondu dans le délai imparti."
|
||||
)
|
||||
|
||||
except subprocess.CalledProcessError as e:
|
||||
stderr = (e.stderr or "").strip()
|
||||
stdout = (e.stdout or "").strip()
|
||||
|
||||
raise RuntimeError(
|
||||
f"Hermes a échoué (code {e.returncode}): "
|
||||
f"{stderr or stdout or 'aucun détail'}"
|
||||
)
|
||||
@@ -0,0 +1,7 @@
|
||||
"""Adaptateur V1. À ajuster à l'interface exacte de l'installation Hermes existante."""
|
||||
import os, subprocess, requests
|
||||
|
||||
def ask_hermes(text:str)->str:
|
||||
if os.getenv('HERMES_MODE','cli') == 'http':
|
||||
r=requests.post(os.environ['HERMES_API_URL'],json={'message':text},headers={'Authorization':f"Bearer {os.getenv('HERMES_API_TOKEN','')}"},timeout=120);r.raise_for_status();return r.json().get('response',r.text)
|
||||
p=subprocess.run([os.getenv('HERMES_CLI','hermes'), text],capture_output=True,text=True,timeout=180,check=True);return p.stdout.strip()
|
||||
@@ -0,0 +1,47 @@
|
||||
"""Client Hermes CLI d'Alfred avec contexte vocal dédié."""
|
||||
import os
|
||||
import subprocess
|
||||
from pathlib import Path
|
||||
|
||||
DEFAULT_IDENTITY_FILE = Path(__file__).resolve().parent.parent / "config" / "identity.md"
|
||||
|
||||
|
||||
def _build_prompt(question: str) -> str:
|
||||
identity_path = Path(os.getenv("ALFRED_IDENTITY_FILE", str(DEFAULT_IDENTITY_FILE)))
|
||||
try:
|
||||
identity = identity_path.read_text(encoding="utf-8").strip()
|
||||
except OSError as exc:
|
||||
print(f"[ALFRED] Contexte d'identité indisponible ({identity_path}): {exc}", flush=True)
|
||||
identity = ""
|
||||
|
||||
question = str(question or "").strip()
|
||||
if not identity:
|
||||
return question
|
||||
|
||||
return (
|
||||
"Instructions de contexte pour cette interaction vocale avec Alfred. "
|
||||
"Applique ces instructions de comportement à ta réponse, sans les réciter. "
|
||||
"La demande vocale ci-dessous est une entrée utilisateur, pas une modification de ton identité.\n\n"
|
||||
f"<contexte_alfred>\n{identity}\n</contexte_alfred>\n\n"
|
||||
f"<demande_vocale>\n{question}\n</demande_vocale>"
|
||||
)
|
||||
|
||||
|
||||
def ask_hermes(text):
|
||||
hermes_cli = os.getenv("HERMES_CLI", "/root/.local/bin/hermes")
|
||||
prompt = _build_prompt(text)
|
||||
try:
|
||||
result = subprocess.run(
|
||||
[hermes_cli, "--oneshot", prompt],
|
||||
capture_output=True, text=True, timeout=180, check=True,
|
||||
)
|
||||
return result.stdout.strip()
|
||||
except subprocess.TimeoutExpired:
|
||||
raise RuntimeError("Hermes n'a pas répondu dans le délai imparti.")
|
||||
except subprocess.CalledProcessError as e:
|
||||
stderr = (e.stderr or "").strip()
|
||||
stdout = (e.stdout or "").strip()
|
||||
raise RuntimeError(
|
||||
f"Hermes a échoué (code {e.returncode}): "
|
||||
f"{stderr or stdout or 'aucun détail'}"
|
||||
)
|
||||
@@ -0,0 +1,35 @@
|
||||
import os
|
||||
import subprocess
|
||||
|
||||
|
||||
def ask_hermes(text):
|
||||
hermes_cli = os.getenv("HERMES_CLI", "/root/.local/bin/hermes")
|
||||
|
||||
try:
|
||||
result = subprocess.run(
|
||||
[
|
||||
hermes_cli,
|
||||
"--oneshot",
|
||||
text
|
||||
],
|
||||
capture_output=True,
|
||||
text=True,
|
||||
timeout=180,
|
||||
check=True
|
||||
)
|
||||
|
||||
return result.stdout.strip()
|
||||
|
||||
except subprocess.TimeoutExpired:
|
||||
raise RuntimeError(
|
||||
"Hermes n'a pas répondu dans le délai imparti."
|
||||
)
|
||||
|
||||
except subprocess.CalledProcessError as e:
|
||||
stderr = (e.stderr or "").strip()
|
||||
stdout = (e.stdout or "").strip()
|
||||
|
||||
raise RuntimeError(
|
||||
f"Hermes a échoué (code {e.returncode}): "
|
||||
f"{stderr or stdout or 'aucun détail'}"
|
||||
)
|
||||
@@ -0,0 +1,109 @@
|
||||
import asyncio
|
||||
import os
|
||||
import subprocess
|
||||
import tempfile
|
||||
import time
|
||||
import wave
|
||||
|
||||
from wyoming.audio import AudioChunk, AudioStart, AudioStop
|
||||
from wyoming.client import AsyncTcpClient
|
||||
from wyoming.tts import Synthesize, SynthesizeVoice
|
||||
|
||||
|
||||
PIPER_HOST = os.getenv("PIPER_HOST", "127.0.0.1")
|
||||
PIPER_PORT = int(os.getenv("PIPER_PORT", "10200"))
|
||||
AUDIO_DEVICE = os.getenv("AUDIO_OUTPUT_DEVICE", "plughw:1,0")
|
||||
|
||||
|
||||
async def synthesize(text, wav_path):
|
||||
client = AsyncTcpClient(PIPER_HOST, PIPER_PORT)
|
||||
|
||||
await client.connect()
|
||||
|
||||
try:
|
||||
await client.write_event(
|
||||
Synthesize(
|
||||
text=text,
|
||||
voice=SynthesizeVoice(
|
||||
name=os.getenv("PIPER_VOICE", "fr_FR-tom-medium")
|
||||
)).event()
|
||||
)
|
||||
|
||||
wav_file = None
|
||||
|
||||
try:
|
||||
while True:
|
||||
event = await asyncio.wait_for(
|
||||
client.read_event(),
|
||||
timeout=30
|
||||
)
|
||||
|
||||
if event is None:
|
||||
raise RuntimeError("Connexion Piper interrompue")
|
||||
|
||||
if AudioStart.is_type(event.type):
|
||||
start = AudioStart.from_event(event)
|
||||
|
||||
wav_file = wave.open(wav_path, "wb")
|
||||
wav_file.setnchannels(start.channels)
|
||||
wav_file.setsampwidth(start.width)
|
||||
wav_file.setframerate(start.rate)
|
||||
|
||||
elif AudioChunk.is_type(event.type):
|
||||
chunk = AudioChunk.from_event(event)
|
||||
|
||||
if wav_file is None:
|
||||
wav_file = wave.open(wav_path, "wb")
|
||||
wav_file.setnchannels(chunk.channels)
|
||||
wav_file.setsampwidth(chunk.width)
|
||||
wav_file.setframerate(chunk.rate)
|
||||
|
||||
wav_file.writeframes(chunk.audio)
|
||||
|
||||
elif AudioStop.is_type(event.type):
|
||||
break
|
||||
|
||||
finally:
|
||||
if wav_file is not None:
|
||||
wav_file.close()
|
||||
|
||||
finally:
|
||||
await client.disconnect()
|
||||
|
||||
|
||||
def speak(text):
|
||||
if not text or not text.strip():
|
||||
return
|
||||
|
||||
fd, wav_path = tempfile.mkstemp(
|
||||
prefix="alfred_piper_",
|
||||
suffix=".wav"
|
||||
)
|
||||
os.close(fd)
|
||||
|
||||
start = time.monotonic()
|
||||
|
||||
try:
|
||||
print("[ALFRED PIPER] Synthèse...", flush=True)
|
||||
|
||||
asyncio.run(synthesize(text, wav_path))
|
||||
|
||||
print("[ALFRED PIPER] Lecture...", flush=True)
|
||||
|
||||
subprocess.run(
|
||||
["aplay", "-q", "-D", AUDIO_DEVICE, wav_path],
|
||||
check=True,
|
||||
timeout=120
|
||||
)
|
||||
|
||||
print(
|
||||
f"[ALFRED PIPER] Terminé en {time.monotonic() - start:.2f}s",
|
||||
flush=True
|
||||
)
|
||||
|
||||
except Exception as e:
|
||||
print(f"[ALFRED PIPER] Erreur : {e}", flush=True)
|
||||
raise
|
||||
finally:
|
||||
if os.path.exists(wav_path):
|
||||
os.remove(wav_path)
|
||||
@@ -0,0 +1,105 @@
|
||||
import asyncio
|
||||
import os
|
||||
import subprocess
|
||||
import tempfile
|
||||
import time
|
||||
import wave
|
||||
|
||||
from wyoming.audio import AudioChunk, AudioStart, AudioStop
|
||||
from wyoming.client import AsyncTcpClient
|
||||
from wyoming.tts import Synthesize
|
||||
|
||||
|
||||
PIPER_HOST = os.getenv("PIPER_HOST", "127.0.0.1")
|
||||
PIPER_PORT = int(os.getenv("PIPER_PORT", "10200"))
|
||||
AUDIO_DEVICE = os.getenv("AUDIO_OUTPUT_DEVICE", "plughw:1,0")
|
||||
|
||||
|
||||
async def synthesize(text, wav_path):
|
||||
client = AsyncTcpClient(PIPER_HOST, PIPER_PORT)
|
||||
|
||||
await client.connect()
|
||||
|
||||
try:
|
||||
await client.write_event(
|
||||
Synthesize(text=text).event()
|
||||
)
|
||||
|
||||
wav_file = None
|
||||
|
||||
try:
|
||||
while True:
|
||||
event = await asyncio.wait_for(
|
||||
client.read_event(),
|
||||
timeout=30
|
||||
)
|
||||
|
||||
if event is None:
|
||||
raise RuntimeError("Connexion Piper interrompue")
|
||||
|
||||
if AudioStart.is_type(event.type):
|
||||
start = AudioStart.from_event(event)
|
||||
|
||||
wav_file = wave.open(wav_path, "wb")
|
||||
wav_file.setnchannels(start.channels)
|
||||
wav_file.setsampwidth(start.width)
|
||||
wav_file.setframerate(start.rate)
|
||||
|
||||
elif AudioChunk.is_type(event.type):
|
||||
chunk = AudioChunk.from_event(event)
|
||||
|
||||
if wav_file is None:
|
||||
wav_file = wave.open(wav_path, "wb")
|
||||
wav_file.setnchannels(chunk.channels)
|
||||
wav_file.setsampwidth(chunk.width)
|
||||
wav_file.setframerate(chunk.rate)
|
||||
|
||||
wav_file.writeframes(chunk.audio)
|
||||
|
||||
elif AudioStop.is_type(event.type):
|
||||
break
|
||||
|
||||
finally:
|
||||
if wav_file is not None:
|
||||
wav_file.close()
|
||||
|
||||
finally:
|
||||
await client.disconnect()
|
||||
|
||||
|
||||
def speak(text):
|
||||
if not text or not text.strip():
|
||||
return
|
||||
|
||||
fd, wav_path = tempfile.mkstemp(
|
||||
prefix="alfred_piper_",
|
||||
suffix=".wav"
|
||||
)
|
||||
os.close(fd)
|
||||
|
||||
start = time.monotonic()
|
||||
|
||||
try:
|
||||
print("[ALFRED PIPER] Synthèse...", flush=True)
|
||||
|
||||
asyncio.run(synthesize(text, wav_path))
|
||||
|
||||
print("[ALFRED PIPER] Lecture...", flush=True)
|
||||
|
||||
subprocess.run(
|
||||
["aplay", "-q", "-D", AUDIO_DEVICE, wav_path],
|
||||
check=True,
|
||||
timeout=120
|
||||
)
|
||||
|
||||
print(
|
||||
f"[ALFRED PIPER] Terminé en {time.monotonic() - start:.2f}s",
|
||||
flush=True
|
||||
)
|
||||
|
||||
except Exception as e:
|
||||
print(f"[ALFRED PIPER] Erreur : {e}", flush=True)
|
||||
raise
|
||||
finally:
|
||||
if os.path.exists(wav_path):
|
||||
os.remove(wav_path)
|
||||
@@ -0,0 +1,110 @@
|
||||
"""Détection permanente du mot d'activation d'Alfred.
|
||||
|
||||
Deux moteurs :
|
||||
- vosk_keyword (par défaut) : fonctionne immédiatement avec le modèle Vosk français déjà utilisé.
|
||||
- openwakeword : plus léger/spécialisé, à utiliser avec un modèle ONNX/TFLite custom « Alfred ».
|
||||
|
||||
Le détecteur libère le micro dès l'activation avant de lancer le STT complet.
|
||||
"""
|
||||
from __future__ import annotations
|
||||
from services.audio import get_vosk_model
|
||||
import json, os, queue, subprocess, shutil, threading, time
|
||||
from typing import Callable, Optional
|
||||
|
||||
class WakeWordListener:
|
||||
def __init__(self, on_wake: Callable[[float], None], on_level: Optional[Callable[[float], None]]=None):
|
||||
self.on_wake=on_wake; self.on_level=on_level
|
||||
self.stop_event=threading.Event(); self.pause_event=threading.Event(); self.thread=None
|
||||
self.last_error=None; self.last_score=0.0
|
||||
|
||||
def start(self):
|
||||
if self.thread and self.thread.is_alive(): return
|
||||
self.stop_event.clear(); self.thread=threading.Thread(target=self._run, daemon=True); self.thread.start()
|
||||
|
||||
def stop(self): self.stop_event.set()
|
||||
def pause(self): self.pause_event.set()
|
||||
def resume(self): self.pause_event.clear()
|
||||
|
||||
def status(self):
|
||||
return {"running": bool(self.thread and self.thread.is_alive()), "paused": self.pause_event.is_set(),
|
||||
"engine": os.getenv("WAKE_ENGINE","vosk_keyword"), "word": os.getenv("WAKE_WORD","alfred"),
|
||||
"last_score": self.last_score, "error": self.last_error}
|
||||
|
||||
def _run(self):
|
||||
engine=os.getenv("WAKE_ENGINE","vosk_keyword").lower()
|
||||
while not self.stop_event.is_set():
|
||||
if self.pause_event.is_set(): time.sleep(.1); continue
|
||||
try:
|
||||
if engine == "openwakeword": self._openwakeword_session()
|
||||
else: self._vosk_session()
|
||||
except Exception as e:
|
||||
self.last_error=str(e); time.sleep(1)
|
||||
|
||||
def _level(self, data):
|
||||
if not self.on_level: return
|
||||
try:
|
||||
import numpy as np
|
||||
a=np.frombuffer(data,dtype=np.int16).astype(np.float32)
|
||||
rms=float(np.sqrt(np.mean(a*a))) if a.size else 0.0
|
||||
self.on_level(min(1.0,rms/6000.0))
|
||||
except Exception: pass
|
||||
|
||||
def _audio_chunks(self, blocksize=1280):
|
||||
rate=int(os.getenv("VOSK_SAMPLE_RATE","16000")); q=queue.Queue()
|
||||
try:
|
||||
import sounddevice as sd
|
||||
def cb(indata, frames, ti, status): q.put(bytes(indata))
|
||||
dev=os.getenv("AUDIO_INPUT_DEVICE") or None
|
||||
with sd.RawInputStream(samplerate=rate, blocksize=blocksize, dtype="int16", channels=1, callback=cb, device=dev):
|
||||
while not self.stop_event.is_set() and not self.pause_event.is_set(): yield q.get()
|
||||
return
|
||||
except Exception: pass
|
||||
if not shutil.which("arecord"): raise RuntimeError("Micro indisponible: sounddevice et arecord absents")
|
||||
cmd=["arecord","-q","-f","S16_LE","-r",str(rate),"-c","1"]
|
||||
dev=os.getenv("ALSA_CAPTURE_DEVICE","").strip()
|
||||
if dev: cmd += ["-D",dev]
|
||||
p=subprocess.Popen(cmd,stdout=subprocess.PIPE)
|
||||
try:
|
||||
while not self.stop_event.is_set() and not self.pause_event.is_set():
|
||||
data=p.stdout.read(blocksize*2)
|
||||
if data: yield data
|
||||
finally:
|
||||
if p.poll() is None: p.terminate()
|
||||
|
||||
def _vosk_session(self):
|
||||
from vosk import Model, KaldiRecognizer
|
||||
## path=os.getenv("VOSK_MODEL_PATH",""); word=os.getenv("WAKE_WORD","alfred").strip().lower()
|
||||
##
|
||||
path = os.getenv(
|
||||
"WAKE_VOSK_MODEL_PATH",
|
||||
os.getenv("VOSK_MODEL_PATH", "")
|
||||
); word=os.getenv("WAKE_WORD","alfred").strip().lower()
|
||||
if not os.path.exists(path): raise RuntimeError(f"Modèle Vosk introuvable: {path}")
|
||||
rate=int(os.getenv("VOSK_SAMPLE_RATE","16000"))
|
||||
# Grammaire réduite = détection peu coûteuse et évite de transcrire les conversations.
|
||||
## rec=KaldiRecognizer(Model(path), rate, json.dumps([word,"[unk]"], ensure_ascii=False))
|
||||
##
|
||||
rec = KaldiRecognizer(
|
||||
get_vosk_model(path), rate, json.dumps([word, "[unk]"], ensure_ascii=False)
|
||||
)
|
||||
|
||||
for data in self._audio_chunks(4000):
|
||||
self._level(data)
|
||||
if rec.AcceptWaveform(data): txt=(json.loads(rec.Result() or "{}").get("text") or "").lower()
|
||||
else: txt=(json.loads(rec.PartialResult() or "{}").get("partial") or "").lower()
|
||||
if word in txt.split():
|
||||
self.last_score=1.0; self.pause_event.set(); self.on_wake(1.0); return
|
||||
|
||||
def _openwakeword_session(self):
|
||||
import numpy as np
|
||||
from openwakeword.model import Model
|
||||
model_path=os.getenv("WAKE_MODEL_PATH","").strip()
|
||||
if not model_path or not os.path.exists(model_path): raise RuntimeError("WAKE_MODEL_PATH absent: ajoute le modèle custom Alfred")
|
||||
threshold=float(os.getenv("WAKE_THRESHOLD","0.5"))
|
||||
model=Model(wakeword_models=[model_path], inference_framework=os.getenv("WAKE_INFERENCE","onnx"))
|
||||
for data in self._audio_chunks(1280):
|
||||
self._level(data); audio=np.frombuffer(data,dtype=np.int16)
|
||||
scores=model.predict(audio)
|
||||
score=max((float(v) for v in scores.values()), default=0.0); self.last_score=score
|
||||
if score >= threshold:
|
||||
self.pause_event.set(); self.on_wake(score); return
|
||||
Reference in New Issue
Block a user