refactor + cleanup

This commit is contained in:
ari committed 2021-12-30 22:30:21 -05:00
1 parent 4a08956e1a
commit 381835c642
34 files changed
+724 -933

No files matched your search

+6 -8
View File
@@ -1,12 +1,10 @@
from src.env import ROOT_FOLDER
from src.db.connection import HassDatabase
from src.config.AutomationLoader import AutomationLoader
from src.yaml_serializer import load_hass_config
from src.automations.AutomationLoader import AutomationLoader
hass_config = load_hass_config(ROOT_FOLDER / "tests/samples")
# hass_config = load_hass_config(ROOT_FOLDER / "tests/samples")
db_connection = HassDatabase(
f"sqlite:///{ROOT_FOLDER / 'tests/samples'}/home-assistant_v2.db"
)
# db_connection = HassDatabase(
# f"sqlite:///{ROOT_FOLDER / 'tests/samples'}/home-assistant_v2.db"
# )
automation_loader = AutomationLoader(hass_config)
# automation_loader = AutomationLoader(hass_config)
+2 -2
View File
@@ -1,9 +1,9 @@
from typing import Optional
from fastapi import APIRouter, HTTPException
from src.config.AutomationLoader import AutomationData, AutomationLoaderException
# from src.automations.AutomationLoader import AutomationData, AutomationLoaderException
from ..config import automation_loader
# from ..config import automation_loader
router = APIRouter()
+100
View File
@@ -0,0 +1,100 @@
from typing import List, Optional
from src.yaml_serializer.types import IncludedYaml
from src.yaml_serializer import load_yaml, dump_yaml
from .types import AutomationData, AutomationMetdata
from .parsers import _parse_actions
from .errors import AutomationLoaderException
# Global Loader
class AutomationLoader:
def __init__(self, hass_config: HassConfig) -> None:
self.hass_config = hass_config
self.automation_ref = hass_config.config.get("automation", None)
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_raw_data)}' --> `automation: {self.automation_raw_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)
def save(self, index: int, auto: AutomationData):
"""Save or create automation on disk and in-memory
Args:
index (int): index of the automation
auto (AutomationData): automation data
"""
# Update in-memory store
if len(self) <= index:
self.automations_data.append(auto)
else:
self.automations_data[index] = auto
# Load a simple version of the latest data on disk
if not isinstance(self.automation_ref, IncludedYaml):
with self.hass_config.root_config_path.open("r") as f:
hass_config_yaml = load_yaml(f)
original_yaml_path = f"{self.hass_config.root_config_path}>automation"
if "automation" not in hass_config_yaml:
raise AutomationLoaderException(
f'missing "automation" key in {self.hass_config.root_config_path}'
)
original_yaml = hass_config_yaml["automation"]
else:
with self.automation_ref.original_path.open("r") as f:
original_yaml = load_yaml(f)
original_yaml_path = f"{self.automation_ref.original_path}"
if not isinstance(original_yaml, list):
raise AutomationLoaderException(
f"Invalid data received from {original_yaml_path} expected a list"
)
# Upsert automation
if len(original_yaml) <= index:
original_yaml.append(auto.to_primitive())
else:
original_yaml[index] = auto.to_primitive()
# Save back to disk
if isinstance(self.automation_ref, IncludedYaml):
with self.automation_ref.original_path.open("w") as f:
f.write(dump_yaml(original_yaml))
else:
hass_config_yaml["automation"] = original_yaml
with self.hass_config.root_config_path.open("w") as f:
f.write(dump_yaml(hass_config_yaml))
+20
View File
@@ -0,0 +1,20 @@
import os
from decouple import config
from pathlib import Path
def find_hass_config() -> Path:
"""Try to find HASS config."""
if "HASSIO_TOKEN" in os.environ:
return Path("/config")
"""Put together the default configuration directory based on the OS."""
data_dir = Path(config("APPDATA", None) if os.name == "nt" else os.path.expanduser("~"))
config_dir = data_dir / ".homeassistant"
if config_dir.is_dir():
return config_dir
raise ValueError(
"Unable to automatically find the location of Home Assistant " "config. Please pass it in."
)
+2
View File
@@ -0,0 +1,2 @@
class AutomationLoaderException(Exception):
pass
+33
View File
@@ -0,0 +1,33 @@
from itertools import chain
from typing import Iterable
from src.json_serializer import normalize_obj
from .types import AutomationData, AutomationMetdata
from .parsers import _parse_actions
# Single loader
def load_automation(
automations_raw_data: Iterable[dict],
) -> Iterable[AutomationData]:
"""Converts an automation dictionary loaded directly from the config into
several python typed objects
Args:
automations_raw_data (Iterable[dict])
Returns:
Iterable[AutomationData]
"""
for auto_raw in automations_raw_data:
yield AutomationData(
metadata=AutomationMetdata.parse_obj(auto_raw),
sequence=list(
_parse_actions(
chain(
auto_raw.get("condition", []),
auto_raw.get("action", []),
)
)
),
trigger=[normalize_obj(obj) for obj in auto_raw.get("trigger", [])],
)
+3
View File
@@ -0,0 +1,3 @@
class AutomationManager:
def __init__(self) -> None:
pass
+88
View File
@@ -0,0 +1,88 @@
from typing import Iterable, Union
from src.json_serializer import NOT_IMPLEMENTED_SV_MSG, json_dumps, normalize_obj
from src.yaml_serializer.types import SecretValue
from .types import AutomationActionNode, AutomationConditionNode
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": NOT_IMPLEMENTED_SV_MSG},
)
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),
)
+46
View File
@@ -0,0 +1,46 @@
from typing import Dict, List, Literal, Optional, Union
from pydantic.fields import Field
from pydantic import BaseModel
class AutomationConditionNode(BaseModel):
condition: str
condition_data: dict
node_type: Literal["condition"] = Field(alias="$smType", default="condition")
def to_primitive(self):
return {
**self.condition_data,
"condition": self.condition,
}
class AutomationActionNode(BaseModel):
action: str
action_data: dict
node_type: Literal["action"] = Field(alias="$smType", default="action")
def to_primitive(self):
return self.action_data
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] = []
sequence: List[Union[AutomationConditionNode, AutomationActionNode]] = []
def to_primitive(self):
return {
**self.metadata.dict(),
"trigger": self.trigger,
"condition": [],
"action": [action.to_primitive() for action in self.sequence],
}
-253
View File
@@ -1,253 +0,0 @@
from typing import Dict, Iterable, List, Literal, Optional, Union
from pydantic.fields import Field
from src.json_serializer import NOT_IMPLEMENTED_SV_MSG, json_dumps, normalize_obj
from src.yaml_serializer import HassConfig, IncludedYaml, SecretValue, dump_yaml, simple_load_yaml
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")
def to_primitive(self):
return {
**self.condition_data,
"condition": self.condition,
}
class AutomationActionNode(BaseModel):
action: str
action_data: dict
node_type: Literal["action"] = Field(alias="$smType", default="action")
def to_primitive(self):
return self.action_data
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]] = []
def to_primitive(self):
return {
**self.metadata.dict(),
"trigger": self.trigger,
"condition": [condition.to_primitive() for condition in self.condition],
"action": [action.to_primitive() for action in self.action],
}
# 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": NOT_IMPLEMENTED_SV_MSG},
)
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, hass_config: HassConfig) -> None:
self.hass_config = hass_config
self.automation_ref = hass_config.config.get("automation", None)
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_raw_data)}' --> `automation: {self.automation_raw_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)
def save(self, index: int, auto: AutomationData):
"""Save or create automation on disk and in-memory
Args:
index (int): index of the automation
auto (AutomationData): automation data
"""
# Update in-memory store
if len(self) <= index:
self.automations_data.append(auto)
else:
self.automations_data[index] = auto
# Load a simple version of the latest data on disk
if not isinstance(self.automation_ref, IncludedYaml):
with self.hass_config.root_config_path.open("r") as f:
hass_config_yaml = simple_load_yaml(f)
original_yaml_path = f"{self.hass_config.root_config_path}>automation"
if "automation" not in hass_config_yaml:
raise AutomationLoaderException(
f'missing "automation" key in {self.hass_config.root_config_path}'
)
original_yaml = hass_config_yaml["automation"]
else:
with self.automation_ref.original_path.open("r") as f:
original_yaml = simple_load_yaml(f)
original_yaml_path = f"{self.automation_ref.original_path}"
if not isinstance(original_yaml, list):
raise AutomationLoaderException(
f"Invalid data received from {original_yaml_path} expected a list"
)
# Upsert automation
if len(original_yaml) <= index:
original_yaml.append(auto.to_primitive())
else:
original_yaml[index] = auto.to_primitive()
# Save back to disk
if isinstance(self.automation_ref, IncludedYaml):
with self.automation_ref.original_path.open("w") as f:
f.write(dump_yaml(original_yaml))
else:
hass_config_yaml["automation"] = original_yaml
with self.hass_config.root_config_path.open("w") as f:
f.write(dump_yaml(hass_config_yaml))
-46
View File
@@ -1,46 +0,0 @@
import os
from decouple import config
from pathlib import Path
from src.yaml_serializer import load_hass_config
def find_hass_config() -> Path:
"""Try to find HASS config."""
if "HASSIO_TOKEN" in os.environ:
return Path("/config")
"""Put together the default configuration directory based on the OS."""
data_dir = Path(
config("APPDATA", None) if os.name == "nt" else os.path.expanduser("~")
)
config_dir = data_dir / ".homeassistant"
if config_dir.is_dir():
return config_dir
raise ValueError(
"Unable to automatically find the location of Home Assistant "
"config. Please pass it in."
)
def db_url_from_hass_config(path: Path):
"""Find the recorder database url from a HASS config dir."""
config = load_hass_config(path)
recorder = config.get("recorder")
if recorder:
db_url = recorder.get("db_url")
if db_url is not None:
return db_url
default_path = path / "home-assistant_v2.db"
default_url = f"sqlite:///{default_path.absolute()}"
if not os.path.isfile(default_path):
raise ValueError(
"Unable to determine DB url from hass config at {}".format(path)
)
return default_url
-41
View File
@@ -1,41 +0,0 @@
from sqlalchemy import create_engine, text
from urllib.parse import urlparse
class HassDatabase:
def __init__(self, db_url: str) -> None:
self.url = urlparse(db_url)
self.entities = None
try:
self.engine = create_engine(db_url)
self.connection = None
except Exception as exc:
if isinstance(exc, ImportError):
raise RuntimeError(
"The right dependency to connect to your database is "
"missing. Please make sure that it is installed."
) from exc
raise
@property
def db_type(self):
return self.url.scheme.split("+")[0]
def execute_sql(self, sql: str, **args):
self.connect()
resp = self.engine.execute(text(sql), **args)
self.close()
return resp.fetchall()
def connect(self):
if self.connection is None:
self.connection = self.engine.connect()
def close(self):
if self.connection is not None:
self.connection.close()
self.connection = None
def __del__(self):
self.close()
-59
View File
@@ -1,59 +0,0 @@
import json
from pydantic import BaseModel
from typing import Dict, Iterable, List, Optional, Union
from .connection import HassDatabase
class Entity(BaseModel):
entity_id: str
domain: str
attributes: dict
def search(
db_connection: HassDatabase,
search_text: str,
offset: int = 0,
limit: int = 100,
domain_filter: Optional[str] = None,
attributes_filter: Optional[Dict[str, Union[str, bool, int, float]]] = None,
) -> Iterable[Entity]:
filter_sql = f"entity_id like '%%{search_text}%%' AND old_state_id is NULL"
if domain_filter:
filter_sql += f" AND `domain` like '%%{domain_filter}%%'"
for entity_id, domain, attributes_str in db_connection.execute_sql(
f"""
SELECT
entity_id,
`domain` ,
`attributes`
FROM
states
WHERE
{filter_sql}
LIMIT {offset}, {limit}
"""
):
attributes: dict = json.loads(attributes_str)
if attributes_filter:
if not _compare_attr(attributes, attributes_filter):
continue
yield Entity(
entity_id=entity_id,
domain=domain,
attributes=attributes,
)
def _compare_attr(attributes: dict, attributes_filter: dict) -> bool:
for attr_name, attr_value in attributes_filter.items():
if attr_name not in attributes:
return False
if not type(attributes[attr_name]) == type(attr_value):
return False
if isinstance(attr_value, str):
if attributes[attr_name].find(attr_value) < 0:
return False
if attributes[attr_name] != attr_value:
return False
return True
File renamed without changes.
+6
View File
@@ -0,0 +1,6 @@
class HassConfigError(Exception):
pass
class MissingFile(HassConfigError):
pass
+28
View File
@@ -0,0 +1,28 @@
from pathlib import Path
from typing import List
from src.yaml_serializer import load_yaml
from src.yaml_serializer.types import IncludedYaml
class HassConfig:
def __init__(self, root_path: Path) -> None:
self.root_path = root_path
@property
def configurations(self) -> dict:
with (self.root_path / "configuration.yaml").open("r") as f:
return dict(load_yaml(f)) # type: ignore
@property
def automations(self) -> List[dict]:
automation_path = self.root_path / "automations.yaml"
config = self.configurations
if "automation" in config:
automation_ref = config["automation"]
if isinstance(automation_ref, IncludedYaml):
automation_path = automation_ref.path
else:
return list(config["automation"])
with automation_path.open("r") as f:
return list(load_yaml(f)) # type: ignore
+1
View File
@@ -0,0 +1 @@
+1 -1
View File
@@ -1,6 +1,6 @@
import orjson
from typing import Any, Union
from src.yaml_serializer import SecretValue
from src.yaml_serializer.types import SecretValue
# TODO: add support for these
NOT_IMPLEMENTED_SV_MSG = "SECRET VALUE NOT IMPLEMENTED"
-176
View File
@@ -1,176 +0,0 @@
from pathlib import Path
from typing import Any, NamedTuple, Optional
from ruamel.yaml import YAML
from ruamel.yaml.constructor import SafeConstructor
from ruamel.yaml.nodes import Node
from src.logger import logger
from src.yaml_serializer.types import IncludedYamlDir, SecretValue, IncludedYaml
class HassYaml:
"""Load a YAML file based on the standard defined by HASS
Args:
file_path (Path): path to yaml file
Returns:
dict
"""
def __init__(self) -> None:
self.secrets: dict = {}
self.current_file_path: Optional[str] = None
self.yaml_loader = YAML(typ="safe")
# Compat with HASS
self.yaml_loader.allow_duplicate_keys = True
# Stub HASS constructors
class HassSafeConstructor(SafeConstructor):
"""Hass specific SafeConstructor."""
def _include_yaml(_loader, node: Node):
"""Load another YAML file and embeds it using the !include tag.
Example:
device_tracker: !include device_tracker.yaml
"""
root_path = (
self.current_file_path.parent if self.current_file_path is not None else Path("/")
)
file_path = _upward_recursive_search(root_path, node.value)
if file_path is None:
logger.warning(f"Could not find `!include {node.value}`!")
return None
else:
logger.info(f"Found `!include {node.value}` in {file_path.absolute()}!")
return IncludedYaml(node.value, file_path, self.__internal_constructor_load(file_path))
def _secret_yaml(loader, node: Node):
"""Load secrets and embed it into the configuration YAML."""
secret = self.secrets.get(node.value, None)
if secret is None:
logger.warning(
f"The secret {node.value} failed to load, please check your `secret.yaml` file."
)
return SecretValue(node.value, secret)
HassSafeConstructor.add_constructor("!include", _include_yaml)
HassSafeConstructor.add_constructor("!env_var", _stub_tag)
HassSafeConstructor.add_constructor("!secret", _secret_yaml)
HassSafeConstructor.add_constructor("!include_dir_list", _stub_tag)
HassSafeConstructor.add_constructor("!include_dir_merge_list", _stub_tag)
HassSafeConstructor.add_constructor("!include_dir_named", _stub_tag)
HassSafeConstructor.add_constructor("!include_dir_merge_named", _stub_tag)
self.yaml_loader.Constructor = HassSafeConstructor
def load(self, file_path: Path) -> dict:
"""Loads a given yaml file into a dictionary
Args:
file_path (Path): path to yaml file
Returns:
dict
"""
self.secrets = self.__load_secrets(file_path.parent)
return self.__load(file_path)
def __internal_constructor_load(self, file_path: Path):
"""This is similar to `self.load` function but it is only called internally by the yaml parsers
as it also manages the references to which file we are currently processing
Args:
file_path (Path): path to yaml file
Returns:
dict
"""
last_file_path = self.current_file_path
loaded = self.__load(file_path)
self.current_file_path = last_file_path
return loaded
def __load(self, file_path: Path) -> dict:
"""Generic load yaml function.
This function is called by either `self.load` or `self.__internal_constructor_load`
Args:
file_path (Path): path to yaml file
Returns:
dict
"""
self.current_file_path = file_path
with file_path.open(encoding="utf-8") as conf_file:
# If configuration file is empty YAML returns None
# We convert that to an empty dict
return self.yaml_loader.load(conf_file) or {}
def __load_secrets(self, root_path: Path) -> dict:
"""Preloads all of the secrets into memory
Args:
root_path (Path): root path where we search for the serects.yaml file
Returns:
dict: all secrets in dict format
"""
file_path = _upward_recursive_search(root_path, "secrets.yaml")
if file_path is None:
logger.warning(f"Secrets file could not be found!")
return {}
else:
logger.info(f"Found secrets file in `{file_path.absolute()}`!")
with file_path.open() as secret_file:
return YAML(typ="safe").load(secret_file)
def _upward_recursive_search(root_dir: Path, file_name: str) -> Optional[Path]:
"""Recursively search for a file or return None
i.e.
assume we are in local deployment where our /config is sitting in /home/awesomeuser/ha/config
you specified somewhere in the yaml `device_tracker: !include device_tracker.yaml`
then
root_dir = Path(/home/awesomeuser/ha/config)
file_name = device_tracker.yaml
we then first search /home/awesomeuser/ha/config
if we find nothin go up to /home/awesomeuser/ha
if we find nothin go up to /home/awesomeuser
if we find nothin go up to /home
if we find nothin go up to /
if we still find nothing return None
if we found something at any stage, we will return it's direct path
Args:
root_dir (Path)
file_name (str)
Returns:
Optional[Path]
"""
dir_path = root_dir
file_path = dir_path / file_name
for _ in root_dir.parts:
if file_path.exists():
return file_path
dir_path = root_dir
file_path = dir_path / file_name
return None
def _stub_tag(constructor, node: Node):
"""Stub a constructor with a dictionary."""
seen = getattr(constructor, "_stub_seen", None)
if seen is None:
seen = constructor._stub_seen = set()
if node.tag not in seen:
logger.warning(f"YAML tag {node.tag} is not supported")
seen.add(node.tag)
return IncludedYamlDir(node.tag, node.value)
+2 -21
View File
@@ -1,25 +1,6 @@
import io
from pathlib import Path
from typing import Any, Union
from typing import Any, Union, TextIO
from src.yaml_serializer.base_yaml import yaml
from src.yaml_serializer.HassYaml import HassYaml
from src.yaml_serializer.types import HassConfig, SecretValue, IncludedYaml, IncludedYamlDir
## TODO: consider deprecating this and using 'simple_load_yaml' for consistency
def load_hass_config(file_path: Path) -> HassConfig:
"""Load all Hass configrations from the root config folder
**highly opinionated**
Args:
file_path (Path)
Returns:
HassConfig
"""
HAY = HassYaml()
data = HAY.load(file_path / "configuration.yaml")
return HassConfig(HAY.secrets, data, file_path / "configuration.yaml")
def dump_yaml(obj: Any) -> str:
@@ -37,7 +18,7 @@ def dump_yaml(obj: Any) -> str:
return stream.read()
def simple_load_yaml(yaml_stream: io.StringIO) -> Union[dict, list]:
def load_yaml(yaml_stream: TextIO) -> Union[dict, list]:
"""Load yaml from string using some hass-compliant yaml strings
Args:
+5 -15
View File
@@ -9,17 +9,15 @@ class IncludedYaml(NamedTuple):
this data type will represent it.
"""
name: str # original node name
original_path: Path # path to location of original file
data: Any # the parsed data
path: Path # original node path
@classmethod
def to_yaml(cls, representer: BaseRepresenter, node: "IncludedYaml"):
return representer.represent_scalar("!include", node.name)
return representer.represent_scalar("!include", str(node.path.absolute()))
@classmethod
def from_yaml(cls, _constructor, node: Node):
return cls(node.value, Path("/"), "n/a")
return cls(Path(node.value).absolute())
class SecretValue(NamedTuple):
@@ -27,7 +25,7 @@ class SecretValue(NamedTuple):
value: str
@classmethod
def to_yaml(cls, representer: BaseRepresenter, node: Node):
def to_yaml(cls, representer: BaseRepresenter, node: "SecretValue"):
return representer.represent_scalar("!secret", node.name)
@classmethod
@@ -48,17 +46,9 @@ class IncludedYamlDir(NamedTuple):
name: str # original node name
@classmethod
def to_yaml(cls, representer: BaseRepresenter, node: "IncludedYaml"):
def to_yaml(cls, representer: BaseRepresenter, node: "IncludedYamlDir"):
return representer.represent_scalar(f"!{node.original_tag}", node.name)
@classmethod
def from_yaml(cls, _constructor, node: Node):
return cls(node.tag[1:], node.value)
class HassConfig(NamedTuple):
"""The final output for load_hass_config"""
secrets: dict # the secrets file content
config: dict # the complete configration.yaml tree
root_config_path: Path # where the root 'configuration.yaml' lives