diff --git a/.gitignore b/.gitignore deleted file mode 100644 index 2d4eef0..0000000 --- a/.gitignore +++ /dev/null @@ -1,9 +0,0 @@ -web/node_modules -web/.parcel-cache -web/dist -api/venv -**__pycache__** -*.db* -.coverage -api/tests/samples/ -.tmp** \ No newline at end of file diff --git a/api/.gitignore b/api/.gitignore new file mode 100644 index 0000000..4906f4c --- /dev/null +++ b/api/.gitignore @@ -0,0 +1,145 @@ + +# Created by https://www.toptal.com/developers/gitignore/api/python +# Edit at https://www.toptal.com/developers/gitignore?templates=python + +### Python ### +# Byte-compiled / optimized / DLL files +__pycache__/ +*.py[cod] +*$py.class + +# C extensions +*.so + +# Distribution / packaging +.Python +build/ +develop-eggs/ +dist/ +downloads/ +eggs/ +.eggs/ +lib/ +lib64/ +parts/ +sdist/ +var/ +wheels/ +share/python-wheels/ +*.egg-info/ +.installed.cfg +*.egg +MANIFEST + +# PyInstaller +# Usually these files are written by a python script from a template +# before PyInstaller builds the exe, so as to inject date/other infos into it. +*.manifest +*.spec + +# Installer logs +pip-log.txt +pip-delete-this-directory.txt + +# Unit test / coverage reports +htmlcov/ +.tox/ +.nox/ +.coverage +.coverage.* +.cache +nosetests.xml +coverage.xml +*.cover +*.py,cover +.hypothesis/ +.pytest_cache/ +cover/ + +# Translations +*.mo +*.pot + +# Django stuff: +*.log +local_settings.py +db.sqlite3 +db.sqlite3-journal + +# Flask stuff: +instance/ +.webassets-cache + +# Scrapy stuff: +.scrapy + +# Sphinx documentation +docs/_build/ + +# PyBuilder +.pybuilder/ +target/ + +# Jupyter Notebook +.ipynb_checkpoints + +# IPython +profile_default/ +ipython_config.py + +# pyenv +# For a library or package, you might want to ignore these files since the code is +# intended to run in multiple environments; otherwise, check them in: +# .python-version + +# pipenv +# According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control. +# However, in case of collaboration, if having platform-specific dependencies or dependencies +# having no cross-platform support, pipenv may install dependencies that don't work, or not +# install all needed dependencies. +#Pipfile.lock + +# PEP 582; used by e.g. github.com/David-OConnor/pyflow +__pypackages__/ + +# Celery stuff +celerybeat-schedule +celerybeat.pid + +# SageMath parsed files +*.sage.py + +# Environments +.env +.venv +env/ +venv/ +ENV/ +env.bak/ +venv.bak/ + +# Spyder project settings +.spyderproject +.spyproject + +# Rope project settings +.ropeproject + +# mkdocs documentation +/site + +# mypy +.mypy_cache/ +.dmypy.json +dmypy.json + +# Pyre type checker +.pyre/ + +# pytype static type analyzer +.pytype/ + +# Cython debug symbols +cython_debug/ + +# End of https://www.toptal.com/developers/gitignore/api/python diff --git a/api/.vscode/settings.json b/api/.vscode/settings.json index 1065d2b..360fda8 100644 --- a/api/.vscode/settings.json +++ b/api/.vscode/settings.json @@ -1,14 +1,5 @@ { "python.formatting.provider": "black", - "sqltools.connections": [ - { - "previewLimit": 50, - "driver": "SQLite", - "name": "ha", - "sqltools.useNodeRuntime": true, - "database": "./tests/samples/home-assistant_v2.db" - } - ], "python.testing.unittestArgs": [ "-v", "-s", @@ -18,4 +9,4 @@ ], "python.testing.pytestEnabled": false, "python.testing.unittestEnabled": true -} \ No newline at end of file +} diff --git a/api/src/api/config.py b/api/src/api/config.py index 6b1ef95..5c8661b 100644 --- a/api/src/api/config.py +++ b/api/src/api/config.py @@ -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) diff --git a/api/src/api/routes/automations.py b/api/src/api/routes/automations.py index a6c956e..122fb50 100644 --- a/api/src/api/routes/automations.py +++ b/api/src/api/routes/automations.py @@ -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() diff --git a/api/src/automations/AutomationLoader.py b/api/src/automations/AutomationLoader.py new file mode 100644 index 0000000..0fa3106 --- /dev/null +++ b/api/src/automations/AutomationLoader.py @@ -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)) diff --git a/api/src/automations/__init__.py b/api/src/automations/__init__.py new file mode 100644 index 0000000..fde69ba --- /dev/null +++ b/api/src/automations/__init__.py @@ -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." + ) diff --git a/api/src/automations/errors.py b/api/src/automations/errors.py new file mode 100644 index 0000000..2638e97 --- /dev/null +++ b/api/src/automations/errors.py @@ -0,0 +1,2 @@ +class AutomationLoaderException(Exception): + pass diff --git a/api/src/automations/loader.py b/api/src/automations/loader.py new file mode 100644 index 0000000..9fec95b --- /dev/null +++ b/api/src/automations/loader.py @@ -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", [])], + ) diff --git a/api/src/automations/manager.py b/api/src/automations/manager.py new file mode 100644 index 0000000..d22dd83 --- /dev/null +++ b/api/src/automations/manager.py @@ -0,0 +1,3 @@ +class AutomationManager: + def __init__(self) -> None: + pass diff --git a/api/src/automations/parsers.py b/api/src/automations/parsers.py new file mode 100644 index 0000000..53dc745 --- /dev/null +++ b/api/src/automations/parsers.py @@ -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), + ) diff --git a/api/src/automations/types.py b/api/src/automations/types.py new file mode 100644 index 0000000..efb6902 --- /dev/null +++ b/api/src/automations/types.py @@ -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], + } diff --git a/api/src/config/AutomationLoader.py b/api/src/config/AutomationLoader.py deleted file mode 100644 index b06c760..0000000 --- a/api/src/config/AutomationLoader.py +++ /dev/null @@ -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)) diff --git a/api/src/config/__init__.py b/api/src/config/__init__.py deleted file mode 100644 index b1808a2..0000000 --- a/api/src/config/__init__.py +++ /dev/null @@ -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 diff --git a/api/src/db/connection.py b/api/src/db/connection.py deleted file mode 100644 index 2a01ad0..0000000 --- a/api/src/db/connection.py +++ /dev/null @@ -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() diff --git a/api/src/db/entities.py b/api/src/db/entities.py deleted file mode 100644 index acbe784..0000000 --- a/api/src/db/entities.py +++ /dev/null @@ -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 diff --git a/api/src/db/__init__.py b/api/src/hass_config/__init__.py similarity index 100% rename from api/src/db/__init__.py rename to api/src/hass_config/__init__.py diff --git a/api/src/hass_config/errors.py b/api/src/hass_config/errors.py new file mode 100644 index 0000000..cda3e2b --- /dev/null +++ b/api/src/hass_config/errors.py @@ -0,0 +1,6 @@ +class HassConfigError(Exception): + pass + + +class MissingFile(HassConfigError): + pass diff --git a/api/src/hass_config/loader.py b/api/src/hass_config/loader.py new file mode 100644 index 0000000..af6d4b4 --- /dev/null +++ b/api/src/hass_config/loader.py @@ -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 diff --git a/api/src/hass_config/types.py b/api/src/hass_config/types.py new file mode 100644 index 0000000..8b13789 --- /dev/null +++ b/api/src/hass_config/types.py @@ -0,0 +1 @@ + diff --git a/api/src/json_serializer.py b/api/src/json_serializer.py index 73e5e72..e73bd30 100644 --- a/api/src/json_serializer.py +++ b/api/src/json_serializer.py @@ -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" diff --git a/api/src/yaml_serializer/HassYaml.py b/api/src/yaml_serializer/HassYaml.py deleted file mode 100644 index 77f6dc8..0000000 --- a/api/src/yaml_serializer/HassYaml.py +++ /dev/null @@ -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) diff --git a/api/src/yaml_serializer/__init__.py b/api/src/yaml_serializer/__init__.py index e5f01fc..bb700c8 100644 --- a/api/src/yaml_serializer/__init__.py +++ b/api/src/yaml_serializer/__init__.py @@ -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: diff --git a/api/src/yaml_serializer/types.py b/api/src/yaml_serializer/types.py index d81e9d5..1ce7975 100644 --- a/api/src/yaml_serializer/types.py +++ b/api/src/yaml_serializer/types.py @@ -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 diff --git a/api/tests/samples/example_config_folder b/api/tests/samples/example_config_folder new file mode 160000 index 0000000..2f2c69d --- /dev/null +++ b/api/tests/samples/example_config_folder @@ -0,0 +1 @@ +Subproject commit 2f2c69d6db5c6b32eee66ad62bcce7553a4ef96c diff --git a/api/tests/unittests/automations/__init__.py b/api/tests/unittests/automations/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/api/tests/unittests/automations/test_loader.py b/api/tests/unittests/automations/test_loader.py new file mode 100644 index 0000000..60a9a1b --- /dev/null +++ b/api/tests/unittests/automations/test_loader.py @@ -0,0 +1,67 @@ +from unittest import TestCase +from src.automations.types import ( + AutomationActionNode, + AutomationConditionNode, + AutomationData, + AutomationMetdata, +) +from src.automations.loader import load_automation +from src.json_serializer import NOT_IMPLEMENTED_SV_MSG +from src.yaml_serializer.types import ( + SecretValue, +) + + +class loader_tests(TestCase): + def test_load_automation_runs(self): + auto = list( + load_automation( + [ + { + "id": "1616887975473", + "alias": "Home Assistant Off", + "description": "", + "trigger": [{"platform": "homeassistant", "event": "shutdown"}], + "condition": ["states(time.time) >= '10:00:00'"], + "action": [ + { + "device_id": SecretValue("my_mobile_phone", "..."), + "domain": "mobile_app", + "type": "notify", + "title": "Hassio Status", + "message": "Hassio Is turning off...", + } + ], + "mode": "single", + } + ] + ) + ) + self.assertEqual( + auto[0], + AutomationData( + metadata=AutomationMetdata( + id="1616887975473", + alias="Home Assistant Off", + description="", + mode="single", + ), + trigger=[{"platform": "homeassistant", "event": "shutdown"}], + sequence=[ + AutomationConditionNode( + condition="template", + condition_data={"value_template": "states(time.time) >= '10:00:00'"}, + ), + AutomationActionNode( + action="device", + action_data={ + "device_id": NOT_IMPLEMENTED_SV_MSG, + "domain": "mobile_app", + "type": "notify", + "title": "Hassio Status", + "message": "Hassio Is turning off...", + }, + ), + ], + ), + ) diff --git a/api/tests/unittests/test_config.py b/api/tests/unittests/automations/test_parsers.py similarity index 51% rename from api/tests/unittests/test_config.py rename to api/tests/unittests/automations/test_parsers.py index ed3d292..eb28fe1 100644 --- a/api/tests/unittests/test_config.py +++ b/api/tests/unittests/automations/test_parsers.py @@ -1,46 +1,19 @@ -from pathlib import Path -from tempfile import mkdtemp from unittest import TestCase -from src.config.AutomationLoader import ( +from src.automations.types import ( AutomationActionNode, AutomationConditionNode, - AutomationData, - AutomationLoader, - AutomationLoaderException, - AutomationMetdata, - load_automation, +) +from src.automations.parsers import ( _parse_conditions, _parse_actions, ) from src.json_serializer import NOT_IMPLEMENTED_SV_MSG -from src.yaml_serializer import ( +from src.yaml_serializer.types import ( SecretValue, - load_hass_config, - IncludedYaml, ) -from tests.utils import SAMPLE_HA_PATH, create_dummy_config_folder -from src.yaml_serializer.types import HassConfig -class config_finder_tests(TestCase): - def test_simple_made_up_config(self): - pass - - def test_find_sample_config(self): - secrets, config, file_path = load_hass_config(SAMPLE_HA_PATH) - self.assertIsInstance(config["template"], IncludedYaml) - self.assertIsInstance(config["binary_sensor"], IncludedYaml) - self.assertIsInstance(config["group"], IncludedYaml) - self.assertIsInstance(config["switch"], IncludedYaml) - self.assertEqual(secrets["myamazingpassword"], "holymoly") - self.assertEqual( - config["automation"].data[32]["trigger"][0]["device_id"], - SecretValue("baby_btn_device_id", "347492ffc6b909a55ebe08745fca1bf6"), - ) - self.assertEqual(file_path, SAMPLE_HA_PATH / "configuration.yaml") - - -class AutomationLoader_tests(TestCase): +class parser_tests(TestCase): def test_various_condition_types(self): raw_conditions = [ {"condition": "template", "value_template": "silly logic here"}, @@ -248,170 +221,115 @@ class AutomationLoader_tests(TestCase): for expected, parsed in zip(expected_process, _parse_actions(raw_conditions)): self.assertEqual(parsed, expected) - def test_load_automation_runs(self): - auto = list( - load_automation( - [ - { - "id": "1616887975473", - "alias": "Home Assistant Off", - "description": "", - "trigger": [{"platform": "homeassistant", "event": "shutdown"}], - "condition": ["states(time.time) >= '10:00:00'"], - "action": [ - { - "device_id": SecretValue("my_mobile_phone", "..."), - "domain": "mobile_app", - "type": "notify", - "title": "Hassio Status", - "message": "Hassio Is turning off...", - } - ], - "mode": "single", - } - ] - ) - ) - self.assertEqual( - auto[0], - AutomationData( - metadata=AutomationMetdata( - id="1616887975473", - alias="Home Assistant Off", - description="", - mode="single", - ), - trigger=[{"platform": "homeassistant", "event": "shutdown"}], - condition=[ - AutomationConditionNode( - condition="template", - condition_data={"value_template": "states(time.time) >= '10:00:00'"}, - ) - ], - action=[ - AutomationActionNode( - action="device", - action_data={ - "device_id": NOT_IMPLEMENTED_SV_MSG, - "domain": "mobile_app", - "type": "notify", - "title": "Hassio Status", - "message": "Hassio Is turning off...", - }, - ) - ], - ), - ) + # def test_finding_with_AutomationLoader(self): + # automation_loader = AutomationLoader(load_hass_config(SAMPLE_HA_PATH)) - def test_finding_with_AutomationLoader(self): - automation_loader = AutomationLoader(load_hass_config(SAMPLE_HA_PATH)) + # first_auto_with_find = list(automation_loader.find(limit=1)) + # first_auto_with_get = automation_loader.get(0) + # self.assertEqual(first_auto_with_find[0], first_auto_with_get) - first_auto_with_find = list(automation_loader.find(limit=1)) - first_auto_with_get = automation_loader.get(0) - self.assertEqual(first_auto_with_find[0], first_auto_with_get) + # kitchen_autos = list(automation_loader.find(alias="kitchen")) + # self.assertTrue(len(kitchen_autos), 3) - kitchen_autos = list(automation_loader.find(alias="kitchen")) - self.assertTrue(len(kitchen_autos), 3) + # self.assertIsNone(automation_loader.get(-1)) + # self.assertIsNone(automation_loader.get(1_000)) + # self.assertIsNone(automation_loader.get(31)) + # self.assertEqual(len(automation_loader), 31) - self.assertIsNone(automation_loader.get(-1)) - self.assertIsNone(automation_loader.get(1_000)) - self.assertIsNone(automation_loader.get(35)) - self.assertEqual(len(automation_loader), 34) + # def test_invalid_automations(self): + # with self.assertRaises(AutomationLoaderException): + # AutomationLoader( + # HassConfig( + # secrets={}, + # config={ + # "automation": "bob", + # }, + # root_config_path=Path("."), + # ) + # ) - def test_invalid_automations(self): - with self.assertRaises(AutomationLoaderException): - AutomationLoader( - HassConfig( - secrets={}, - config={ - "automation": "bob", - }, - root_config_path=Path("."), - ) - ) + # with self.assertRaises(AutomationLoaderException): + # AutomationLoader( + # HassConfig( + # secrets={}, + # config={}, + # root_config_path=Path("."), + # ) + # ) - with self.assertRaises(AutomationLoaderException): - AutomationLoader( - HassConfig( - secrets={}, - config={}, - root_config_path=Path("."), - ) - ) + # def test_overwriting_one_auto_in_separate_file(self): + # # create dummy data + # config_path = create_dummy_config_folder( + # auto=[ + # AutomationData( + # metadata=AutomationMetdata( + # id="01", + # ) + # ), + # AutomationData( + # metadata=AutomationMetdata( + # id="02", + # ) + # ), + # AutomationData( + # metadata=AutomationMetdata( + # id="03", + # ) + # ), + # ] + # ) + # # check the data is loaded well + # automation_loader = AutomationLoader(load_hass_config(config_path)) + # self.assertEqual(automation_loader.get(0).metadata.id, "01") + # self.assertEqual(automation_loader.get(1).metadata.id, "02") + # self.assertEqual(automation_loader.get(2).metadata.id, "03") + # self.assertIsNone(automation_loader.get(3)) + # self.assertEqual(len(automation_loader), 3) + # # update auto #1 + # automation_loader.save( + # 1, + # AutomationData( + # metadata=AutomationMetdata(id="02", alias="flush toilet!"), + # trigger=[{"event": "toilet.flushed"}], + # ), + # ) + # # check that in-memory data is correctly updated + # self.assertEqual(automation_loader.get(1).metadata.id, "02") + # self.assertEqual(automation_loader.get(1).metadata.alias, "flush toilet!") + # self.assertListEqual(automation_loader.get(1).trigger, [{"event": "toilet.flushed"}]) - def test_overwriting_one_auto_in_separate_file(self): - # create dummy data - config_path = create_dummy_config_folder( - auto=[ - AutomationData( - metadata=AutomationMetdata( - id="01", - ) - ), - AutomationData( - metadata=AutomationMetdata( - id="02", - ) - ), - AutomationData( - metadata=AutomationMetdata( - id="03", - ) - ), - ] - ) - # check the data is loaded well - automation_loader = AutomationLoader(load_hass_config(config_path)) - self.assertEqual(automation_loader.get(0).metadata.id, "01") - self.assertEqual(automation_loader.get(1).metadata.id, "02") - self.assertEqual(automation_loader.get(2).metadata.id, "03") - self.assertIsNone(automation_loader.get(3)) - self.assertEqual(len(automation_loader), 3) - # update auto #1 - automation_loader.save( - 1, - AutomationData( - metadata=AutomationMetdata(id="02", alias="flush toilet!"), - trigger=[{"event": "toilet.flushed"}], - ), - ) - # check that in-memory data is correctly updated - self.assertEqual(automation_loader.get(1).metadata.id, "02") - self.assertEqual(automation_loader.get(1).metadata.alias, "flush toilet!") - self.assertListEqual(automation_loader.get(1).trigger, [{"event": "toilet.flushed"}]) - - # check that disk data is correctly updated - reloaded_automation_loader = AutomationLoader(load_hass_config(config_path)) - self.assertEqual(len(automation_loader), 3) - self.assertEqual(reloaded_automation_loader.get(1).metadata.id, "02") - self.assertEqual(reloaded_automation_loader.get(1).metadata.alias, "flush toilet!") - self.assertListEqual( - reloaded_automation_loader.get(1).trigger, [{"event": "toilet.flushed"}] - ) - # add new auto - automation_loader.save( - 3, - AutomationData( - metadata=AutomationMetdata(id="newest", alias="testing autos"), - condition=[ - AutomationConditionNode(condition="time", condition_data={"at": "10:00:00"}) - ], - ), - ) - # check that in-memory data is correctly updated - self.assertEqual(len(automation_loader), 4) - self.assertEqual(automation_loader.get(3).metadata.id, "newest") - self.assertEqual(automation_loader.get(3).metadata.alias, "testing autos") - self.assertListEqual( - automation_loader.get(3).condition, - [AutomationConditionNode(condition="time", condition_data={"at": "10:00:00"})], - ) - # check that disk data is correctly updated - reloaded_automation_loader = AutomationLoader(load_hass_config(config_path)) - self.assertEqual(len(reloaded_automation_loader), 4) - self.assertEqual(reloaded_automation_loader.get(3).metadata.id, "newest") - self.assertEqual(reloaded_automation_loader.get(3).metadata.alias, "testing autos") - self.assertListEqual( - reloaded_automation_loader.get(3).condition, - [AutomationConditionNode(condition="time", condition_data={"at": "10:00:00"})], - ) + # # check that disk data is correctly updated + # reloaded_automation_loader = AutomationLoader(load_hass_config(config_path)) + # self.assertEqual(len(automation_loader), 3) + # self.assertEqual(reloaded_automation_loader.get(1).metadata.id, "02") + # self.assertEqual(reloaded_automation_loader.get(1).metadata.alias, "flush toilet!") + # self.assertListEqual( + # reloaded_automation_loader.get(1).trigger, [{"event": "toilet.flushed"}] + # ) + # # add new auto + # automation_loader.save( + # 3, + # AutomationData( + # metadata=AutomationMetdata(id="newest", alias="testing autos"), + # sequence=[ + # AutomationConditionNode(condition="time", condition_data={"at": "10:00:00"}) + # ], + # ), + # ) + # # check that in-memory data is correctly updated + # self.assertEqual(len(automation_loader), 4) + # self.assertEqual(automation_loader.get(3).metadata.id, "newest") + # self.assertEqual(automation_loader.get(3).metadata.alias, "testing autos") + # self.assertListEqual( + # automation_loader.get(3).sequence, + # [AutomationConditionNode(condition="time", condition_data={"at": "10:00:00"})], + # ) + # # check that disk data is correctly updated + # reloaded_automation_loader = AutomationLoader(load_hass_config(config_path)) + # self.assertEqual(len(reloaded_automation_loader), 4) + # self.assertEqual(reloaded_automation_loader.get(3).metadata.id, "newest") + # self.assertEqual(reloaded_automation_loader.get(3).metadata.alias, "testing autos") + # self.assertListEqual( + # reloaded_automation_loader.get(3).sequence, + # [AutomationConditionNode(condition="time", condition_data={"at": "10:00:00"})], + # ) diff --git a/api/tests/unittests/hass_config/__init__.py b/api/tests/unittests/hass_config/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/api/tests/unittests/hass_config/test_loader.py b/api/tests/unittests/hass_config/test_loader.py new file mode 100644 index 0000000..7304255 --- /dev/null +++ b/api/tests/unittests/hass_config/test_loader.py @@ -0,0 +1,38 @@ +from unittest import TestCase +from src.automations.types import AutomationData, AutomationMetdata +from src.hass_config.loader import HassConfig +from tests.utils import HA_CONFIG_EXAMPLE, create_dummy_config_folder + +example_hass_config = HassConfig(HA_CONFIG_EXAMPLE) + + +class loader_tests(TestCase): + def test_load_automation_from_config_yaml(self): + folder = create_dummy_config_folder( + [AutomationData(metadata=AutomationMetdata(id="test"))], + automation_in_conifguration_mode="inline", + ) + hass_config = HassConfig(folder) + self.assertIsInstance(hass_config.configurations, dict) + self.assertTrue("automation" in hass_config.configurations) + self.assertEqual(hass_config.automations[0]["id"], "test") + + def test_load_automation_from_config_yaml_inclue(self): + folder = create_dummy_config_folder( + [AutomationData(metadata=AutomationMetdata(id="test"))], + automation_in_conifguration_mode="include", + ) + hass_config = HassConfig(folder) + self.assertIsInstance(hass_config.configurations, dict) + self.assertTrue("automation" in hass_config.configurations) + self.assertEqual(hass_config.automations[0]["id"], "test") + + def test_load_automation_from_infer(self): + folder = create_dummy_config_folder( + [AutomationData(metadata=AutomationMetdata(id="test"))], + automation_in_conifguration_mode="none", + ) + hass_config = HassConfig(folder) + self.assertIsInstance(hass_config.configurations, dict) + self.assertFalse("automation" in hass_config.configurations) + self.assertEqual(hass_config.automations[0]["id"], "test") diff --git a/api/tests/unittests/test_db.py b/api/tests/unittests/test_db.py deleted file mode 100644 index 4e56cd0..0000000 --- a/api/tests/unittests/test_db.py +++ /dev/null @@ -1,80 +0,0 @@ -from unittest import TestCase -from src.db.connection import HassDatabase -from src.db import entities -from tests.utils import SAMPLE_DB_PATH - -db = HassDatabase(f"sqlite:///{SAMPLE_DB_PATH.absolute()}") - - -class hass_db_tests(TestCase): - def test_it_loads_local_db(self): - self.assertEqual(db.execute_sql("SELECT count(*) FROM states")[0][0], 333_878) - self.assertEqual(db.db_type, "sqlite") - - def test_search_entity_find_by_text(self): - expected = [ - "sensor.temperature_entrance_closet", - "sensor.temperature_office", - "sensor.temperature_kitchen", - "sensor.temperature_mbathroom", - "sensor.temperature_baby_room", - "sensor.temperature_storage_unit", - "sensor.temperature_powder_room", - "sensor.temperature_laundry", - "sensor.temperature_living_room", - "sensor.temperature_ewelink", - "sensor.temperature_main_bedroom", - ] - for entity in entities.search( - db, - search_text="sensor.temperature", - ): - self.assertTrue(expected.count(entity.entity_id) > 0) - self.assertEqual(entity.domain, "sensor") - self.assertEqual(entity.attributes["state_class"], "measurement") - - def test_search_entity_find_by_text_and_domain(self): - expected = [ - "automation.kitchen_island_buttom_press", - "automation.kitchen_button_long_press", - ] - for entity in entities.search( - db, search_text="kitchen", domain_filter="automation" - ): - self.assertTrue(expected.count(entity.entity_id) > 0) - self.assertEqual(entity.domain, "automation") - self.assertEqual(entity.attributes["mode"], "single") - - def test_search_entity_find_by_text_and_attr(self): - expected = [ - "sensor.humidity_kitchen", - "sensor.pressure_kitchen", - "sensor.temperature_kitchen", - "sensor.battery_kitchen_btn", - "sensor.battery_weather_kitchen", - "sensor.battery_wleak_kitchen", - ] - for entity in entities.search( - db, search_text="kitchen", attributes_filter={"state_class": "measurement"} - ): - self.assertTrue(expected.count(entity.entity_id) > 0) - self.assertEqual(entity.domain, "sensor") - self.assertEqual(entity.attributes["state_class"], "measurement") - - def test_search_entity_find_by_text_and_partial_attr(self): - expected = [ - "sensor.humidity_kitchen", - "sensor.pressure_kitchen", - "sensor.temperature_kitchen", - "sensor.battery_kitchen_btn", - "sensor.battery_weather_kitchen", - "sensor.battery_wleak_kitchen", - ] - for entity in entities.search( - db, - search_text="kitchen", - attributes_filter={"state_class": "sureme"}, - ): - self.assertTrue(expected.count(entity.entity_id) > 0) - self.assertEqual(entity.domain, "sensor") - self.assertEqual(entity.attributes["state_class"], "measurement") diff --git a/api/tests/unittests/test_json_s.py b/api/tests/unittests/test_json_serializer.py similarity index 94% rename from api/tests/unittests/test_json_s.py rename to api/tests/unittests/test_json_serializer.py index 774e093..2faa5eb 100644 --- a/api/tests/unittests/test_json_s.py +++ b/api/tests/unittests/test_json_serializer.py @@ -1,6 +1,6 @@ import json from unittest import TestCase -from src.yaml_serializer import SecretValue +from src.yaml_serializer.types import SecretValue from src.json_serializer import json_dumps, NOT_IMPLEMENTED_SV_MSG diff --git a/api/tests/unittests/test_yaml.py b/api/tests/unittests/test_yaml_serializer.py similarity index 76% rename from api/tests/unittests/test_yaml.py rename to api/tests/unittests/test_yaml_serializer.py index 9140e63..fa8b0a9 100644 --- a/api/tests/unittests/test_yaml.py +++ b/api/tests/unittests/test_yaml_serializer.py @@ -3,10 +3,12 @@ from pathlib import Path from unittest import TestCase from src.yaml_serializer import ( dump_yaml, + load_yaml, +) +from src.yaml_serializer.types import ( IncludedYaml, SecretValue, IncludedYamlDir, - simple_load_yaml, ) @@ -15,15 +17,11 @@ class dumping_yamls_tests(TestCase): yaml = dump_yaml( { "automations": IncludedYaml( - "automations.yaml", - Path("/config/automations.yaml"), - [ - {"id": "wow", "alias": "NO!"}, - ], + Path("automations.yaml"), ) } ) - self.assertEqual(yaml, "automations: !include automations.yaml\n") + self.assertEqual(yaml, f"automations: !include {Path('automations.yaml').absolute()}\n") def test_dumping_secrets(self): yaml = dump_yaml({"google_password": SecretValue("gpass", "supersec")}) @@ -34,7 +32,7 @@ class dumping_yamls_tests(TestCase): self.assertEqual(yaml, "sensor: !include_dir_list sensors/*yaml\n") def test_load_stub(self): - yaml_obj = simple_load_yaml( + yaml_obj = load_yaml( io.StringIO( """ name: cool @@ -50,7 +48,7 @@ class dumping_yamls_tests(TestCase): "name": "cool", "google_password": SecretValue("gpass", "n/a"), "sensor": IncludedYamlDir("include_dir_list", "sensors/*yaml"), - "automations": IncludedYaml("automations.yaml", Path("/"), "n/a"), + "automations": IncludedYaml(Path("automations.yaml").absolute()), }, ) self.assertEqual( @@ -58,5 +56,5 @@ class dumping_yamls_tests(TestCase): "name: cool\n" "google_password: !secret gpass\n" "sensor: !include_dir_list sensors/*yaml\n" - "automations: !include automations.yaml\n", + f"automations: !include {Path('automations.yaml').absolute()}\n", ) diff --git a/api/tests/utils.py b/api/tests/utils.py index be71eb1..0caf959 100644 --- a/api/tests/utils.py +++ b/api/tests/utils.py @@ -1,21 +1,21 @@ from tempfile import mkdtemp from pathlib import Path -from typing import List, Optional -from src.config.AutomationLoader import AutomationData +from typing import List, Literal, Optional +from src.automations.types import AutomationData from src.yaml_serializer import dump_yaml from src.yaml_serializer.types import IncludedYaml THIS_FOLDER = Path(__file__).parent -SAMPLE_HA_PATH = THIS_FOLDER / "samples" -SAMPLE_DB_PATH = SAMPLE_HA_PATH / "home-assistant_v2.db" +SAMPLES_FOLDER = THIS_FOLDER / "samples" +HA_CONFIG_EXAMPLE = SAMPLES_FOLDER / "example_config_folder" def create_dummy_config_folder( auto: List[AutomationData], secrets: Optional[dict] = None, other_config: Optional[dict] = None, - include_auto_in_configuration: bool = False, + automation_in_conifguration_mode: Literal["include", "inline", "none"] = "include", ) -> Path: """Creates a dummy /config structure for testing @@ -23,7 +23,7 @@ def create_dummy_config_folder( auto (List[AutomationData]): automations secrets (Optional[dict], optional): dictionary of secrets other_config (Optional[dict], optional): some config stuff to place into configuration.yaml. Defaults to None. - include_auto_in_configuration (bool, optional): whether to !include automation as a separete file or in the configuration yaml. Defaults to False. + automation_in_conifguration_mode (Literal['include', 'inline', 'none'], optional): whether to !include automation as a separete file or in the configuration yaml. Defaults to inline. Returns: Path: [description] @@ -31,12 +31,13 @@ def create_dummy_config_folder( root_folder = Path(mkdtemp()) auto_prims = [a.to_primitive() for a in auto] configuration_yaml = {**other_config} if other_config is not None else {} - if include_auto_in_configuration: + if automation_in_conifguration_mode == "inline": configuration_yaml["automation"] = auto_prims - else: + elif automation_in_conifguration_mode == "include": configuration_yaml["automation"] = IncludedYaml( - "automations.yaml", root_folder / "automations.yaml", auto + Path(root_folder / "automations.yaml"), ) + if automation_in_conifguration_mode != "inline": (root_folder / "automations.yaml").write_text(dump_yaml(auto_prims)) if secrets is not None: (root_folder / "secrets.yaml").write_text(dump_yaml(secrets))