Files
Shortumation/api/src/automations_v2/loader.py
T
2022-08-15 15:46:58 -04:00

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}")