Init commit

alfred/app.backup/app.py

@@ -0,0 +1,166 @@
+import os, threading
+from flask import Flask, render_template, request, jsonify
+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
+
+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":""}
+conversation_lock=threading.Lock()
+mic_stop_event=threading.Event()
+audio_settings.initialize()
+
+def emit_state(mode=None, **extra):
+    if mode: STATE["mode"]=mode
+    STATE.update(extra); socketio.emit("alfred_state",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="", 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)
+        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}
+
+        STATE["content"] = display
+        socketio.emit("alfred_render", display)
+
+        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("/")
+def index(): return render_template("index.html",name=os.getenv("ALFRED_NAME","Alfred"))
+@app.get("/api/state")
+def state(): return jsonify({**STATE,"wake":wake.status(),"tts":tts_backend_detect()})
+@app.post("/api/state")
+def set_state():
+    STATE.update(request.get_json(force=True)); socketio.emit("alfred_state",STATE); return jsonify({"ok":True})
+@app.post("/api/render")
+def render_payload():
+    data=request.get_json(force=True); STATE["content"]=data; socketio.emit("alfred_render",data); return jsonify({"ok":True})
+@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)