227 lines
8.0 KiB
Python
227 lines
8.0 KiB
Python
import os, threading, hmac
|
|
from flask import Flask, render_template, request, jsonify, Response
|
|
from flask_socketio import SocketIO
|
|
from dotenv import load_dotenv
|
|
from services.audio import listen_once, speak_async, tts_backend_detect
|
|
from services.wakeword import WakeWordListener
|
|
from services.hermes_client import ask_hermes
|
|
from services import audio_settings # ALFRED_AUDIO_SETTINGS_V1
|
|
from services.camera import video_stream
|
|
|
|
load_dotenv()
|
|
|
|
##
|
|
from services.audio import get_vosk_model
|
|
print("[ALFRED] Préchargement des modèles vocaux...", flush=True)
|
|
get_vosk_model(os.environ["WAKE_VOSK_MODEL_PATH"])
|
|
get_vosk_model(os.environ["VOSK_MODEL_PATH"])
|
|
print("[ALFRED] Modèles vocaux prêts.", flush=True)
|
|
##
|
|
app=Flask(__name__); socketio=SocketIO(app,cors_allowed_origins="*")
|
|
STATE={"mode":"idle","title":"Alfred","content":{"type":"text","text":"À votre écoute."},"partial":""}
|
|
STATE_LOCK = threading.RLock()
|
|
IMAGE_REVISION = 0 # Incrémenté à chaque image envoyée par ComfyUI.
|
|
conversation_lock=threading.Lock()
|
|
mic_stop_event=threading.Event()
|
|
audio_settings.initialize()
|
|
audio_settings.update_settings({"mic_gain": 30})
|
|
|
|
def emit_state(mode=None, **extra):
|
|
with STATE_LOCK:
|
|
if mode: STATE["mode"] = mode
|
|
STATE.update(extra)
|
|
socketio.emit("alfred_state", dict(STATE))
|
|
|
|
def audio_level(level): socketio.emit("audio_level",{"level":max(0,min(float(level),1))})
|
|
|
|
def conversation(score=1.0):
|
|
if not conversation_lock.acquire(blocking=False):
|
|
return
|
|
|
|
try:
|
|
emit_state("listening", partial="", transcript="", wake_score=score)
|
|
|
|
print("[ALFRED] Début écoute STT", flush=True)
|
|
|
|
r = listen_once(
|
|
stop_event=mic_stop_event,
|
|
on_partial=lambda p: emit_state("listening", partial=p),
|
|
on_level=audio_level
|
|
)
|
|
|
|
print(f"[ALFRED] Résultat STT : {r.text!r}, erreur : {r.error!r}", flush=True)
|
|
|
|
if audio_settings.mic_muted():
|
|
emit_state("idle", partial="")
|
|
return
|
|
|
|
if r.error:
|
|
emit_state(
|
|
"error",
|
|
content={"type": "text", "text": r.error}
|
|
)
|
|
return
|
|
|
|
if not r.text:
|
|
emit_state("idle", partial="")
|
|
return
|
|
|
|
emit_state(
|
|
"thinking",
|
|
partial="",
|
|
transcript=r.text,
|
|
content={"type": "text", "text": r.text}
|
|
)
|
|
|
|
print("[ALFRED] Envoi à Hermes", flush=True)
|
|
# ComfyUI publie l'image pendant cet appel Hermes.
|
|
with STATE_LOCK:
|
|
image_revision_before = IMAGE_REVISION
|
|
answer = ask_hermes(r.text)
|
|
print(f"[ALFRED] Réponse Hermes : {answer!r}", flush=True)
|
|
if isinstance(answer, dict):
|
|
speech = str(answer.get("speech") or answer.get("text") or "")
|
|
display = answer.get("display") or {
|
|
"type": "text",
|
|
"text": speech
|
|
}
|
|
else:
|
|
speech = str(answer or "")
|
|
display = {"type": "text", "text": speech}
|
|
|
|
# Si le MCP ComfyUI a affiché une image pendant la requête,
|
|
# ne pas l'écraser par la réponse textuelle d'Hermes.
|
|
with STATE_LOCK:
|
|
if IMAGE_REVISION == image_revision_before:
|
|
STATE["content"] = display
|
|
socketio.emit("alfred_render", display)
|
|
else:
|
|
print("[ALFRED] Image ComfyUI conservée à l'écran", flush=True)
|
|
|
|
if speech and not audio_settings.speaker_muted():
|
|
emit_state("speaking")
|
|
done = threading.Event()
|
|
speak_async(speech, on_end=done.set)
|
|
done.wait(timeout=120)
|
|
|
|
emit_state("idle", partial="")
|
|
|
|
except Exception as exc:
|
|
print(f"[ALFRED] Erreur conversation : {exc}", flush=True)
|
|
emit_state(
|
|
"error",
|
|
content={"type": "text", "text": str(exc)}
|
|
)
|
|
|
|
finally:
|
|
conversation_lock.release()
|
|
if not audio_settings.mic_muted():
|
|
wake.resume()
|
|
print("[ALFRED] Wake word réactivé", flush=True)
|
|
|
|
|
|
|
|
def on_wake(score):
|
|
if audio_settings.mic_muted():
|
|
return
|
|
socketio.emit("wake_detected",{"word":os.getenv("WAKE_WORD","alfred"),"score":score})
|
|
threading.Thread(target=conversation,args=(score,),daemon=True).start()
|
|
|
|
wake=WakeWordListener(on_wake=on_wake,on_level=lambda l: audio_level(l if STATE["mode"]!="idle" else l*.18))
|
|
|
|
@app.get('/api/audio/settings')
|
|
def get_audio_settings():
|
|
return jsonify(audio_settings.get_settings())
|
|
|
|
@app.post('/api/audio/settings')
|
|
def set_audio_settings():
|
|
data = request.get_json(silent=True)
|
|
try:
|
|
old = audio_settings.get_settings()
|
|
new = audio_settings.update_settings(data)
|
|
except ValueError as exc:
|
|
return jsonify({'error': str(exc)}), 400
|
|
except Exception as exc:
|
|
return jsonify({'error': f'ALSA : {exc}'}), 500
|
|
if new['mic_muted'] != old['mic_muted']:
|
|
if new['mic_muted']:
|
|
mic_stop_event.set()
|
|
wake.pause()
|
|
else:
|
|
mic_stop_event.clear()
|
|
if not conversation_lock.locked():
|
|
wake.resume()
|
|
socketio.emit('audio_settings', new)
|
|
return jsonify(new)
|
|
|
|
@app.get('/api/camera/stream')
|
|
def camera_stream():
|
|
# Flux MJPEG à la demande ; ne démarre jamais la webcam en arrière-plan.
|
|
try:
|
|
frames = video_stream(index=int(os.getenv('CAMERA_INDEX', '0')))
|
|
except (ImportError, ValueError, RuntimeError, OSError) as exc:
|
|
return jsonify({'error': str(exc)}), 503
|
|
return Response(
|
|
frames,
|
|
mimetype='multipart/x-mixed-replace; boundary=frame',
|
|
headers={'Cache-Control': 'no-store', 'X-Content-Type-Options': 'nosniff'}
|
|
)
|
|
|
|
@app.get("/")
|
|
def index(): return render_template("index.html",name=os.getenv("ALFRED_NAME","Alfred"))
|
|
@app.get("/api/state")
|
|
def state():
|
|
with STATE_LOCK:
|
|
snapshot = dict(STATE)
|
|
return jsonify({**snapshot, "wake": wake.status(), "tts": tts_backend_detect()})
|
|
|
|
@app.post("/api/state")
|
|
def set_state():
|
|
data = request.get_json(force=True)
|
|
with STATE_LOCK:
|
|
STATE.update(data)
|
|
socketio.emit("alfred_state", dict(STATE))
|
|
return jsonify({"ok": True})
|
|
@app.post("/api/render")
|
|
def render_payload():
|
|
global IMAGE_REVISION
|
|
token = os.getenv("ALFRED_RENDER_TOKEN", "").strip()
|
|
if token and not hmac.compare_digest(
|
|
request.headers.get("X-Alfred-Render-Token", ""), token
|
|
):
|
|
return jsonify({"ok": False, "error": "Non autorisé"}), 401
|
|
|
|
data = request.get_json(silent=True)
|
|
if not isinstance(data, dict):
|
|
return jsonify({"ok": False, "error": "JSON objet attendu"}), 400
|
|
if data.get("type") == "image":
|
|
image_url = data.get("url")
|
|
if not isinstance(image_url, str) or not (
|
|
image_url.startswith(("http://", "https://", "/"))
|
|
and not image_url.startswith("//")
|
|
):
|
|
return jsonify({"ok": False, "error": "URL image invalide"}), 400
|
|
|
|
with STATE_LOCK:
|
|
if data.get("type") == "image":
|
|
IMAGE_REVISION += 1
|
|
STATE["content"] = data
|
|
socketio.emit("alfred_render", data)
|
|
return jsonify({"ok": True, "image_revision": IMAGE_REVISION})
|
|
@app.post("/api/audio-level")
|
|
def api_audio_level(): audio_level((request.get_json(force=True) or {}).get("level",0)); return jsonify({"ok":True})
|
|
@app.get("/api/wake/status")
|
|
def wake_status(): return jsonify(wake.status())
|
|
@app.post("/api/wake/start")
|
|
def wake_start(): wake.start(); return jsonify({"ok":True,**wake.status()})
|
|
@app.post("/api/wake/stop")
|
|
def wake_stop(): wake.stop(); return jsonify({"ok":True,**wake.status()})
|
|
@app.post("/api/tts/say")
|
|
def tts_say():
|
|
text=(request.get_json(silent=True) or {}).get("text",""); return jsonify({"ok":speak_async(text)})
|
|
|
|
if __name__ == "__main__":
|
|
if os.getenv("WAKE_ENABLED","true").lower() in ("1","true","yes","on") and not audio_settings.mic_muted(): wake.start()
|
|
socketio.run(app,host=os.getenv("FLASK_HOST","0.0.0.0"),port=int(os.getenv("FLASK_PORT","54321")),allow_unsafe_werkzeug=True)
|
|
|