Files
Shortumation/api/src/automations/loader.py
T
2022-08-27 13:58:41 -04:00

253 lines
8.9 KiB
Python

from itertools import chain
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 (
IncludedYaml,
IncludedYamlDir,
dump_yaml,
load_yaml,
)
from ..hass_config.loader import HassConfig
from .errors import InvalidAutomationFile
from .tags import TagManager
from .types import (
AutomationExtractedIter,
ConfigurationKey,
ExtenededAutomation,
IncludedAutoamtion,
InlineAutomation,
)
logger = get_logger(__file__)
AUTOMATION_CONFIGURATION_KEY = "automation shortumation"
def load_and_iter_automations(
hass_config: HassConfig, tag_manager: TagManager
) -> Iterator[ExtenededAutomation]:
for ref in extract_automation_refs(hass_config):
try:
if isinstance(ref, IncludedAutoamtion):
yield from load_automation_path(
hass_config.root_path,
hass_config.root_path / ref.ref.path,
ref.configuration_key,
tag_manager,
)
else:
yield from load_automation_inline_ref(hass_config.root_path, tag_manager, ref)
except InvalidAutomationFile as e:
logger.error(e)
def extract_automation_refs(
hass_config: HassConfig,
) -> AutomationExtractedIter:
found = False
for ref in chain(
extract_automation_root_refs(hass_config), extract_automation_package_refs(hass_config)
):
found = True
yield ref
if not found:
yield IncludedAutoamtion([""], IncludedYaml(hass_config.get_default_automation_path()))
def extract_automation_root_refs(
hass_config: HassConfig,
) -> AutomationExtractedIter:
for key, value in extract_automation_keys(hass_config):
logger.info(f"Loading automations from '{key}'")
if isinstance(value, IncludedYamlDir): # type: ignore
yield IncludedAutoamtion([key], value)
elif isinstance(value, list):
yield InlineAutomation(
configuration_key=[key],
automations=value,
source_file=hass_config.get_configuration_path(),
)
else:
logger.warning(f"found an invalid type in {key}!")
def extract_automation_package_refs(hass_config: HassConfig) -> AutomationExtractedIter:
for package_name, package_data in hass_config.pacakges.items():
if not isinstance(package_data, dict):
logger.warning(f"The package {package_name} is incorrectly configured!")
else:
if automations := package_data.get("automation", None):
logger.info(f"Loading automations from package '{package_name}'")
if isinstance(automations, IncludedYamlDir): # type: ignore
yield IncludedAutoamtion([package_name], automations)
elif isinstance(automations, list):
logger.warning(
f"Failed to load from '{package_name}' as no support for inline automations yet."
)
else:
logger.warning(f"found an invalid type in {package_name}!")
def get_base_automation_key(hass_config: HassConfig) -> Tuple[ConfigurationKey, str]:
found_any = False
for key, value in extract_automation_keys(hass_config):
found_any = True
if isinstance(value, IncludedYaml):
return [key], str(value.path.relative_to(hass_config.root_path))
configurations = hass_config.configurations
if found_any:
out_path = hass_config.get_backup_automation_file_path()
else:
if not (out_path := hass_config.get_default_automation_path()): # type: ignore
raise AssertionError("Failed to find automation files...")
out_file = str(out_path.relative_to(hass_config.root_path))
configurations[AUTOMATION_CONFIGURATION_KEY] = IncludedYaml(out_path)
out_path.touch(exist_ok=True)
with hass_config.get_configuration_path().open("w") as fp:
fp.write(dump_yaml(configurations, root_path=hass_config.root_path))
return [AUTOMATION_CONFIGURATION_KEY], out_file
def extract_automation_keys(
hass_config: HassConfig,
) -> Iterator[Tuple[str, IncludedYamlDir | list]]:
for key, value in hass_config.configurations.items():
if str(key).startswith("automation"):
if isinstance(value, list):
yield key, value
elif isinstance(value, IncludedYamlDir): # type: ignore
yield key, value
else:
logger.warning(f"found an invalid type in {key}!")
def load_automation_inline_ref(
root_path: Path, tag_manager: TagManager, inline_automation: InlineAutomation
) -> Iterator[ExtenededAutomation]:
for auto in inline_automation.automations:
try:
yield ExtenededAutomation(
**clean_automation(auto),
tags=tag_manager.get(auto["id"], {}),
configuration_key=inline_automation.configuration_key,
source_file=str(inline_automation.source_file.relative_to(root_path)),
source_file_type="inline",
)
except Exception as err:
raise InvalidAutomationFile(
when="reading file contents",
automation_path=inline_automation.source_file,
error=err,
) from err
def load_automation_path(
root_path: Path,
automation_path: Path,
configuration_key: ConfigurationKey,
tag_manager: TagManager,
) -> Iterator[ExtenededAutomation]:
"""
Args:
automation_path (Path)
configuration_key (list[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(root_path, f, configuration_key, tag_manager)
else:
try:
with automation_path.open("r") as fp:
automations = load_yaml(fp, root_path=root_path)
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),
tags=tag_manager.get(automations["id"], {}),
configuration_key=configuration_key,
source_file=str(automation_path.relative_to(root_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),
tags=tag_manager.get(automation["id"], {}),
configuration_key=configuration_key,
source_file=str(automation_path.relative_to(root_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}")