backend modified
This commit is contained in:
1 parent
d96c1fb953
commit
55ea1e23a4
26 files changed
+737
-1145
No files matched your search
@@ -0,0 +1,122 @@
|
||||
import base64
|
||||
import json
|
||||
import sqlite3
|
||||
from contextlib import contextmanager
|
||||
from pathlib import Path
|
||||
from typing import Iterable, Iterator, List, Optional
|
||||
|
||||
from src.logger import get_logger
|
||||
|
||||
from .errors import DBDataError, DBError, DBNoAutomationFound
|
||||
from .types import ExtenededAutomation
|
||||
|
||||
logger = get_logger(__file__)
|
||||
|
||||
automations_tbl = "autos"
|
||||
|
||||
|
||||
def encode_auto(auto: ExtenededAutomation) -> str:
|
||||
return base64.b64encode(
|
||||
json.dumps(auto.to_primitive(include_tags=True)).encode("utf-8")
|
||||
).decode("utf-8")
|
||||
|
||||
|
||||
def decode_auto(
|
||||
auto_str: str, source_file: str, source_file_type: str, configuration_key: str
|
||||
) -> ExtenededAutomation:
|
||||
return ExtenededAutomation(
|
||||
source_file=source_file,
|
||||
source_file_type=source_file_type,
|
||||
configuration_key=configuration_key,
|
||||
**json.loads(base64.b64decode(auto_str.encode("utf-8")).decode("utf-8")),
|
||||
)
|
||||
|
||||
|
||||
class AutomationDBConnection:
|
||||
def __init__(self, db_file: Path) -> None:
|
||||
self.db_file = db_file
|
||||
|
||||
def reset(self):
|
||||
self.db_file.unlink(missing_ok=True)
|
||||
self.create_db()
|
||||
|
||||
@contextmanager
|
||||
def get_cur(self) -> Iterator[sqlite3.Cursor]:
|
||||
conn = sqlite3.connect(self.db_file)
|
||||
cur = conn.cursor()
|
||||
try:
|
||||
yield cur
|
||||
conn.commit()
|
||||
except sqlite3.IntegrityError as err:
|
||||
raise DBDataError(*err.args) from err
|
||||
except sqlite3.DatabaseError as err:
|
||||
raise DBError(*err.args) from err
|
||||
finally:
|
||||
cur.close()
|
||||
conn.close()
|
||||
|
||||
def create_db(self):
|
||||
with self.get_cur() as cur:
|
||||
cur.execute(
|
||||
f"""
|
||||
CREATE TABLE IF NOT EXISTS {automations_tbl} (
|
||||
id TEXT NOT NULL PRIMARY KEY,
|
||||
alias TEXT,
|
||||
description TEXT,
|
||||
mode TEXT NOT NULL,
|
||||
source_file TEXT NOT NULL,
|
||||
source_file_type TEXT NOT NULL,
|
||||
configuration_key TEXT NOT NULL,
|
||||
rest BLOB NOT NULL
|
||||
);
|
||||
"""
|
||||
)
|
||||
|
||||
def upsert_automations(self, automations: List[ExtenededAutomation]):
|
||||
with self.get_cur() as cur:
|
||||
for automation in automations:
|
||||
cur.execute(
|
||||
f"""
|
||||
INSERT INTO {automations_tbl} VALUES (
|
||||
"{automation.id}",
|
||||
"{automation.alias}",
|
||||
"{automation.description}",
|
||||
"{automation.mode}",
|
||||
"{automation.source_file.absolute()}",
|
||||
"{automation.source_file_type}",
|
||||
"{automation.configuration_key}",
|
||||
"{encode_auto(automation)}"
|
||||
)
|
||||
ON CONFLICT DO UPDATE SET
|
||||
alias = "{automation.alias}",
|
||||
description = "{automation.description}",
|
||||
mode = "{automation.mode}",
|
||||
source_file = "{automation.source_file.absolute()}",
|
||||
source_file_type = "{automation.source_file_type}",
|
||||
configuration_key = "{automation.configuration_key}",
|
||||
rest = "{encode_auto(automation)}"
|
||||
|
||||
""",
|
||||
)
|
||||
|
||||
def get_automation(self, automation_id: str) -> ExtenededAutomation:
|
||||
with self.get_cur() as cur:
|
||||
cur.execute(
|
||||
f'SELECT rest, source_file, source_file_type, configuration_key FROM {automations_tbl} WHERE id = "{automation_id}"'
|
||||
)
|
||||
objs = cur.fetchone()
|
||||
if objs is None:
|
||||
raise DBNoAutomationFound(automation_id)
|
||||
[rest, source_file, source_file_type, configuration_key] = objs
|
||||
return decode_auto(rest, source_file, source_file_type, configuration_key)
|
||||
|
||||
def list_automations(self, offset: int, limit: int) -> Iterable[ExtenededAutomation]:
|
||||
with self.get_cur() as cur:
|
||||
for [rest, source_file, source_file_type, configuration_key] in cur.execute(
|
||||
f"SELECT rest, source_file, source_file_type, configuration_key FROM {automations_tbl} LIMIT {limit} OFFSET {offset}"
|
||||
):
|
||||
yield decode_auto(rest, source_file, source_file_type, configuration_key)
|
||||
|
||||
def count_automations(self) -> int:
|
||||
with self.get_cur() as cur:
|
||||
return cur.execute(f"SELECT count(id) FROM {automations_tbl}").fetchone()[0]
|
||||
@@ -5,9 +5,25 @@ class AutomationLoaderException(Exception):
|
||||
)
|
||||
|
||||
|
||||
class AttemptingToOverwriteAnIncompatibleFileError(AutomationLoaderException):
|
||||
pass
|
||||
|
||||
|
||||
class InvalidAutomationFile(AutomationLoaderException):
|
||||
pass
|
||||
|
||||
|
||||
class FailedDeletion(AutomationLoaderException):
|
||||
pass
|
||||
|
||||
|
||||
class DBError(Exception):
|
||||
pass
|
||||
|
||||
|
||||
class DBDataError(DBError):
|
||||
pass
|
||||
|
||||
|
||||
class DBNoAutomationFound(DBError):
|
||||
pass
|
||||
+103
-23
@@ -1,38 +1,118 @@
|
||||
from typing import Any, Iterator, Union
|
||||
|
||||
from pydantic.error_wrappers import ValidationError
|
||||
from pathlib import Path
|
||||
from typing import Any, Iterator, Tuple, Union
|
||||
|
||||
from src.json_serializer import normalize_obj
|
||||
from src.logger import get_logger
|
||||
from src.utils import extract_files
|
||||
from src.yaml_serializer import load_yaml
|
||||
from src.yaml_serializer.types import IncludedYaml, IncludedYamlDir
|
||||
|
||||
from ..hass_config.loader import HassConfig
|
||||
from .errors import InvalidAutomationFile
|
||||
from .types import AutomationMetdata, ExtenededAutomationData
|
||||
from .tags import TagManager
|
||||
from .types import ExtenededAutomation
|
||||
|
||||
logger = get_logger(__file__)
|
||||
|
||||
|
||||
# Single loader
|
||||
def load_automation(
|
||||
auto_raw: dict,
|
||||
tags: dict,
|
||||
) -> Iterator[ExtenededAutomationData]:
|
||||
"""Converts an automation dictionary loaded directly from the config into
|
||||
several python typed objects
|
||||
def extract_automation_paths(
|
||||
hass_config: HassConfig,
|
||||
) -> Iterator[Tuple[str, Path]]:
|
||||
found = False
|
||||
for key, value in hass_config.configurations.items():
|
||||
if str(key).startswith("automation"):
|
||||
logger.info(f"Loading automations from '{key}'")
|
||||
found = True
|
||||
if isinstance(value, dict):
|
||||
raise NotImplementedError(
|
||||
"No support for automations baked into configuration.yaml! Please extract these into a seperate file"
|
||||
)
|
||||
elif isinstance(value, IncludedYaml):
|
||||
yield key, hass_config.root_path / value.path_str
|
||||
elif isinstance(value, IncludedYamlDir):
|
||||
yield key, hass_config.root_path / value.name
|
||||
else:
|
||||
logger.warning(f"found an invalid type in {key}!")
|
||||
if not found:
|
||||
yield "", hass_config.root_path / "automations.yaml"
|
||||
|
||||
|
||||
def load_automation_path(
|
||||
automation_path: Path,
|
||||
configuration_key: str,
|
||||
tag_manager: TagManager,
|
||||
) -> Iterator[ExtenededAutomation]:
|
||||
"""
|
||||
|
||||
Args:
|
||||
automations_raw_data (Iterable[dict])
|
||||
automation_path (Path)
|
||||
configuration_key (str)
|
||||
|
||||
Returns:
|
||||
Iterator[ExtenededAutomationData]
|
||||
Iterator[ExtenededAutomation]
|
||||
|
||||
"""
|
||||
try:
|
||||
yield ExtenededAutomationData(
|
||||
metadata=AutomationMetdata.parse_obj(auto_raw),
|
||||
condition=ifempty_or_null_then_list(load_conditions(auto_raw.get("condition", []))),
|
||||
sequence=ifempty_or_null_then_list(load_conditions(auto_raw.get("action", []))),
|
||||
trigger=ifempty_or_null_then_list(normalize_obj(auto_raw.get("trigger", []))),
|
||||
tags=tags,
|
||||
)
|
||||
except ValidationError as err:
|
||||
raise InvalidAutomationFile from err
|
||||
if not automation_path.exists():
|
||||
logger.warning(f"the file {automation_path} does not exists")
|
||||
return
|
||||
if automation_path.is_dir():
|
||||
for f in extract_files(automation_path):
|
||||
yield from load_automation_path(f, configuration_key, tag_manager)
|
||||
else:
|
||||
try:
|
||||
with automation_path.open("r") as fp:
|
||||
automations = load_yaml(fp)
|
||||
except Exception as err:
|
||||
raise InvalidAutomationFile(
|
||||
when="loading yaml",
|
||||
automation_path=automation_path,
|
||||
error=err,
|
||||
) from err
|
||||
|
||||
if isinstance(automations, dict):
|
||||
try:
|
||||
yield ExtenededAutomation(
|
||||
**clean_automation(automations),
|
||||
tags=tag_manager.get(automations["id"], {}),
|
||||
configuration_key=configuration_key,
|
||||
source_file=str(automation_path),
|
||||
source_file_type="obj",
|
||||
)
|
||||
except Exception as err:
|
||||
raise InvalidAutomationFile(
|
||||
when="reading file contents",
|
||||
automation_path=automation_path,
|
||||
error=err,
|
||||
) from err
|
||||
else:
|
||||
if automations is None:
|
||||
logger.warning(f"the file {automation_path} is empty")
|
||||
return
|
||||
for automation in automations:
|
||||
try:
|
||||
yield ExtenededAutomation(
|
||||
**clean_automation(automation),
|
||||
tags=tag_manager.get(automation["id"], {}),
|
||||
configuration_key=configuration_key,
|
||||
source_file=str(automation_path),
|
||||
source_file_type="list",
|
||||
)
|
||||
except Exception as err:
|
||||
raise InvalidAutomationFile(
|
||||
when="reading file contents",
|
||||
automation_path=automation_path,
|
||||
error=err,
|
||||
automation=automation,
|
||||
) from err
|
||||
|
||||
|
||||
def clean_automation(auto_raw: dict):
|
||||
return {
|
||||
**auto_raw,
|
||||
"condition": ifempty_or_null_then_list(load_conditions(auto_raw.get("condition", []))),
|
||||
"action": ifempty_or_null_then_list(load_conditions(auto_raw.get("action", []))),
|
||||
"trigger": ifempty_or_null_then_list(normalize_obj(auto_raw.get("trigger", []))),
|
||||
}
|
||||
|
||||
|
||||
def ifempty_or_null_then_list(obj: Any):
|
||||
|
||||
+120
-64
@@ -1,76 +1,132 @@
|
||||
from typing import Dict, Iterator, List, Optional
|
||||
from enum import auto
|
||||
from pathlib import Path
|
||||
from tempfile import mktemp
|
||||
from typing import Dict, Optional, Union
|
||||
|
||||
from src.automations.errors import FailedDeletion, InvalidAutomationFile
|
||||
from src.automations.types import AutomationData, ExtenededAutomationData
|
||||
from src.hass_config.loader import HassConfig
|
||||
from src.yaml_serializer import dump_yaml, load_yaml
|
||||
|
||||
from .loader import load_automation
|
||||
from ..errors import ErrorSet
|
||||
from ..logger import get_logger
|
||||
from .db import AutomationDBConnection
|
||||
from .errors import (
|
||||
AttemptingToOverwriteAnIncompatibleFileError,
|
||||
DBError,
|
||||
InvalidAutomationFile,
|
||||
)
|
||||
from .loader import extract_automation_paths, load_automation_path
|
||||
from .tags import TagManager
|
||||
from .types import ExtenededAutomation
|
||||
|
||||
logger = get_logger(__file__)
|
||||
|
||||
|
||||
class AutomationManager:
|
||||
def __init__(self, hass_config: HassConfig) -> None:
|
||||
self.hass_config = hass_config
|
||||
|
||||
def find(
|
||||
def __init__(
|
||||
self,
|
||||
offset: int = 0,
|
||||
limit: int = 10,
|
||||
) -> Iterator[AutomationData]:
|
||||
tags = self.hass_config.automation_tags
|
||||
for i, auto in enumerate(self.hass_config.automations):
|
||||
if i < offset:
|
||||
continue
|
||||
if i >= offset + limit:
|
||||
break
|
||||
yield from load_automation(auto, tags.get(auto.get("id", ""), {}))
|
||||
hass_config: HassConfig,
|
||||
db_path: Optional[Path] = None,
|
||||
) -> None:
|
||||
if db_path is None:
|
||||
db_path = Path(mktemp())
|
||||
self.hass_config = hass_config
|
||||
self.db = AutomationDBConnection(db_path)
|
||||
self.tag_path = hass_config.get_automation_tags_path()
|
||||
self.tag_manager = TagManager()
|
||||
self.reload_tags()
|
||||
|
||||
def get(self, index: int) -> Optional[ExtenededAutomationData]:
|
||||
tags = self.hass_config.automation_tags
|
||||
if index >= 0:
|
||||
for i, auto in enumerate(self.hass_config.automations):
|
||||
if not isinstance(auto, dict):
|
||||
raise InvalidAutomationFile(automation_index=i)
|
||||
if i == index:
|
||||
return next(load_automation(auto, tags.get(auto.get("id", ""), {})))
|
||||
return None
|
||||
def reload_tags(self):
|
||||
if self.tag_path.exists():
|
||||
self.tag_manager = TagManager.load(self.tag_path)
|
||||
|
||||
def update(self, index: int, automation: ExtenededAutomationData):
|
||||
tags = self.hass_config.automation_tags
|
||||
automations: List[dict] = []
|
||||
updated_index: Optional[int] = None
|
||||
for i, orig_auto in enumerate(self.hass_config.automations):
|
||||
if i == index:
|
||||
automations.append(automation.to_primitive())
|
||||
updated_index = i
|
||||
else:
|
||||
automations.append(orig_auto)
|
||||
if updated_index is None:
|
||||
automations.append(automation.to_primitive())
|
||||
updated_index = len(automations) - 1
|
||||
tags[automation.metadata.id] = automation.tags
|
||||
self.hass_config.save_automations(automations)
|
||||
self.hass_config.save_tags(tags)
|
||||
def reload(self):
|
||||
self.db.reset()
|
||||
self.reload_tags()
|
||||
errors = []
|
||||
for config_key, p in extract_automation_paths(self.hass_config):
|
||||
try:
|
||||
automations = list(load_automation_path(p, config_key, self.tag_manager))
|
||||
self.db.upsert_automations(automations)
|
||||
except InvalidAutomationFile as e:
|
||||
logger.warning(e)
|
||||
errors.append(e)
|
||||
except DBError as e:
|
||||
logger.warning(e)
|
||||
errors.append(e)
|
||||
if len(errors) > 0:
|
||||
raise ErrorSet(*errors)
|
||||
|
||||
def update_tags(self, auto_id: str, tags: Dict[str, str]):
|
||||
autos_tags = self.hass_config.automation_tags
|
||||
autos_tags[auto_id] = tags
|
||||
self.hass_config.save_tags(autos_tags)
|
||||
def list(self, offset: int, limit: int):
|
||||
return self.db.list_automations(offset=offset, limit=limit)
|
||||
|
||||
def delete(self, index: int):
|
||||
automations: List[dict] = []
|
||||
deleted = False
|
||||
for i, orig_auto in enumerate(self.hass_config.automations):
|
||||
if i == index:
|
||||
deleted = True
|
||||
else:
|
||||
automations.append(orig_auto)
|
||||
if not deleted:
|
||||
raise FailedDeletion("No such automation found")
|
||||
self.hass_config.save_automations(automations)
|
||||
def count(self):
|
||||
return self.db.count_automations()
|
||||
|
||||
# TODO: improve on this without keeping things in memory
|
||||
def get_total_items(self) -> int:
|
||||
count = 0
|
||||
for i, _ in enumerate(self.hass_config.automations):
|
||||
count = i
|
||||
return count + 1
|
||||
def get(self, auto_id: str):
|
||||
return self.db.get_automation(auto_id)
|
||||
|
||||
def upsert(self, automation: ExtenededAutomation):
|
||||
if not automation.source_file.parent.exists():
|
||||
automation.source_file.parent.mkdir(parents=True)
|
||||
|
||||
objs: Optional[Union[list, dict]] = None
|
||||
if automation.source_file.exists():
|
||||
with automation.source_file.open("r") as fp:
|
||||
objs = load_yaml(fp)
|
||||
|
||||
if automation.source_file_type == "obj":
|
||||
if isinstance(objs, list):
|
||||
raise AttemptingToOverwriteAnIncompatibleFileError(
|
||||
f"{automation.source_file} is a list, but expected a obj for {automation}"
|
||||
)
|
||||
raw_auto = automation.to_primitive(include_tags=False)
|
||||
automation.source_file.write_text(dump_yaml(raw_auto))
|
||||
else:
|
||||
if isinstance(objs, dict):
|
||||
raise AttemptingToOverwriteAnIncompatibleFileError(
|
||||
f"{automation.source_file} is a list, but expected a obj for {automation}"
|
||||
)
|
||||
elif objs is None:
|
||||
objs = []
|
||||
if not isinstance(objs, list):
|
||||
raise AssertionError(
|
||||
f"Attemption to save automation to {automation.source_file} but encountering an invalid list yaml file. Did you modify this file prior to saving?\n{automation}"
|
||||
)
|
||||
found = False
|
||||
for i, obj in enumerate(objs):
|
||||
if obj["id"] == automation.id:
|
||||
objs[i] = automation.to_primitive(include_tags=False)
|
||||
found = True
|
||||
break
|
||||
if not found:
|
||||
objs.append(automation.to_primitive(include_tags=False))
|
||||
automation.source_file.write_text(dump_yaml(objs))
|
||||
self.update_tags(automation.id, automation.tags)
|
||||
|
||||
def update_tags(self, automation_id: str, tags: Dict[str, str]):
|
||||
self.reload_tags()
|
||||
self.tag_manager[automation_id] = tags
|
||||
self.tag_manager.save(self.tag_path)
|
||||
|
||||
def delete_tags(self, automation_id: str):
|
||||
self.reload_tags()
|
||||
if automation_id in self.tag_manager:
|
||||
del self.tag_manager[automation_id]
|
||||
self.tag_manager.save(self.tag_path)
|
||||
|
||||
def delete(self, automation: ExtenededAutomation):
|
||||
if automation.source_file_type == "obj":
|
||||
automation.source_file.unlink(missing_ok=True)
|
||||
else:
|
||||
with automation.source_file.open("r") as fp:
|
||||
objs = load_yaml(fp)
|
||||
if not isinstance(objs, list):
|
||||
raise AssertionError(
|
||||
f"Attemption to save automation to {automation.source_file} but encountering an invalid list yaml file. Did you modify this file prior to saving?\n{automation}"
|
||||
)
|
||||
kept = []
|
||||
for i, obj in enumerate(objs):
|
||||
if obj["id"] != automation.id:
|
||||
kept.append(obj)
|
||||
automation.source_file.write_text(dump_yaml(kept))
|
||||
self.delete_tags(automation.id)
|
||||
@@ -6,6 +6,8 @@ from src.yaml_serializer import dump_yaml, load_yaml
|
||||
|
||||
class TagManager(Dict[str, Dict[str, str]]):
|
||||
def save(self, path: Path):
|
||||
if not path.parent.exists():
|
||||
path.parent.mkdir(parents=True)
|
||||
path.write_text(dump_yaml(dict(self)))
|
||||
|
||||
@classmethod
|
||||
|
||||
@@ -1,31 +1,39 @@
|
||||
from typing import Dict, List, Optional, Union
|
||||
import json
|
||||
from pathlib import Path
|
||||
from typing import Dict, List, Literal, Optional, Union
|
||||
|
||||
from pydantic import BaseModel
|
||||
from pydantic.fields import Field
|
||||
|
||||
|
||||
class AutomationMetdata(BaseModel):
|
||||
class BaseAutomation(BaseModel):
|
||||
id: str
|
||||
alias: Optional[str] = None
|
||||
description: Optional[str] = None
|
||||
trigger_variables: Optional[Dict[str, Union[str, int, bool, float]]] = None
|
||||
mode: str = "single"
|
||||
|
||||
|
||||
class AutomationData(BaseModel):
|
||||
metadata: AutomationMetdata
|
||||
trigger: List[dict] = []
|
||||
condition: List[dict] = []
|
||||
sequence: List[dict] = []
|
||||
action: List[dict] = []
|
||||
|
||||
def to_primitive(self):
|
||||
return {
|
||||
**self.metadata.dict(exclude_unset=True, exclude_none=True),
|
||||
"trigger": self.trigger,
|
||||
"condition": self.condition,
|
||||
"action": self.sequence,
|
||||
}
|
||||
return self.dict(exclude_unset=True, exclude_none=True)
|
||||
|
||||
|
||||
class ExtenededAutomationData(AutomationData):
|
||||
class ExtenededAutomation(BaseAutomation):
|
||||
source_file: Path
|
||||
source_file_type: Literal["list", "obj"]
|
||||
configuration_key: str
|
||||
tags: Dict[str, str] = Field(default_factory=dict)
|
||||
|
||||
def to_primitive(self, include_tags: bool = False):
|
||||
out = super().to_primitive()
|
||||
del out["source_file"]
|
||||
del out["source_file_type"]
|
||||
del out["configuration_key"]
|
||||
if not include_tags and out.get("tags", None) is not None:
|
||||
del out["tags"]
|
||||
return out
|
||||
|
||||
def to_json(self):
|
||||
return json.loads(self.json())
|
||||
Reference in new issue
Block a user