appdaemon 4.5.7__tar.gz → 4.5.8__tar.gz

{appdaemon-4.5.7/appdaemon.egg-info → appdaemon-4.5.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: appdaemon
-Version: 4.5.7
+Version: 4.5.8
 Summary: Apps for the Home Assistant home automation package.
 Author-email: Andrew I Cockburn <appdaemon@acockburn.com>
 Project-URL: documentation, https://appdaemon.readthedocs.io

{appdaemon-4.5.7 → appdaemon-4.5.8}/appdaemon/app_management.py

@@ -15,7 +15,7 @@ from copy import copy
 from functools import partial, reduce, wraps
 from logging import Logger
 from pathlib import Path
-from typing import TYPE_CHECKING, Literal, TypeVar
+from typing import TYPE_CHECKING, Any, Literal, TypeVar
 
 from pydantic import ValidationError
 
@@ -432,7 +432,7 @@ class AppManagement:
         else:
             return True
 
-    async def restart_app(self, app):
+    async def restart_app(self, app: str) -> None:
         await self.stop_app(app, delete=False)
         try:
             await self.start_app(app)
@@ -513,8 +513,11 @@ class AppManagement:
     def get_managed_app_names(self, include_globals: bool = False) -> set[str]:
         apps = set(name for name, o in self.objects.items() if o.type == "app")
         if include_globals:
-            apps |= set(name for name, cfg in self.app_config.root.items()
-                        if isinstance(cfg, GlobalModule))
+            globals = set(
+                name for name, cfg in self.app_config.root.items()
+                if isinstance(cfg, GlobalModule)
+            )
+            apps |= globals
         return apps
 
     def add_plugin_object(self, name: str, object: "PluginBase", use_dictionary_unpacking: bool = False) -> None:
@@ -763,7 +766,7 @@ class AppManagement:
         return wrapper
 
     # @utils.timeit
-    async def check_app_updates(self, plugin_ns: str = None, mode: UpdateMode = UpdateMode.NORMAL):
+    async def check_app_updates(self, plugin_ns: str | None = None, mode: UpdateMode = UpdateMode.NORMAL):
         """Checks the states of the Python files that define the apps, reloading when necessary.
 
         Called as part of :meth:`.utility_loop.Utility.loop`
@@ -778,12 +781,18 @@ class AppManagement:
         async with self.check_updates_lock:
             await self._process_filters()
 
-            if mode == UpdateMode.INIT:
-                await self._process_import_paths()
-                await self._init_dep_manager()
-
             update_actions = UpdateActions()
 
+            match mode:
+                case UpdateMode.INIT:
+                    await self._process_import_paths()
+                    await self._init_dep_manager()
+                case UpdateMode.RELOAD_APPS:
+                    all_apps = self.get_managed_app_names(include_globals=False)
+                    modules = self.dependency_manager.modules_from_apps(all_apps)
+                    update_actions.apps.reload |= all_apps
+                    update_actions.modules.reload |= modules
+
             await self.check_app_config_files(update_actions)
 
             await self._handle_sequence_change(update_actions, mode)
@@ -1285,40 +1294,39 @@ class AppManagement:
             self.get_state(app, attribute="config_path")
         )
 
-    async def manage_services(self,
-                              namespace: str,
-                              domain: str,
-                              service: str,
-                              app: str | None = None,
-                              __name: str | None = None,
-                              **kwargs):
+    async def manage_services(
+        self,
+        namespace: str,
+        domain: str,
+        service: Literal["start", "stop", "restart", "reload", "enable", "disable", "create", "edit", "remove"],
+        app: str | None = None,
+        __name: str | None = None,
+        **kwargs
+    ) -> None | bool | Any:
         assert namespace == 'admin' and domain == 'app'
-
-        if app is None and service != "reload":
-            self.logger.warning(
-                "App not specified when calling '%s' service from %s. Specify App", service, __name)
-            return
-
         match service:
             case "reload" | "create":
                 pass
             case _:
-                if app not in self.app_config:
+                if app not in self.get_managed_app_names(include_globals=False):
                     self.logger.warning(
-                        "Specified App '%s' is not a valid App from %s", app, __name)
+                        "Specified app '%s' for service '%s' is not valid from %s",
+                        app,
+                        service,
+                        __name
+                    )
                     return
 
-        match service:
-            case "start":
-                asyncio.ensure_future(self.start_app(app))
-            case "stop":
-                asyncio.ensure_future(self.stop_app(app, delete=False))
-            case "restart":
-                asyncio.ensure_future(self.restart_app(app))
-            case "reload":
-                asyncio.ensure_future(
-                    self.check_app_updates(mode=UpdateMode.INIT))
-            case _:
+        match (service, app):
+            case ("start", str()):
+                asyncio.create_task(self.start_app(app))
+            case ("stop", str()):
+                asyncio.create_task(self.stop_app(app, delete=False))
+            case ("restart", str()):
+                asyncio.create_task(self.restart_app(app))
+            case ("reload", _):
+                asyncio.create_task(self.check_app_updates(mode=UpdateMode.RELOAD_APPS))
+            case (_, str()):
                 # first the check app updates needs to be stopped if on
                 mode = copy.deepcopy(self.AD.production_mode)
 
@@ -1343,3 +1351,10 @@ class AppManagement:
                     self.AD.production_mode = mode
 
                 return result
+            case _:
+                self.logger.warning(
+                    "Invalid app service call '%s' with app '%s' from  app %s.",
+                    service,
+                    app,
+                    __name
+                )

{appdaemon-4.5.7 → appdaemon-4.5.8}/appdaemon/dependency_manager.py

@@ -173,8 +173,9 @@ class DependencyManager:
         return self.python_deps.get_dependents(modules)
 
     def modules_from_apps(self, apps: str | Iterable[str], dependents: bool = True) -> set[str]:
-        """Find the importable names of all the python modules that depend on the given apps. Includes
-        the transitive closure by default.
+        """Find the importable names of all the python modules that the given apps depend on.
+
+        This includes the transitive closure by default.
 
         Args:
             apps (str | Iterable[str]):

{appdaemon-4.5.7 → appdaemon-4.5.8}/appdaemon/events.py

@@ -15,7 +15,7 @@ if TYPE_CHECKING:
 
 
 class EventCallback(Protocol):
-    def __call__(self, event_name: str, data: dict[str, Any], **kwargs: Any) -> None: ...
+    def __call__(self, event_type: str, data: dict[str, Any], **kwargs: Any) -> None: ...
 
 
 class Events:
@@ -214,8 +214,8 @@ class Events:
             # if data["event_type"] == "__AD_ENTITY_REMOVED":
             #    print("process event")
 
-            self.logger.debug("Event type:%s:", data["event_type"])
-            self.logger.debug(data["data"])
+            self.logger.debug("Event type: %s:", data["event_type"])
+            # self.logger.debug(data["data"])
 
             # Kick the scheduler so it updates it's clock
             if self.AD.sched is not None and self.AD.sched.realtime is False and namespace != "admin":

{appdaemon-4.5.7 → appdaemon-4.5.8}/appdaemon/models/config/plugin.py

@@ -92,7 +92,7 @@ class HASSConfig(PluginConfig):
     enable_started_event: bool = True
     """If true, the plugin will wait for the 'homeassistant_started' event before starting the plugin."""
     cert_path: CoercedPath | None = None
-    cert_verify: bool | None = None
+    cert_verify: bool = True
     commtype: str = "WS"
     q_timeout: int = 30
     ws_timeout: Annotated[

{appdaemon-4.5.7 → appdaemon-4.5.8}/appdaemon/models/internal/app_management.py

@@ -24,6 +24,7 @@ class UpdateMode(Enum):
 
     INIT = auto()
     NORMAL = auto()
+    RELOAD_APPS = auto()
     PLUGIN_FAILED = auto()
     PLUGIN_RESTART = auto()
     TERMINATE = auto()

{appdaemon-4.5.7 → appdaemon-4.5.8}/appdaemon/plugins/hass/hassapi.py

@@ -58,10 +58,14 @@ class Hass(ADBase, ADAPI):
         self.register_constraint("constrain_input_select")
 
     @utils.sync_decorator
-    async def ping(self) -> float:
+    async def ping(self) -> float | None:
         """Gets the number of seconds """
         if (plugin := self._plugin) is not None:
-            return (await plugin.ping())['ad_duration']
+            match await plugin.ping():
+                case {"ad_status": "OK", "ad_duration": ad_duration}:
+                    return ad_duration
+                case _:
+                    return None
 
     @utils.sync_decorator
     async def check_for_entity(self, entity_id: str, namespace: str | None = None) -> bool:
@@ -539,16 +543,14 @@ class Hass(ADBase, ADAPI):
         Returns:
             Information about the service in a dict with the following keys: ``name``, ``description``, ``target``, and
             ``fields``.
-
         """
-        if (plugin := self._plugin) is not None:
-            domain, service_name = service.split("/", 2)
-            for service_def in plugin.services:
-                if service_def.get("domain") == domain:
-                    if (services := service_def.get("services")) is not None:
-                        return deepcopy(services.get(service_name))
-            else:
-                self.logger.warning("Service info not found for domain '%s", domain)
+        match self._plugin:
+            case HassPlugin() as plugin:
+                domain, service_name = service.split("/", 2)
+                if info := plugin.services.get(domain, {}).get(service_name):
+                    # Return a copy of the info dict to prevent accidental modification
+                    return deepcopy(info)
+        self.logger.warning("Service info not found for domain '%s", domain)
 
     # Methods that use self.call_service
 
@@ -680,7 +682,7 @@ class Hass(ADBase, ADAPI):
         significant_changes_only: bool | None = None,
         callback: Callable | None = None,
         namespace: str | None = None,
-    ) -> list[list[dict[str, Any]]]:
+    ) -> list[list[dict[str, Any]]] | None:
         """Gets access to the HA Database.
         This is a convenience function that allows accessing the HA Database, so the
         history state of a device can be retrieved. It allows for a level of flexibility
@@ -755,31 +757,27 @@ class Hass(ADBase, ADAPI):
             end_time = end_time or await self.get_now()
             start_time = end_time - timedelta(days=days)
 
-
-        plugin: "HassPlugin" = self.AD.plugins.get_plugin_object(
-            namespace or self.namespace
-        )
-
-        if plugin is not None:
-            coro = plugin.get_history(
-                filter_entity_id=entity_id,
-                timestamp=start_time,
-                end_time=end_time,
-                minimal_response=minimal_response,
-                no_attributes=no_attributes,
-                significant_changes_only=significant_changes_only,
-            )
-
-            if callback is not None and callable(callback):
-                self.create_task(coro, callback)
-            else:
-                return await coro
-
-        else:
-            self.logger.warning(
-                "Wrong Namespace selected, as %s has no database plugin attached to it",
-                namespace,
-            )
+        plugin = self.AD.plugins.get_plugin_object(namespace or self.namespace)
+        match plugin:
+            case HassPlugin():
+                coro = plugin.get_history(
+                    filter_entity_id=entity_id,
+                    timestamp=start_time,
+                    end_time=end_time,
+                    minimal_response=minimal_response,
+                    no_attributes=no_attributes,
+                    significant_changes_only=significant_changes_only,
+                )
+
+                if callback is not None and callable(callback):
+                    self.create_task(coro, callback)
+                else:
+                    return await coro
+            case _:
+                self.logger.warning(
+                    "Wrong Namespace selected, as %s has no database plugin attached to it",
+                    namespace,
+                )
 
     @utils.sync_decorator
     async def get_logbook(