home-assistant-intents 2025.6.23__py3-none-any.whl → 2025.7.30__py3-none-any.whl

home_assistant_intents/__init__.py

@@ -7,13 +7,14 @@ import typing
 from dataclasses import dataclass
 from enum import Enum
 from pathlib import Path
-from typing import IO, Any, Callable, Dict, List, Optional
+from typing import IO, Any, Callable, Collection, Dict, List, Optional, Set, Tuple
 
 from .languages import LANGUAGES
 
 _PACKAGE = "home_assistant_intents"
 _DIR = Path(typing.cast(os.PathLike, importlib.resources.files(_PACKAGE)))
 _DATA_DIR = _DIR / "data"
+_FUZZY_DIR = _DIR / "fuzzy"
 
 
 class ErrorKey(str, Enum):
@@ -155,3 +156,136 @@ def get_language_scores(
             )
             for lang_key, lang_scores in scores_dict.items()
         }
+
+
+# -----------------------------------------------------------------------------
+
+
+@dataclass
+class FuzzyConfig:
+    """Shared configuration for fuzzy matching."""
+
+    # intent -> (slot, slot) -> {name domains}
+    slot_combinations: Dict[str, Dict[Tuple[str, ...], Set[str]]]
+    """Name domains for all intent slot combinations."""
+
+    # list name -> [slot names]
+    slot_list_names: Dict[str, List[str]]
+    """Mapping between list and slot names."""
+
+
+@dataclass
+class FuzzyNgramModel:
+    """N-gram model for fuzzy matching."""
+
+    order: int
+    """N-gram order."""
+
+    words: Dict[str, int]
+    """Words to integer ids."""
+
+    database_path: Path
+    """Path to sqlite3 database file."""
+
+
+FuzzyLanguageResponses = Dict[str, Dict[Tuple[str, ...], Dict[str, str]]]
+
+
+@dataclass
+class FuzzyLanguageInfo:
+    """Language specific information for fuzzy matching."""
+
+    language: str
+
+    # domain -> [keywords]
+    domain_keywords: Dict[str, List[str]]
+    """Keywords that hint at a domain."""
+
+    # intent -> model
+    ngram_models: Dict[str, FuzzyNgramModel]
+    """N-gram model for each intent."""
+
+    # intent -> (slot, slot) -> domain -> response
+    responses: FuzzyLanguageResponses
+    """Response code mapping per slot combination."""
+
+    stop_words: Optional[Collection[str]] = None
+    """Words that can be ignored if unknown."""
+
+
+def get_fuzzy_config(
+    json_load: Callable[[IO[str]], Dict[str, Any]] = json.load,
+) -> FuzzyConfig:
+    """Return shared configuration for fuzzy matching."""
+    with open(_FUZZY_DIR / "config.json", "r", encoding="utf-8") as config_file:
+        config_dict = json_load(config_file)
+
+    return FuzzyConfig(
+        slot_combinations={
+            intent_name: {
+                tuple(sorted(combo_key_str.split())): set(name_domains)
+                for combo_key_str, name_domains in intent_combos.items()
+            }
+            for intent_name, intent_combos in config_dict["slot_combinations"].items()
+        },
+        slot_list_names={
+            list_name: slot_names
+            for list_name, slot_names in config_dict["slot_list_names"].items()
+        },
+    )
+
+
+def get_fuzzy_languages() -> Set[str]:
+    """Return languages with fuzzy matching support."""
+    return {lang_dir.name for lang_dir in _FUZZY_DIR.iterdir() if lang_dir.is_dir()}
+
+
+def get_fuzzy_language(
+    language: str,
+    json_load: Callable[[IO[str]], Dict[str, Any]] = json.load,
+) -> Optional[FuzzyLanguageInfo]:
+    """Return fuzzy matching information for a language."""
+    lang_fuzzy_dir = _FUZZY_DIR / language
+    lang_ngram_dir = lang_fuzzy_dir / "ngram"
+
+    if not lang_ngram_dir.is_dir():
+        return None
+
+    with open(lang_fuzzy_dir / "config.json", "r", encoding="utf-8") as config_file:
+        lang_config = json_load(config_file)
+
+    ngram_models: Dict[str, FuzzyNgramModel] = {}
+    for intent_ngram_path in lang_ngram_dir.glob("*.json"):
+        intent_db_path = intent_ngram_path.with_suffix(".db")
+        if not intent_db_path.exists():
+            continue
+
+        with open(intent_ngram_path, "r", encoding="utf-8") as intent_ngram_file:
+            intent_ngram_dict = json_load(intent_ngram_file)
+
+        intent_name = intent_ngram_path.stem
+        ngram_models[intent_name] = FuzzyNgramModel(
+            order=intent_ngram_dict["order"],
+            words=intent_ngram_dict["words"],
+            database_path=intent_db_path,
+        )
+
+    with open(
+        lang_fuzzy_dir / "responses.json", "r", encoding="utf-8"
+    ) as responses_file:
+        lang_responses_dict = json_load(responses_file)
+        lang_responses = {
+            intent_name: {
+                tuple(sorted(combo_key_str.split())): domain_responses
+                for combo_key_str, domain_responses in intent_responses.items()
+            }
+            for intent_name, intent_responses in lang_responses_dict.items()
+        }
+
+    return FuzzyLanguageInfo(
+        language=language,
+        domain_keywords=lang_config["domain_keywords"],
+        stop_words=lang_config.get("stop_words"),
+        ngram_models=ngram_models,
+        responses=lang_responses,
+    )

home_assistant_intents/data/ca.json

@@ -559,7 +559,7 @@
             "my_list": "[la] [meva] llista [de (la compra|compres|comprar)]",
             "my_list_req": "[la] [meva] llista de (la compra|compres|comprar)",
             "item": "{shopping_list_item:item}",
-            "add": "(afeg[e]ix|posa)"
+            "add": "(afeg[e]ix|posa|fica)"
           }
         }
       ]