Merge commit '5f82d18ad71f90d27a208a744d11726cc209fd44' into pydantic-hass

Author: jsl12

appdaemon/app_management.py

@@ -141,7 +141,8 @@ def __init__(self, logging: "Logging", loop: BaseEventLoop, ad_config_model: App
 
         if self.apps is True:
             assert self.config_dir is not None, "Config_dir not set. This is a development problem"
-            assert self.config_dir.exists(), f"{self.config_dir} does not exist"
+            assert self.config_dir.exists(), f"{
+                self.config_dir} does not exist"
             assert os.access(
                 self.config_dir, os.R_OK | os.X_OK
             ), f"{self.config_dir} does not have the right permissions"
@@ -155,6 +156,8 @@ def __init__(self, logging: "Logging", loop: BaseEventLoop, ad_config_model: App
                     self.app_dir, os.R_OK | os.W_OK | os.X_OK
                 ), f"{self.app_dir} does not have the right permissions"
 
+            self.logger.info(f"Using {self.app_dir} as app_dir")
+
             self.app_management = AppManagement(self)
             self.threading = Threading(self)
 

appdaemon/appdaemon.py

@@ -73,7 +73,7 @@ def discriminate_app(v: Any):
 
 AppOrGlobal = Annotated[
     Union[
-        Annotated[AppConfig, Tag("app")], 
+        Annotated[AppConfig, Tag("app")],
         Annotated[GlobalModule, Tag("global")]
     ],
     Field(discriminator=Discriminator(discriminate_app))

appdaemon/models/config/app.py

@@ -1,12 +1,20 @@
 from datetime import timedelta
 from typing import Annotated, Any, Literal, Union
 
-from pydantic import BaseModel, BeforeValidator, Discriminator, Field, PlainSerializer, RootModel, Tag, WrapSerializer
+from pydantic import BaseModel, BeforeValidator, Discriminator, Field, PlainSerializer, RootModel, Tag, ValidationError, WrapSerializer
+
+
+def validate_timedelta(v: Any):
+    match v:
+        case int() | float():
+            return timedelta(seconds=v)
+        case _:
+            raise ValidationError(f'Invalid type for timedelta: {v}')
 
 
 TimeType = Annotated[
     timedelta,
-    BeforeValidator(lambda v: timedelta(seconds=v)),
+    BeforeValidator(validate_timedelta),
     PlainSerializer(lambda td: td.total_seconds())
 ]
 

appdaemon/models/config/sequence.py

@@ -28,7 +28,8 @@ def __init__(self, ad: "AppDaemon"):
 
     async def run_sequence_service(self, namespace, domain, service, kwargs):
         if "entity_id" not in kwargs:
-            self.logger.warning("entity_id not given in service call, so will not be executing %s", service)
+            self.logger.warning(
+                "entity_id not given in service call, so will not be executing %s", service)
             return
 
         entity_id = kwargs["entity_id"]
@@ -54,7 +55,7 @@ async def add_sequences(self, sequences):
             if sequence_namespace is not None:
                 attributes.update({"namespace": sequence_namespace})
 
-            if not self.AD.state.entity_exists("rules", entity):
+            if not await self.AD.state.entity_exists("rules", entity):
                 # it doesn't exist so add it
                 await self.AD.state.add_entity(
                     "rules",
@@ -82,7 +83,7 @@ async def remove_sequences(self, sequences):
             await self.cancel_sequence(sequence)
             await self.AD.state.remove_entity("rules", "sequence.{}".format(sequence))
 
-    async def run_sequence(self, _name: str, namespace: str, sequence: str | list[str]):
+    async def run_sequence(self, _name, namespace, sequence):
         if isinstance(sequence, str):
             if "." in sequence:
                 # the entity given
@@ -127,14 +128,15 @@ async def cancel_sequence(self, sequence):
         self.AD.futures.cancel_futures(name)
         await self.AD.state.set_state("_sequences", "rules", entity_id, state="idle")
 
-    async def prep_sequence(self, _name: str, namespace: str, sequence: str | list[str]):
+    async def prep_sequence(self, _name, namespace, sequence):
         ephemeral_entity = False
         loop = False
 
         if isinstance(sequence, str):
             entity_id = sequence
-            if self.AD.state.entity_exists("rules", entity_id) is False:
-                self.logger.warning('Unknown sequence "%s" in run_sequence()', sequence)
+            if await self.AD.state.entity_exists("rules", entity_id) is False:
+                self.logger.warning(
+                    'Unknown sequence "%s" in run_sequence()', sequence)
                 return None
 
             entity = await self.AD.state.get_state("_services", "rules", sequence, attribute="all")
@@ -146,32 +148,20 @@ async def prep_sequence(self, _name: str, namespace: str, sequence: str | list[s
             #
             # Assume it's a list with the actual commands in it
             #
-            assert isinstance(sequence, list) and all(isinstance(s, str) for s in sequence)
             entity_id = "sequence.{}".format(uuid.uuid4().hex)
             # Create an ephemeral entity for it
             ephemeral_entity = True
 
-            await self.AD.state.add_entity(
-                namespace="rules",
-                entity=entity_id,
-                state="idle",
-                attributes={"steps": sequence}
-            )
+            await self.AD.state.add_entity("rules", entity_id, "idle", attributes={"steps": sequence})
 
             seq = sequence
             ns = namespace
 
         coro = await self.do_steps(ns, entity_id, seq, ephemeral_entity, loop)
         return coro
 
-    async def do_steps(self,
-                       namespace: str,
-                       entity_id: str,
-                       seq: str | list[str],
-                       ephemeral_entity: bool = False,
-                       loop: bool = False):
+    async def do_steps(self, namespace, entity_id, seq, ephemeral_entity, loop):
         await self.AD.state.set_state("_sequences", "rules", entity_id, state="active")
-
         try:
             while True:
                 steps = copy.deepcopy(seq)
@@ -191,7 +181,8 @@ async def do_steps(self,
 
                         elif command == "wait_state":
                             if ephemeral_entity is True:
-                                self.logger.warning("Cannot process command 'wait_state', as not supported in sequence")
+                                self.logger.warning(
+                                    "Cannot process command 'wait_state', as not supported in sequence")
                                 continue
 
                             _, entity_name = entity_id.split(".")
@@ -200,7 +191,8 @@ async def do_steps(self,
                             wait_entity = parameters.get("entity_id")
 
                             if wait_entity is None:
-                                self.logger.warning("Cannot process command 'wait_state', as entity_id not given")
+                                self.logger.warning(
+                                    "Cannot process command 'wait_state', as entity_id not given")
                                 continue
 
                             state = parameters.get("state")
@@ -209,30 +201,43 @@ async def do_steps(self,
                             timeout = parameters.get("timeout", 15 * 60)
 
                             # now we create the wait entity object
-                            entity_object = Entity(self.logger, self.AD, name, ns, wait_entity)
-                            if not entity_object.exists():
+                            entity_object = Entity(
+                                self.logger, self.AD, name, ns, wait_entity)
+                            if not await entity_object.exists():
                                 self.logger.warning(
-                                    f"Waiting for an entity {wait_entity}, in sequence {entity_name}, that doesn't exist"
+                                    f"Waiting for an entity {wait_entity}, in sequence {
+                                        entity_name}, that doesn't exist"
                                 )
 
                             try:
                                 await entity_object.wait_state(state, attribute, duration, timeout)
                             except TimeOutException:
                                 self.logger.warning(
-                                    f"{entity_name} sequence wait for {wait_entity} timed out, so continuing sequence"
+                                    f"{entity_name} sequence wait for {
+                                        wait_entity} timed out, so continuing sequence"
                                 )
 
                         else:
                             domain, service = str.split(command, "/")
+                            # parameters["__name"] = entity_id
                             loop_step = parameters.pop("loop_step", None)
                             params = copy.deepcopy(parameters)
                             await self.AD.services.call_service(ns, domain, service, entity_id, params)
 
-                            if isinstance(loop_step, dict):  # we need to loop this command multiple times
+                            # we need to loop this command multiple times
+                            if isinstance(loop_step, dict):
                                 await self.loop_step(ns, command, parameters, loop_step)
 
                 if loop is not True:
                     break
+
+        except Exception:
+            self.logger.error("-" * 60)
+            self.logger.error("Unexpected error in do_steps()")
+            self.logger.error("-" * 60)
+            self.logger.error(traceback.format_exc())
+            self.logger.error("-" * 60)
+
         finally:
             await self.AD.state.set_state("_sequences", "rules", entity_id, state="idle")
 
@@ -257,7 +262,13 @@ async def loop_step(self, namespace: str, command: str, parameters: dict, loop_s
 
         except Exception:
             self.logger.error("-" * 60)
-            self.logger.error("Unexpected error when attempting to loop step")
+            self.logger.error("Unexpected error in loop_step()")
             self.logger.error("-" * 60)
             self.logger.error(traceback.format_exc())
             self.logger.error("-" * 60)
+
+    #
+    # Placeholder for constraints
+    #
+    def list_constraints(self):
+        return []

appdaemon/sequences.py

@@ -85,10 +85,12 @@ def register_service(self, namespace: str, domain: str, service: str, callback:
             name = kwargs.get("__name")
             # first we confirm if the namespace exists
             if name and namespace not in self.AD.state.state:
-                raise NamespaceException(f"Namespace {namespace}, doesn't exist")
+                raise NamespaceException(
+                    f"Namespace {namespace}, doesn't exist")
 
             elif not callable(callback):
-                raise ValueError(f"The given callback {callback} is not a callable function")
+                raise ValueError(f"The given callback {
+                                 callback} is not a callable function")
 
             if namespace not in self.services:
                 self.services[namespace] = {}
@@ -99,27 +101,32 @@ def register_service(self, namespace: str, domain: str, service: str, callback:
             if service in self.services[namespace][domain]:
                 # there was a service already registered before
                 # so if a different app, we ask to deregister first
-                service_app = self.services[namespace][domain][service].get("__name")
+                service_app = self.services[namespace][domain][service].get(
+                    "__name")
                 if service_app and service_app != name:
                     self.logger.warning(
-                        f"This service '{domain}/{service}' already registered to a different app '{service_app}', and so cannot be registered to {name}. Do deregister from app first"
+                        f"This service '{domain}/{service}' already registered to a different app '{
+                            service_app}', and so cannot be registered to {name}. Do deregister from app first"
                     )
                     return
 
-            self.services[namespace][domain][service] = {"callback": callback, "__name": name, **kwargs}
+            self.services[namespace][domain][service] = {
+                "callback": callback, "__name": name, **kwargs}
 
             if __silent is False:
                 data = {
                     "event_type": "service_registered",
                     "data": {"namespace": namespace, "domain": domain, "service": service},
                 }
-                self.AD.loop.create_task(self.AD.events.process_event(namespace, data))
+                self.AD.loop.create_task(
+                    self.AD.events.process_event(namespace, data))
 
             if name:
                 if name not in self.app_registered_services:
                     self.app_registered_services[name] = set()
 
-                self.app_registered_services[name].add(f"{namespace}:{domain}:{service}")
+                self.app_registered_services[name].add(
+                    f"{namespace}:{domain}:{service}")
 
     def deregister_service(self, namespace: str, domain: str, service: str, __name: str) -> bool:
         """Used to unregister a service"""
@@ -133,12 +140,14 @@ def deregister_service(self, namespace: str, domain: str, service: str, __name:
         )
 
         if __name not in self.app_registered_services:
-            raise ValueError(f"The given App {__name} has no services registered")
+            raise ValueError(f"The given App {
+                             __name} has no services registered")
 
         app_service = f"{namespace}:{domain}:{service}"
 
         if app_service not in self.app_registered_services[__name]:
-            raise ValueError(f"The given App {__name} doesn't have the given service registered it")
+            raise ValueError(f"The given App {
+                             __name} doesn't have the given service registered it")
 
         # if it gets here, then time to deregister
         with self.services_lock:
@@ -149,7 +158,8 @@ def deregister_service(self, namespace: str, domain: str, service: str, __name:
                 "event_type": "service_deregistered",
                 "data": {"namespace": namespace, "domain": domain, "service": service, "app": __name},
             }
-            self.AD.loop.create_task(self.AD.events.process_event(namespace, data))
+            self.AD.loop.create_task(
+                self.AD.events.process_event(namespace, data))
 
             # now check if that domain is empty
             # if it is, remove it also
@@ -192,29 +202,37 @@ def list_services(self, ns: str = "global") -> list[dict[str, str]]:
             ]
 
     async def call_service(
-            self,
-            namespace: str,
-            domain: str,
-            service: str,
-            name: str | None = None,
-            data: dict[str, Any] | None = None, # Don't expand with **data
-) -> Any:
+        self,
+        namespace: str,
+        domain: str,
+        service: str,
+        name: str | None = None,
+        data: dict[str, Any] | None = None,  # Don't expand with **data
+    ) -> Any:
         self.logger.debug(
             "call_service: namespace=%s domain=%s service=%s data=%s",
             namespace,
             domain,
             service,
             data,
         )
+
+        # data can be None, later on we assume it is not!
+        if data is None:
+            data = {}
+
         with self.services_lock:
             if namespace not in self.services:
-                raise NamespaceException(f"Unknown namespace {namespace} in call_service from {name}")
+                raise NamespaceException(f"Unknown namespace {
+                                         namespace} in call_service from {name}")
 
             if domain not in self.services[namespace]:
-                raise DomainException(f"Unknown domain ({namespace}/{domain}) in call_service from {name}")
+                raise DomainException(
+                    f"Unknown domain ({namespace}/{domain}) in call_service from {name}")
 
             if service not in self.services[namespace][domain]:
-                raise ServiceException(f"Unknown service ({namespace}/{domain}/{service}) in call_service from {name}")
+                raise ServiceException(
+                    f"Unknown service ({namespace}/{domain}/{service}) in call_service from {name}")
 
             # If we have namespace in data it's an override for the domain of the eventual service call, as distinct
             # from the namespace the call itself is executed from. e.g. set_state() is in the AppDaemon namespace but
@@ -230,9 +248,10 @@ async def call_service(
             match isasync := service_def.pop("__async", 'auto'):
                 case 'auto':
                     # Remove any wrappers from the funcref before determining if it's async or not
-                    isasync = asyncio.iscoroutinefunction(utils.unwrapped(funcref))
+                    isasync = asyncio.iscoroutinefunction(
+                        utils.unwrapped(funcref))
                 case bool():
-                    pass # isasync already set as a bool from above
+                    pass  # isasync already set as a bool from above
                 case _:
                     raise TypeError(f'Invalid __async type: {isasync}')
 
@@ -247,9 +266,11 @@ async def call_service(
             else:
                 # It's not a coroutine, run it in an executor
                 if use_dictionary_unpacking:
-                    coro = utils.run_in_executor(self, funcref, ns, domain, service, **data)
+                    coro = utils.run_in_executor(
+                        self, funcref, ns, domain, service, **data)
                 else:
-                    coro = utils.run_in_executor(self, funcref, ns, domain, service, data)
+                    coro = utils.run_in_executor(
+                        self, funcref, ns, domain, service, data)
 
             @utils.warning_decorator(error_text=f"Unexpected error calling service {ns}/{domain}/{service}")
             async def safe_service(self: 'Services'):

appdaemon/services.py

@@ -554,13 +554,13 @@ def maybe_copy(data):
         }
 
     def parse_state(
-            self,
-            namespace: str,
-            entity: str,
-            state: Any | None = None,
-            attributes: dict | None = None,
-            replace: bool = False,
-            **kwargs
+        self,
+        namespace: str,
+        entity: str,
+        state: Any | None = None,
+        attributes: dict | None = None,
+        replace: bool = False,
+        **kwargs
     ):
         self.logger.debug(f"parse_state: {entity}, {kwargs}")