137 lines
4.6 KiB
Python
137 lines
4.6 KiB
Python
from pathlib import Path
|
|
from typing import Any, Iterator, Tuple, Union
|
|
|
|
from src.json_serializer import normalize_obj
|
|
from src.logger import get_logger
|
|
from src.utils import extract_files
|
|
from src.yaml_serializer import load_yaml
|
|
from src.yaml_serializer.types import IncludedYaml, IncludedYamlDir
|
|
|
|
from ..hass_config.loader import HassConfig
|
|
from .errors import InvalidAutomationFile
|
|
from .types import ExtenededAutomation
|
|
|
|
logger = get_logger(__file__)
|
|
|
|
|
|
def extract_automation_paths(
|
|
hass_config: HassConfig,
|
|
) -> Iterator[Tuple[str, Path]]:
|
|
found = False
|
|
for key, value in hass_config.configurations.items():
|
|
if str(key).startswith("automation"):
|
|
logger.info(f"Loading automations from '{key}'")
|
|
found = True
|
|
if isinstance(value, dict):
|
|
raise NotImplementedError(
|
|
"No support for automations baked into configuration.yaml! Please extract these into a seperate file"
|
|
)
|
|
elif isinstance(value, IncludedYaml):
|
|
yield key, hass_config.root_path / value.path_str
|
|
elif isinstance(value, IncludedYamlDir):
|
|
yield key, hass_config.root_path / value.name
|
|
else:
|
|
logger.warning(f"found an invalid type in {key}!")
|
|
if not found:
|
|
yield "", hass_config.root_path / "automations.yaml"
|
|
|
|
|
|
def load_automation_path(
|
|
automation_path: Path,
|
|
configuration_key: str,
|
|
) -> Iterator[ExtenededAutomation]:
|
|
"""
|
|
|
|
Args:
|
|
automation_path (Path)
|
|
configuration_key (str)
|
|
|
|
Returns:
|
|
Iterator[ExtenededAutomation]
|
|
|
|
"""
|
|
if not automation_path.exists():
|
|
logger.warning(f"the file {automation_path} does not exists")
|
|
return
|
|
if automation_path.is_dir():
|
|
for f in extract_files(automation_path):
|
|
yield from load_automation_path(f, configuration_key)
|
|
else:
|
|
try:
|
|
with automation_path.open("r") as fp:
|
|
automations = load_yaml(fp)
|
|
except Exception as err:
|
|
raise InvalidAutomationFile(
|
|
when="loading yaml",
|
|
automation_path=automation_path,
|
|
error=err,
|
|
) from err
|
|
|
|
if isinstance(automations, dict):
|
|
try:
|
|
yield ExtenededAutomation(
|
|
**clean_automation(automations),
|
|
configuration_key=configuration_key,
|
|
source_file=str(automation_path),
|
|
source_file_type="obj",
|
|
)
|
|
except Exception as err:
|
|
raise InvalidAutomationFile(
|
|
when="reading file contents",
|
|
automation_path=automation_path,
|
|
error=err,
|
|
) from err
|
|
else:
|
|
if automations is None:
|
|
logger.warning(f"the file {automation_path} is empty")
|
|
return
|
|
for automation in automations:
|
|
try:
|
|
yield ExtenededAutomation(
|
|
**clean_automation(automation),
|
|
configuration_key=configuration_key,
|
|
source_file=str(automation_path),
|
|
source_file_type="list",
|
|
)
|
|
except Exception as err:
|
|
raise InvalidAutomationFile(
|
|
when="reading file contents",
|
|
automation_path=automation_path,
|
|
error=err,
|
|
automation=automation,
|
|
) from err
|
|
|
|
|
|
def clean_automation(auto_raw: dict):
|
|
return {
|
|
**auto_raw,
|
|
"condition": ifempty_or_null_then_list(load_conditions(auto_raw.get("condition", []))),
|
|
"action": ifempty_or_null_then_list(load_conditions(auto_raw.get("action", []))),
|
|
"trigger": ifempty_or_null_then_list(normalize_obj(auto_raw.get("trigger", []))),
|
|
}
|
|
|
|
|
|
def ifempty_or_null_then_list(obj: Any):
|
|
if not isinstance(obj, list):
|
|
return []
|
|
else:
|
|
return obj
|
|
|
|
|
|
def load_conditions(conditions: Union[dict, list, str]):
|
|
if isinstance(conditions, list):
|
|
return list(map(ensure_condition_dictionary, conditions))
|
|
elif not conditions:
|
|
return []
|
|
else:
|
|
return [ensure_condition_dictionary(conditions)]
|
|
|
|
|
|
def ensure_condition_dictionary(c: Union[str, dict]):
|
|
c = normalize_obj(c)
|
|
if isinstance(c, str):
|
|
return {"condition": "template", "value_template": c}
|
|
elif isinstance(c, dict):
|
|
return c
|
|
raise InvalidAutomationFile(f"Invalid type for condition object {c}")
|