appdaemon 4.5.6__tar.gz → 4.5.8__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: appdaemon
-Version: 4.5.6
+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.6 → appdaemon-4.5.8}/appdaemon/adapi.py

@@ -17,6 +17,7 @@ from typing import TYPE_CHECKING, Any, Literal, TypeVar, overload
 from appdaemon import dependency, utils
 from appdaemon import exceptions as ade
 from appdaemon.appdaemon import AppDaemon
+from appdaemon.models.config.app import AppConfig
 from appdaemon.entity import Entity
 from appdaemon.events import EventCallback
 from appdaemon.logging import Logging
@@ -76,11 +77,6 @@ class ADAPI:
     def __init__(self, ad: AppDaemon, config_model: "AppConfig"):
         self.AD = ad
         self.config_model = config_model
-
-        self.config = self.AD.config.model_dump(by_alias=True, exclude_unset=True)
-        self.app_config = self.AD.app_management.app_config.model_dump(by_alias=True, exclude_unset=True)
-        self.args = config_model.model_dump(by_alias=True, exclude_unset=True)
-
         self.dashboard_dir = None
 
         if self.AD.http is not None:
@@ -134,17 +130,44 @@ class ADAPI:
         directory, but can be overridden in ``appdaemon.app_dir`` in the ``appdaemon.yaml`` file."""
         return self.AD.app_dir
 
+    @app_dir.setter
+    def app_dir(self, value: Path) -> None:
+        self.logger.warning('app_dir is read-only and needs to be set before AppDaemon starts')
+
     @property
     def callback_counter(self) -> int:
         return self.AD.app_management.objects[self.name].callback_counter
 
+    @callback_counter.setter
+    def callback_counter(self, value: Path) -> None:
+        self.logger.warning('callback_counter is read-only and is set internally by AppDaemon')
+
     @property
     def config_dir(self) -> Path:
         """Directory that contains the ``appdaemon.yaml`` file."""
         return self.AD.config_dir
 
+    @config_dir.setter
+    def config_dir(self, value: Path) -> None:
+        self.logger.warning('config_dir is read-only and needs to be set before AppDaemon starts')
+
+    @property
+    def config_model(self) -> AppConfig:
+        """The AppConfig model only for this app."""
+        return self._config_model
+
+    @config_model.setter
+    def config_model(self, new_config: Any) -> None:
+        match new_config:
+            case AppConfig():
+                self._config_model = new_config
+            case _:
+                self._config_model = AppConfig.model_validate(new_config)
+        self.args = self._config_model.model_dump(by_alias=True, exclude_unset=True)
+
     @property
     def global_vars(self) -> Any:
+        """Globally locked attribute that can be used to share data between apps."""
         with self.AD.global_lock:
             return self.AD.global_vars
 
@@ -158,16 +181,28 @@ class ADAPI:
         """Reference to the AppDaemon Logging subsystem object."""
         return self.AD.logging
 
+    @_logging.setter
+    def _logging(self, value: Logging) -> None:
+        self.logger.warning('The _logging property is read-only')
+
     @property
     def name(self) -> str:
         """The name for the app, as defined by it's key in the corresponding YAML file."""
         return self.config_model.name
 
+    @name.setter
+    def name(self, value: str) -> None:
+        self.logger.warning("The name property is read-only and is defined by the app's key in the YAML file")
+
     @property
     def plugin_config(self) -> dict:
         self.get_plugin_config()
         return self.AD.plugins.config
 
+    @plugin_config.setter
+    def plugin_config(self, value: dict) -> None:
+        self.logger.warning("The plugin_config property is read-only and is set by the plugin itself")
+
     #
     # Logging
     #

{appdaemon-4.5.6 → appdaemon-4.5.8}/appdaemon/adbase.py

@@ -2,11 +2,11 @@ import threading
 from functools import wraps
 from logging import Logger
 from pathlib import Path
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Any
 
 from appdaemon import adapi
 from appdaemon import utils
-from appdaemon.models.config.app import AppConfig
+from appdaemon.models.config.app import AppConfig, AllAppConfig
 
 
 # Check if the module is being imported using the legacy method
@@ -73,8 +73,6 @@ def global_lock(f):
 
 class ADBase:
     AD: "AppDaemon"
-    config_model: "AppConfig"
-
     config: dict
     """Dictionary of the AppDaemon configuration
     """
@@ -96,10 +94,7 @@ class ADBase:
     def __init__(self, ad: "AppDaemon", config_model: "AppConfig"):
         self.AD = ad
         self.config_model = config_model
-
         self.config = self.AD.config.model_dump(by_alias=True, exclude_unset=True)
-        self.args = self.config_model.model_dump(by_alias=True, exclude_unset=True)
-
         self.namespace = "default"
         self.dashboard_dir = None
 
@@ -136,9 +131,28 @@ class ADBase:
         # Sometimes this will be None. Namespaces are not guaranteed to be associated with a plugin
 
     @property
-    def app_config(self):
+    def app_config(self) -> AllAppConfig:
+        """The full app configuration model for all the apps."""
         return self.AD.app_management.app_config
 
+    @app_config.setter
+    def app_config(self, new_config: AppConfig) -> None:
+        self.logger.warning("The full app configuration model is read-only")
+
+    @property
+    def config_model(self) -> AppConfig:
+        """The AppConfig model only for this app."""
+        return self._config_model
+
+    @config_model.setter
+    def config_model(self, new_config: Any) -> None:
+        match new_config:
+            case AppConfig():
+                self._config_model = new_config
+            case _:
+                self._config_model = AppConfig.model_validate(new_config)
+        self.args = self._config_model.model_dump(by_alias=True, exclude_unset=True)
+
     @property
     def app_dir(self) -> Path:
         return self.AD.app_dir

{appdaemon-4.5.6 → 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.6 → 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.6 → 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.6 → 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.6 → 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.6 → 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(