Files
Shortumation/api/src/config/AutomationLoader.py
T
2021-11-11 11:12:50 -05:00

196 lines
6.8 KiB
Python

from typing import Dict, Iterable, List, Literal, Optional, Union
from pydantic.fields import Field
from pydantic.error_wrappers import ValidationError
from src.json_serializer import json_dumps, normalize_obj
from src.config.HassSafeConstructor import HassConfig, IncludedYaml, SecretValue
from pydantic import BaseModel
# errors
class AutomationLoaderException(Exception):
pass
# types
class AutomationConditionNode(BaseModel):
condition: str
condition_data: dict
node_type: Literal["condition"] = Field(alias="$smType", default="condition")
class AutomationActionNode(BaseModel):
action: str
action_data: dict
node_type: Literal["action"] = Field(alias="$smType", default="action")
class AutomationMetdata(BaseModel):
id: str
alias: Optional[str] = None
description: Optional[str] = None
trigger_variables: Optional[Dict[str, Union[str, int, bool, float]]] = None
mode: Literal["single", "restart", "queued", "parallel"] = "single"
class AutomationData(BaseModel):
metadata: AutomationMetdata
trigger: List[dict] = []
condition: List[AutomationConditionNode] = []
action: List[Union[AutomationConditionNode, AutomationActionNode]] = []
# Single loader
def load_automation(
automations_raw_data: List[dict],
) -> Iterable[AutomationData]:
"""Converts an automation dictionary loaded directly from the config into
several python typed objects
Args:
automations_raw_data (List[dict])
Returns:
Iterable[AutomationData]
"""
for auto_raw in automations_raw_data:
yield AutomationData(
metadata=AutomationMetdata.parse_obj(auto_raw),
condition=list(_parse_conditions(auto_raw.get("condition", []))),
action=list(_parse_actions(auto_raw.get("action", []))),
trigger=[normalize_obj(obj) for obj in auto_raw.get("trigger", [])],
)
def _parse_actions(
raw_actions: Iterable[Union[dict, str]]
) -> Iterable[Union[AutomationActionNode, AutomationConditionNode]]:
for raw_c in raw_actions:
action_type = "unknown"
if isinstance(raw_c, str):
yield from _parse_conditions([raw_c])
continue
elif isinstance(raw_c, dict):
if raw_c.get("condition"):
yield from _parse_conditions([raw_c])
continue
elif raw_c.get("service"):
action_type = "service"
action_data = normalize_obj(raw_c)
elif raw_c.get("repeat"):
action_type = "repeat"
repeat_data = raw_c.pop("repeat")
action_data = {
**raw_c,
"repeat": {
"count": repeat_data.get("count", 0),
"sequence": list(
_parse_actions(repeat_data.get("sequence", []))
),
},
}
elif raw_c.get("wait_template"):
action_type = "wait"
action_data = normalize_obj(raw_c)
elif raw_c.get("event"):
action_type = "event"
action_data = normalize_obj(raw_c)
elif raw_c.get("type") and raw_c.get("device_id"):
action_type = "device"
action_data = normalize_obj(raw_c)
elif raw_c.get("choose"):
action_type = "choose"
choose_data = raw_c.pop("choose")
default_data = raw_c.pop("default", [])
action_data = {
**raw_c,
"choose": [
{
"conditions": list(
_parse_conditions(option.get("conditions", []))
),
"sequence": list(
_parse_actions(option.get("sequence", []))
),
}
for option in choose_data
],
"default": list(_parse_actions(default_data)),
}
else:
action_data = normalize_obj(raw_c)
yield AutomationActionNode(action=action_type, action_data=action_data)
def _parse_conditions(
raw_conditions: Iterable[Union[dict, str]]
) -> Iterable[AutomationConditionNode]:
for raw_c in raw_conditions:
if isinstance(raw_c, str):
yield AutomationConditionNode(
condition="template",
condition_data={"value_template": raw_c},
)
elif isinstance(raw_c, SecretValue):
yield AutomationConditionNode(
condition="template",
condition_data={"value_template": "SECRETS NOT SUPPORTED"},
)
elif isinstance(raw_c, dict):
condition = raw_c.pop("condition")
yield AutomationConditionNode(
condition=condition,
condition_data=normalize_obj(raw_c),
)
else:
yield AutomationConditionNode(
condition="template",
condition_data=json_dumps(raw_c),
)
# Global Loader
class AutomationLoader:
def __init__(self, loaded_yaml: HassConfig) -> None:
self.automation_ref = loaded_yaml.config["automation"]
if isinstance(self.automation_ref, IncludedYaml):
self.automation_raw_data: list = self.automation_ref.data
else:
self.automation_raw_data: list = self.automation_ref
self.automation_ref = None
if not isinstance(self.automation_raw_data, list):
raise AutomationLoaderException(
f"Invalid automation file, expected it to be a 'list' instead it's a '{type(self.automation_data)}'"
)
self.automations_data = list(load_automation(self.automation_raw_data))
def find(
self,
offset: int = 0,
limit: int = 10,
alias: Optional[str] = None,
description: Optional[str] = None,
mode: Optional[str] = None,
):
for auto in self.automations_data[offset : (offset + limit)]:
if alias is not None:
if auto.metadata.alias.lower().count(alias.lower()) <= 0:
continue
if description is not None:
if auto.metadata.description.lower().count(description.lower()) <= 0:
continue
if mode is not None:
if auto.metadata.mode.lower().count(mode.lower()) <= 0:
continue
yield auto
def get(self, index: int):
if (index < 0) or (len(self.automations_data) <= index):
return None
return self.automations_data[index]
def __len__(self):
return len(self.automations_data)