hiapp 0.0.1__py3-none-any.whl

hiapp/__init__.py

@@ -0,0 +1,17 @@
+"""
+Hiapp: H.ogar con I.nteligencia A.rtificial P.rivada P.ersonal.
+
+Asistente de voz autogestionado para el hogar, con servidor de juegos
+para PPSSPP y otras aplicaciones.
+"""
+
+from importlib.metadata import version, PackageNotFoundError
+
+try:
+    __version__ = version("hiapp")
+except PackageNotFoundError:
+    # Para estado en desarrollo, sin pip install
+    __version__ = "0.0.0+unknown"
+
+__author__ = "Dixan Pupo Morales (Triplex3x-cyver)"
+__license__ = "Apache-2.0"

hiapp/addons/base.py

@@ -0,0 +1,60 @@
+"""
+Clase base para todos los add-ons de Hiapp.
+
+Un add-on es una funcionalidad opcional que se registra en el núcleo.
+Puede ser gratuito (viene con Hiapp) o PRO (instalado desde el servidor de licencias).
+
+Cada add-on debe:
+    - Definir `name` (identificador único).
+    - Definir `prefix` (prefijo de URL si expone rutas Flask).
+    - Definir `free` (True si es gratuito, False si es PRO).
+    - Implementar `register(app)` si expone rutas HTTP.
+    - Opcionalmente sobrescribir `start()` y `stop()` si gestiona recursos.
+"""
+
+
+class Addon:
+    """Clase base para todos los add-ons de Hiapp."""
+
+    # --- Atributos que cada subclase debe sobrescribir ---
+    name: str = "unnamed"
+    prefix: str = ""  # Prefijo de URL (ej. "/game")
+    free: bool = True
+
+    # --- Ciclo de vida ---
+
+    def register(self, app):
+        """
+        Registra los blueprints y rutas del add-on en la app Flask.
+
+        Args:
+            app: Instancia de Flask donde registrar el add-on.
+        """
+        pass
+
+    def start(self):
+        """Inicia recursos propios (hilos, procesos). Opcional."""
+        pass
+
+    def stop(self):
+        """Detiene recursos propios. Opcional."""
+        pass
+
+    # --- Estado ---
+
+    def status(self) -> dict:
+        """
+        Devuelve un diccionario con el estado actual del add-on.
+        Las subclases pueden sobrescribirlo para dar más información.
+        """
+        return {
+            "name": self.name,
+            "prefix": self.prefix,
+            "free": self.free,
+        }
+
+    # --- Utilidades ---
+
+    def __repr__(self) -> str:
+        kind = "free" if self.free else "PRO"
+        return f"<Addon {self.name} ({kind}) prefix={self.prefix!r}>"

hiapp/addons/ppsspp/addon.py

@@ -0,0 +1,20 @@
+"""
+Add-on gratuito: servidor de juegos para PPSSPP.
+"""
+
+# ..
+from ..base import Addon
+# .
+from .routes import bp
+
+
+class PpssppAddon(Addon):
+    """Servidor HTTP de streaming para PPSSPP (soporta rangos)."""
+
+    name = "ppsspp"
+    prefix = "/game"
+    free = True
+
+    def register(self, app):
+        """Registra el blueprint /game en la app Flask."""
+        app.register_blueprint(bp)

hiapp/addons/ppsspp/paths.py

@@ -0,0 +1,21 @@
+from pathlib import Path
+
+# (...core)
+from ...core.config import load_config, save_config
+
+
+def get_games_directory() -> str:
+    """Devuelve el directorio de juegos configurado, creándolo si no existe."""
+    config = load_config()
+    games_dir = config.get("games_dir", str(Path.home() / "PSP"))
+
+    # Crear si no existe
+    Path(games_dir).mkdir(parents=True, exist_ok=True)
+    return games_dir
+
+
+def save_games_directory(path: str) -> None:
+    """Guarda el directorio de juegos en la configuración."""
+    config = load_config()
+    config["games_dir"] = str(path)
+    save_config(config)

hiapp/addons/ppsspp/routes.py

@@ -0,0 +1,69 @@
+"""
+Rutas HTTP del add-on PPSSPP.
+
+Se registran bajo el prefijo /game:
+    /game/            → index.txt con la lista de juegos
+    /game/<filename>  → streaming del archivo (soporta rangos)
+"""
+
+from pathlib import Path
+
+from flask import Blueprint, Response, abort, send_file
+
+# (.)
+from .paths import get_games_directory
+
+
+bp = Blueprint(
+    "ppsspp",
+    __name__,
+    url_prefix="/game",
+    template_folder="templates",
+    static_folder="static",
+)
+
+
+@bp.route("/", methods=["GET"])
+def index():
+    """
+    Devuelve la lista de juegos disponibles en formato index.txt.
+
+    Cada línea debe empezar con '/' (PPSSPP lo requiere).
+    Formato de ejemplo:
+        /dissidia.iso
+        /god-of-war.cso
+    """
+    games_dir = Path(get_games_directory())
+    lines = []
+
+    if games_dir.is_dir():
+        for entry in sorted(games_dir.iterdir()):
+            if entry.is_file() and entry.suffix.lower() in {".iso", ".cso"}:
+                lines.append(f"/{entry.name}")
+
+    content = "\n".join(lines) + "\n" if lines else ""
+    return Response(content, mimetype="text/plain")
+
+
+@bp.route("/<path:filename>", methods=["GET"])
+def stream_game(filename):
+    """
+    Sirve un archivo de juego con soporte de peticiones de rango.
+    PPSSPP requiere respuestas 206 Partial Content.
+    """
+    games_dir = Path(get_games_directory()).resolve()
+    file_path = (games_dir / filename).resolve()
+
+    # Seguridad: evitar path traversal (../../etc/passwd)
+    if not str(file_path).startswith(str(games_dir)):
+        abort(403)
+
+    if not file_path.is_file():
+        abort(404)
+
+    # conditional=True habilita el manejo de cabeceras Range
+    return send_file(
+        file_path,
+        conditional=True,
+        mimetype="application/octet-stream",
+    )

hiapp/config_cli.py

@@ -0,0 +1,210 @@
+
+"""
+Comando `hiapp-config`: gestiona la configuración de Hiapp.
+
+Reglas:
+    - USER_DEFAULTS se pueden leer, escribir y resetear.
+    - APP_DEFAULTS solo se leen. Para cambiar lang/lang_model_name,
+      se usa el flujo de reconfiguración (reset lang_model_name + reinicio).
+    - `reset --all` solo afecta a USER_DEFAULTS.
+
+Modo interactivo:
+hiapp-config list
+hiapp-config get port
+hiapp-config set port 8080
+hiapp-config get port
+hiapp-config reset port
+hiapp-config get port
+
+hiapp-config get models_dir
+hiapp-config set models_dir /storage/XXXX-XXXX/models
+hiapp-config get models_dir
+hiapp-config reset models_dir
+hiapp-config get models_dir
+hiapp-config list
+"""
+
+# 🔧 Configuración de Hiapp
+# ------------------------------
+import sys
+import argparse
+
+from .core.config import (
+    ALL_DEFAULTS,
+    APP_DEFAULTS,
+    USER_DEFAULTS,
+    load_config,
+    save_config,
+)
+from .core.i18n import translate
+
+# Traducir guiones (CLI) a guiones bajos (interno)
+CLI_TO_INTERNAL = {k.replace("_", "-"): k for k in ALL_DEFAULTS}
+config = load_config()
+
+
+def _resolve_key(key: str) -> str:
+    """Convierte 'models-dir' → 'models_dir'. Deja pasar claves ya válidas.
+    Si entra models_dir, pasa sin cambiar.
+    """
+    return CLI_TO_INTERNAL.get(key, key)
+
+
+def _is_app_key(key: str) -> bool:
+    """¿Es una clave gestionada por la app (no libremente editable)?"""
+    return key in APP_DEFAULTS
+
+
+# --- Comandos -----------
+def cmd_list(args):
+    print(translate("config_title", config.get("lang")))
+    print("=" * 40)
+    for key, value in config.items():
+        marca = "  [app]" if _is_app_key(key) else ""
+        print(f"  {key:18} = {value}{marca}")
+
+
+def cmd_get(args):
+    key = _resolve_key(args.key)
+    if key not in ALL_DEFAULTS:
+        print(translate("config_unknown_key", config.get("lang"), text=key))
+        print(translate(
+            "config_valid_keys", config.get("lang"), valid=", ".join(ALL_DEFAULTS.keys())))
+        sys.exit(1)
+
+    print(config.get(key))
+
+
+def cmd_set(args):
+    # global config
+    key = _resolve_key(args.key)
+
+    if key not in USER_DEFAULTS:
+        if _is_app_key(key):
+            print(translate("config_applang_warn", config.get("lang"), text=key))
+        else:
+            print(translate("config_unknown_key", config.get("lang"), text=key))
+            print(translate(
+                "config_valid_keys", config.get("lang"), valid=", ".join(ALL_DEFAULTS.keys())))
+        sys.exit(1)
+
+    # Unir todos los argumentos en un solo string
+    raw_value = " ".join(args.value)
+
+    # Convertir tipo si el valor por defecto es int
+    if isinstance(USER_DEFAULTS[key], int):
+        try:
+            value = int(raw_value)
+        except ValueError:
+            print(translate(
+                "config_nan_err", config.get("lang"), value=raw_value, text=key))
+            sys.exit(1)
+
+    elif isinstance(USER_DEFAULTS[key], list):
+        # Para listas (aliases), separar por comas
+        value = [v.strip() for v in raw_value.split(",") if v.strip()]
+    else:
+        value = raw_value
+
+    config[key] = value
+    save_config(config)
+    print(f"✅ {key} = {value}")
+
+
+def cmd_reset(args):
+    # global config
+
+    # Caso especial: reset --all
+    if args.all:
+        #
+        # Solo resetear las configurables
+        for key in USER_DEFAULTS:
+            config[key] = USER_DEFAULTS[key]
+        save_config(config)
+        print(translate("config_reset_ok", config.get("lang")))
+        return
+
+    if not args.key:
+        print(translate("config_nokey_err", config.get("lang")))
+        print(translate(
+            "config_valid_keys", config.get("lang"),
+            valid=", ".join(ALL_DEFAULTS.keys()) + ", --all"))
+        sys.exit(1)
+
+    key = _resolve_key(args.key)
+
+    # RESET LANG
+    if key == "lang":
+        print(translate("config_applang_warn", config.get("lang"), text=key))
+        sys.exit(1)
+    #
+    # Claves de APP (excepto lang, ya bloqueada arriba)
+    if _is_app_key(key):
+        print(translate("config_appstat_warn", config.get("lang"), text=key))
+        confirm = input("¿Continuar? [s/N]: ").strip().lower()
+        if confirm != "s":
+            print(translate("canceled", config.get("lang")))
+            return
+
+        config[key] = APP_DEFAULTS[key]
+        save_config(config)
+        print(f"✅ {key} = {config[key]}")
+        return
+
+    if key not in ALL_DEFAULTS:
+        print(translate("config_unknown_key", config.get("lang"), text=key))
+        print(translate(
+            "config_valid_keys", config.get("lang"),
+            valid=", ".join(ALL_DEFAULTS.keys()) + ", --all"))
+        sys.exit(1)
+
+    # Ejecutar reset en clave de usuario
+    config[key] = USER_DEFAULTS[key]
+    save_config(config)
+    print(f"✅ {key} = {USER_DEFAULTS[key]}")
+
+
+# --- Punto de entrada -----------
+def main():
+    parser = argparse.ArgumentParser(
+        prog="hiapp-config",
+        description=translate("cmd_parser_desc", config.get("lang"))
+    )
+    subparsers = parser.add_subparsers(dest="command")
+
+    subparsers.add_parser("list", help=translate("cmd_list_help", config.get("lang")))
+
+    # GET
+    p_get = subparsers.add_parser("get", help=translate("cmd_get_help", config.get("lang")))
+    p_get.add_argument("key")
+
+    # SET
+    p_set = subparsers.add_parser("set", help=translate("cmd_set_help", config.get("lang")))
+    p_set.add_argument("key")
+    # p_set.add_argument("value", help="Valor (para listas, separar por comas a,b,c)")
+    p_set.add_argument(
+        "value", nargs="+", help=translate("cmd_setvalue_help", config.get("lang")))
+
+    # RESET
+    p_reset = subparsers.add_parser("reset", help=translate("cmd_reset_help", config.get("lang")))
+    p_reset.add_argument("key", nargs="?", help=translate("cmd_resetkey_help", config.get("lang")))
+    p_reset.add_argument(
+        "--all", action="store_true", help=translate("cmd_resetall_help", config.get("lang")))
+
+    args = parser.parse_args()
+
+    # Dispatch
+    if args.command == "list":
+        cmd_list(args)
+    elif args.command == "get":
+        cmd_get(args)
+    elif args.command == "set":
+        cmd_set(args)
+    elif args.command == "reset":
+        cmd_reset(args)
+    else:
+        parser.print_help()
+
+
+if __name__ == "__main__":
+    main()

hiapp/core/commands.py

@@ -0,0 +1,138 @@
+"""
+Registro de comandos de voz de Hiapp.
+
+Los comandos se recogen de dos fuentes:
+    - El núcleo: estado, ayuda.
+    - Los add-ons: cada uno declara los suyos en su addon.json.
+
+Con todos los comandos + la wake word, se construye una gramática JSON
+que se pasa a Vosk para restringir el reconocimiento.
+
+Beneficios de la gramática:
+    - Menos falsos positivos (de ~50% a ~100% de precisión).
+    - Menos uso de CPU (espacio de búsqueda reducido).
+    - Misma velocidad que un modelo "small".
+"""
+
+import json
+
+
+# Comandos del núcleo por idioma
+CORE_COMMANDS = {
+    "es": {
+        "status": ("estado", "estatus"),
+        "help":   ("ayuda", "aiuda", "ayúa"),
+    },
+    "en": {
+        "status": ("status", "state"),
+        "help":   ("help",),
+    },
+}
+
+
+class CommandRegistry:
+    """
+    Recoge comandos del núcleo y de los add-ons, y construye la gramática
+    de Vosk para el idioma activo.
+
+    Mapea frases exactas a intenciones para que el controlador sepa
+    qué hacer cuando Vosk devuelve una transcripción.
+    """
+
+    def __init__(self):
+        # {lang: {intent: [frases]}}
+        self._by_intent = {}
+        # {lang: {frase: intent}}
+        self._phrase_to_intent = {}
+
+    # --- Registro -----------
+
+    def register_core(self):
+        """Registra los comandos del núcleo (estado, ayuda)."""
+        for lang, intents in CORE_COMMANDS.items():
+            for intent, phrases in intents.items():
+                self._register(lang, intent, phrases)
+
+    def register_addon(self, manifest: dict):
+        """
+        Registra los comandos de un add-on a partir de su manifest
+        (el diccionario cargado desde addon.json).
+
+        El manifest debe exponer los comandos con esta estructura:
+            "commands": {
+                "es": {
+                    "start": ["activar servidor de juegos"],
+                    "stop":  ["desactivar servidor de juegos"]
+                }
+            }
+
+        Las intenciones se registran con el prefijo del add-on:
+            "ppsspp:start", "ppsspp:stop"
+        """
+        name = manifest.get("name", "addon")
+        commands = manifest.get("commands", {})
+
+        for lang, intents in commands.items():
+            for intent, phrases in intents.items():
+                full_intent = f"{name}:{intent}"
+                self._register(lang, full_intent, phrases)
+
+    def _register(self, lang: str, intent: str, phrases):
+        """Añade frases a una intención en un idioma, evitando duplicados."""
+        self._by_intent.setdefault(lang, {})
+        self._by_intent[lang].setdefault(intent, [])
+
+        self._phrase_to_intent.setdefault(lang, {})
+
+        for phrase in phrases:
+            # Evitar duplicados
+            if phrase not in self._by_intent[lang][intent]:
+                self._by_intent[lang][intent].append(phrase)
+            # Mapear frase → intención (el último gana si hay colisión)
+            self._phrase_to_intent[lang][phrase] = intent
+
+    # --- Gramática -----------
+
+    def build_grammar(self, lang: str, wake_words: list) -> str:
+        """
+        Construye la gramática JSON para Vosk.
+        Incluye la wake word, los comandos del idioma, y el token [unk].
+        """
+        phrases = set(wake_words)
+
+        for phrases_list in self._by_intent.get(lang, {}).values():
+            phrases.update(phrases_list)
+
+        phrases.add("[unk]")
+        return json.dumps(sorted(phrases))
+
+    # --- Búsqueda de intención -----------
+
+    def find_intent(self, text: str, lang: str) -> str | None:
+        """
+        Devuelve la intención cuyo comando aparece en el texto, o None.
+
+        Con gramática activa, Vosk devuelve frases exactas. El fallback
+        por substring está por si el modelo devuelve algo inesperado.
+        """
+        mapping = self._phrase_to_intent.get(lang, {})
+
+        # 1. Coincidencia exacta
+        if text in mapping:
+            return mapping[text]
+
+        # 2. Fallback: substring
+        for phrase, intent in mapping.items():
+            if phrase in text:
+                return intent
+
+        return None
+
+    # --- Utilidades -----------
+
+    def list_commands(self, lang: str) -> list:
+        """Devuelve las frases registradas para un idioma."""
+        phrases = []
+        for phrases_list in self._by_intent.get(lang, {}).values():
+            phrases.extend(phrases_list)
+        return sorted(phrases)

hiapp/core/config.py

@@ -0,0 +1,71 @@
+import json
+import socket
+from pathlib import Path
+
+# Rutas base (fijas)
+HIAPP_DIR = Path.home() / ".hiapp"
+CONFIG_FILE = HIAPP_DIR / "config.json"
+
+# Configuración de usuario (resetable con --all)
+USER_DEFAULTS = {
+    "models_dir": str(HIAPP_DIR / "models"),
+    "games_dir": str(Path.home() / "PSP"),
+    "port": 5000,
+    "host": "0.0.0.0",
+    "aliases": [],
+}
+
+# Estado de la aplicación (NO resetable con --all)
+APP_DEFAULTS = {
+    "lang": None,
+    "lang_model_name": None,
+}
+
+# Todas las claves válidas (para validación en CLI)
+ALL_DEFAULTS = {**USER_DEFAULTS, **APP_DEFAULTS}
+
+
+def load_config() -> dict:
+    """Carga la configuración aplicando esta prioridad:
+        1. Valores por defecto (USER_DEFAULTS + APP_DEFAULTS).
+        2. Valores del archivo ~/.hiapp/config.json (si existen).
+
+    Solo se cargan las claves que existen en ALL_DEFAULTS.
+    """
+    result = {**USER_DEFAULTS, **APP_DEFAULTS}
+
+    # 1. Cargar del archivo json
+    if CONFIG_FILE.exists():
+        try:
+            with open(CONFIG_FILE, "r", encoding="utf-8") as f:
+                # config.update(json.load(f))
+                saved = json.load(f)
+
+            for key in ALL_DEFAULTS:
+                if key in saved:  # Solo carga las que estén en ALL_KEYS
+                    result[key] = saved[key]
+        except (json.JSONDecodeError, OSError):
+            pass  # Usar valores por defecto
+
+    return result
+
+
+def save_config(config: dict):
+    """Guarda la configuración en ~/.hiapp/config.json."""
+    CONFIG_FILE.parent.mkdir(parents=True, exist_ok=True)
+
+    with open(CONFIG_FILE, "w", encoding="utf-8") as f:
+        json.dump(config, f, indent=2, ensure_ascii=False)
+
+
+def get_lan_ip() -> str:
+    """Devuelve la IP local de la interfaz que conecta a la LAN."""
+    s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+    try:
+        # No envía nada, solo consulta la ruta de salida hacia internet
+        s.connect(("8.8.8.8", 80))
+        return s.getsockname()[0]
+    except Exception:
+        return "127.0.0.1"
+    finally:
+        s.close()