469 lines
15 KiB
Python
469 lines
15 KiB
Python
"""Wake word settings."""
|
|
import itertools
|
|
import re
|
|
import shutil
|
|
from pathlib import Path
|
|
from typing import Dict, Optional
|
|
|
|
from .const import LOCAL_DIR, SatelliteType, Settings, WakeWordSystem
|
|
from .packages import install_packages, packages_installed
|
|
from .whiptail import (
|
|
error,
|
|
inputbox,
|
|
menu,
|
|
msgbox,
|
|
passwordbox,
|
|
radiolist,
|
|
run_with_gauge,
|
|
yesno,
|
|
)
|
|
|
|
|
|
def configure_wake_word(settings: Settings) -> None:
|
|
if settings.satellite.type != SatelliteType.WAKE:
|
|
if not yesno("Set satellite type to local wake word?"):
|
|
return
|
|
|
|
settings.satellite.type = SatelliteType.WAKE
|
|
settings.save()
|
|
|
|
def star(ww_system: WakeWordSystem) -> str:
|
|
return (
|
|
f"{ww_system.value} [*]"
|
|
if settings.wake.system == ww_system
|
|
else ww_system.value
|
|
)
|
|
|
|
choice: Optional[str] = None
|
|
while True:
|
|
choice = menu(
|
|
"Main > Wake Word",
|
|
[
|
|
("system", "Wake Word System"),
|
|
("wake_word", "Choose Wake Word"),
|
|
("openWakeWord", star(WakeWordSystem.OPENWAKEWORD)),
|
|
("porcupine1", star(WakeWordSystem.PORCUPINE1)),
|
|
("snowboy", star(WakeWordSystem.SNOWBOY)),
|
|
],
|
|
selected_item=choice,
|
|
menu_args=["--ok-button", "Select", "--cancel-button", "Back"],
|
|
)
|
|
|
|
if choice == "system":
|
|
wake_word_system = radiolist(
|
|
"Wake Word System:",
|
|
[v.value for v in WakeWordSystem],
|
|
settings.wake.system,
|
|
)
|
|
if wake_word_system is None:
|
|
continue
|
|
|
|
wake_word_system = WakeWordSystem(wake_word_system)
|
|
install_wake_word(settings, wake_word_system)
|
|
elif choice == "wake_word":
|
|
select_wake_word(settings)
|
|
elif choice == "openWakeWord":
|
|
configure_openWakeWord(settings)
|
|
elif choice == "porcupine1":
|
|
configure_porcupine1(settings)
|
|
elif choice == "snowboy":
|
|
configure_snowboy(settings)
|
|
else:
|
|
break
|
|
|
|
|
|
def install_wake_word(settings: Settings, wake_word_system: WakeWordSystem) -> None:
|
|
if wake_word_system == WakeWordSystem.OPENWAKEWORD:
|
|
oww_dir = LOCAL_DIR / "wyoming-openwakeword"
|
|
if not oww_dir.exists():
|
|
if not yesno("Install openWakeWord?"):
|
|
return
|
|
|
|
success = run_with_gauge(
|
|
"Installing openWakeWord",
|
|
[
|
|
[
|
|
"git",
|
|
"clone",
|
|
"https://github.com/rhasspy/wyoming-openwakeword.git",
|
|
str(oww_dir),
|
|
],
|
|
[str(oww_dir / "script" / "setup")],
|
|
],
|
|
)
|
|
|
|
if not success:
|
|
# Clean up
|
|
try:
|
|
shutil.rmtree(oww_dir)
|
|
except Exception:
|
|
pass
|
|
|
|
error("installing openWakeWord")
|
|
return
|
|
|
|
msgbox("openWakeWord installed successfully")
|
|
settings.wake.system = wake_word_system
|
|
settings.save()
|
|
return
|
|
|
|
if wake_word_system == WakeWordSystem.PORCUPINE1:
|
|
porcupine1_dir = LOCAL_DIR / "wyoming-porcupine1"
|
|
if not porcupine1_dir.exists():
|
|
if not yesno("Install porcupine1?"):
|
|
return
|
|
|
|
success = run_with_gauge(
|
|
"Installing porcupine1",
|
|
[
|
|
[
|
|
"git",
|
|
"clone",
|
|
"https://github.com/rhasspy/wyoming-porcupine1.git",
|
|
str(porcupine1_dir),
|
|
],
|
|
[str(porcupine1_dir / "script" / "setup")],
|
|
],
|
|
)
|
|
|
|
if not success:
|
|
# Clean up
|
|
try:
|
|
shutil.rmtree(porcupine1_dir)
|
|
except Exception:
|
|
pass
|
|
|
|
error("installing porcupine1")
|
|
return
|
|
|
|
msgbox("porcupine1 installed successfully")
|
|
settings.wake.system = wake_word_system
|
|
settings.save()
|
|
return
|
|
|
|
if wake_word_system == WakeWordSystem.SNOWBOY:
|
|
snowboy_dir = LOCAL_DIR / "wyoming-snowboy"
|
|
if not snowboy_dir.exists():
|
|
if not yesno("Install snowboy?"):
|
|
return
|
|
|
|
snowboy_packages = ["python3-dev", "swig", "libatlas-base-dev"]
|
|
if not packages_installed(*snowboy_packages):
|
|
password = passwordbox("sudo password:")
|
|
if not password:
|
|
return
|
|
|
|
success = install_packages(
|
|
"Installing system packages...", password, *snowboy_packages
|
|
)
|
|
if not success:
|
|
error("installing " + ", ".join(snowboy_packages))
|
|
return
|
|
|
|
success = run_with_gauge(
|
|
"Installing snowboy",
|
|
[
|
|
[
|
|
"git",
|
|
"clone",
|
|
"https://github.com/rhasspy/wyoming-snowboy.git",
|
|
str(snowboy_dir),
|
|
],
|
|
[str(snowboy_dir / "script" / "setup")],
|
|
],
|
|
)
|
|
|
|
if not success:
|
|
# Clean up
|
|
try:
|
|
shutil.rmtree(snowboy_dir)
|
|
except Exception:
|
|
pass
|
|
|
|
error("installing snowboy")
|
|
return
|
|
|
|
msgbox("snowboy installed successfully")
|
|
settings.wake.system = wake_word_system
|
|
settings.save()
|
|
return
|
|
|
|
|
|
def select_wake_word(settings: Settings) -> None:
|
|
if settings.wake.system == WakeWordSystem.OPENWAKEWORD:
|
|
oww_dir = LOCAL_DIR / "wyoming-openwakeword"
|
|
if not oww_dir.exists():
|
|
msgbox("openWakeWord is not installed")
|
|
return
|
|
|
|
custom_wake_word_dir = LOCAL_DIR / "custom-wake-words" / "openWakeWord"
|
|
custom_wake_word_dir.mkdir(parents=True, exist_ok=True)
|
|
|
|
community_wake_word_dir = LOCAL_DIR / "home-assistant-wakewords-collection"
|
|
|
|
while True:
|
|
ww_paths: Dict[str, Path] = {
|
|
p.stem: p for p in custom_wake_word_dir.glob("*.tflite")
|
|
}
|
|
|
|
for ww_path in community_wake_word_dir.rglob("*.tflite"):
|
|
ww_name = ww_path.stem
|
|
if ww_name in ww_paths:
|
|
continue
|
|
|
|
ww_paths[ww_name] = ww_path
|
|
|
|
for ww_path in (oww_dir / "wyoming_openwakeword" / "models").glob(
|
|
"*.tflite"
|
|
):
|
|
if not re.match("^.+_v[0-9].*$", ww_path.stem):
|
|
continue
|
|
|
|
ww_name = ww_path.stem.rsplit("_", maxsplit=1)[0]
|
|
if ww_name in ww_paths:
|
|
continue
|
|
|
|
ww_paths[ww_name] = ww_path
|
|
|
|
items = sorted(list(ww_paths.keys()))
|
|
wake_word = radiolist(
|
|
"Wake Word:", items, settings.wake.openwakeword.wake_word
|
|
)
|
|
if wake_word is None:
|
|
break
|
|
|
|
wake_word_path = ww_paths[wake_word]
|
|
if wake_word_path.is_relative_to(community_wake_word_dir):
|
|
# Copy to custom directory
|
|
shutil.copy(wake_word_path, custom_wake_word_dir)
|
|
|
|
settings.wake.openwakeword.wake_word = wake_word
|
|
settings.save()
|
|
break
|
|
|
|
return
|
|
|
|
if settings.wake.system == WakeWordSystem.PORCUPINE1:
|
|
porcupine1_dir = LOCAL_DIR / "wyoming-porcupine1"
|
|
if not porcupine1_dir.exists():
|
|
msgbox("porcupine1 is not installed")
|
|
return
|
|
|
|
ww_names = sorted(
|
|
list(
|
|
set(
|
|
p.stem.rsplit("_", maxsplit=1)[0]
|
|
for p in (
|
|
porcupine1_dir / "wyoming_porcupine1" / "data" / "resources"
|
|
).rglob("*.ppn")
|
|
)
|
|
)
|
|
)
|
|
|
|
wake_word = radiolist(
|
|
"Wake Word:", ww_names, settings.wake.porcupine1.wake_word
|
|
)
|
|
if wake_word is not None:
|
|
settings.wake.porcupine1.wake_word = wake_word
|
|
settings.save()
|
|
|
|
return
|
|
|
|
if settings.wake.system == WakeWordSystem.SNOWBOY:
|
|
snowboy_dir = LOCAL_DIR / "wyoming-snowboy"
|
|
if not snowboy_dir.exists():
|
|
msgbox("snowboy is not installed")
|
|
return
|
|
|
|
custom_wake_word_dir = LOCAL_DIR / "custom-wake-words" / "snowboy"
|
|
custom_wake_word_dir.mkdir(parents=True, exist_ok=True)
|
|
|
|
builtin_wake_words = (snowboy_dir / "wyoming_snowboy" / "data").glob("*.umdl")
|
|
custom_wake_words = itertools.chain(
|
|
custom_wake_word_dir.glob("*.pmdl"), custom_wake_word_dir.glob("*.umdl")
|
|
)
|
|
ww_names = sorted(
|
|
list(
|
|
set(
|
|
p.stem
|
|
for p in itertools.chain(builtin_wake_words, custom_wake_words)
|
|
)
|
|
)
|
|
)
|
|
|
|
wake_word = radiolist("Wake Word:", ww_names, settings.wake.snowboy.wake_word)
|
|
if wake_word is not None:
|
|
settings.wake.snowboy.wake_word = wake_word
|
|
settings.save()
|
|
|
|
return
|
|
|
|
|
|
def configure_openWakeWord(settings: Settings) -> None:
|
|
choice: Optional[str] = None
|
|
while True:
|
|
choice = menu(
|
|
"Main > Wake Word > openWakeWord",
|
|
[
|
|
("community", "Download Community Wake Words"),
|
|
("threshold", "Set Threshold"),
|
|
("trigger_level", "Set Trigger Level"),
|
|
],
|
|
selected_item=choice,
|
|
menu_args=["--ok-button", "Select", "--cancel-button", "Back"],
|
|
)
|
|
|
|
if choice == "community":
|
|
community_wake_word_dir = LOCAL_DIR / "home-assistant-wakewords-collection"
|
|
|
|
if not community_wake_word_dir.exists():
|
|
success = run_with_gauge(
|
|
"Downloading community wake words...",
|
|
[
|
|
[
|
|
"git",
|
|
"clone",
|
|
"https://github.com/fwartner/home-assistant-wakewords-collection.git",
|
|
str(community_wake_word_dir),
|
|
]
|
|
],
|
|
)
|
|
|
|
if not success:
|
|
error("downloading community wake words")
|
|
else:
|
|
success = run_with_gauge(
|
|
"Updating community wake words...",
|
|
[
|
|
[
|
|
"git",
|
|
"-C",
|
|
str(community_wake_word_dir),
|
|
"pull",
|
|
"origin",
|
|
"main",
|
|
]
|
|
],
|
|
)
|
|
|
|
if not success:
|
|
error("updating community wake words")
|
|
elif choice == "threshold":
|
|
while True:
|
|
threshold = inputbox(
|
|
"Threshold (0-1, 0.5 = default):",
|
|
settings.wake.openwakeword.threshold,
|
|
)
|
|
if threshold is None:
|
|
break
|
|
|
|
try:
|
|
threshold_float = float(threshold)
|
|
except ValueError:
|
|
msgbox("Invalid value")
|
|
continue
|
|
|
|
if 0 < threshold_float < 1:
|
|
settings.wake.openwakeword.threshold = threshold_float
|
|
settings.save()
|
|
break
|
|
|
|
msgbox("Threshold must be in (0, 1)")
|
|
elif choice == "trigger_level":
|
|
while True:
|
|
trigger_level = inputbox(
|
|
"Trigger Level (> 0, 1 = default):",
|
|
settings.wake.openwakeword.trigger_level,
|
|
)
|
|
if trigger_level is None:
|
|
break
|
|
|
|
try:
|
|
trigger_level_int = int(trigger_level)
|
|
except ValueError:
|
|
msgbox("Invalid value")
|
|
continue
|
|
|
|
if trigger_level_int > 0:
|
|
settings.wake.openwakeword.trigger_level = trigger_level_int
|
|
settings.save()
|
|
break
|
|
|
|
msgbox("Trigger level must be > 0")
|
|
else:
|
|
break
|
|
|
|
|
|
def configure_porcupine1(settings: Settings) -> None:
|
|
choice: Optional[str] = None
|
|
while True:
|
|
choice = menu(
|
|
"Main > Wake Word > porcupine1",
|
|
[
|
|
("sensitivity", "Set Sensitivity"),
|
|
],
|
|
selected_item=choice,
|
|
menu_args=["--ok-button", "Select", "--cancel-button", "Back"],
|
|
)
|
|
|
|
if choice == "sensitivity":
|
|
while True:
|
|
sensitivity = inputbox(
|
|
"Sensitivity (0-1, 0.5 = default):",
|
|
settings.wake.porcupine1.sensitivity,
|
|
)
|
|
if sensitivity is None:
|
|
break
|
|
|
|
try:
|
|
sensitivity_float = float(sensitivity)
|
|
except ValueError:
|
|
msgbox("Invalid value")
|
|
continue
|
|
|
|
if 0 < sensitivity_float < 1:
|
|
settings.wake.porcupine1.sensitivity = sensitivity_float
|
|
settings.save()
|
|
break
|
|
|
|
msgbox("Sensitivity must be in (0, 1)")
|
|
else:
|
|
break
|
|
|
|
|
|
def configure_snowboy(settings: Settings) -> None:
|
|
choice: Optional[str] = None
|
|
while True:
|
|
choice = menu(
|
|
"Main > Wake Word > snowboy",
|
|
[
|
|
("sensitivity", "Set Sensitivity"),
|
|
],
|
|
selected_item=choice,
|
|
menu_args=["--ok-button", "Select", "--cancel-button", "Back"],
|
|
)
|
|
|
|
if choice == "sensitivity":
|
|
while True:
|
|
sensitivity = inputbox(
|
|
"Sensitivity (0-1, 0.5 = default):",
|
|
settings.wake.snowboy.sensitivity,
|
|
)
|
|
if sensitivity is None:
|
|
break
|
|
|
|
try:
|
|
sensitivity_float = float(sensitivity)
|
|
except ValueError:
|
|
msgbox("Invalid value")
|
|
continue
|
|
|
|
if 0 < sensitivity_float < 1:
|
|
settings.wake.snowboy.sensitivity = sensitivity_float
|
|
settings.save()
|
|
break
|
|
|
|
msgbox("Sensitivity must be in (0, 1)")
|
|
else:
|
|
break
|