improved home assistant connection errors

Author: jsl12

appdaemon/__init__.py

@@ -1,7 +1,7 @@
+from . import models as cfg
 from .adapi import ADAPI
 from .appdaemon import AppDaemon
 from .plugins.hass.hassapi import Hass
 from .plugins.mqtt.mqttapi import Mqtt
-from . import models as cfg
 
 __all__ = ["ADAPI", "AppDaemon", "Hass", "Mqtt", "cfg"]

appdaemon/__main__.py

@@ -17,15 +17,13 @@
 import os
 import signal
 import sys
-from collections.abc import Callable, Generator
+from collections.abc import Generator
 from contextlib import ExitStack, contextmanager
 from logging import Logger
 from pathlib import Path
 from time import perf_counter
 
-
 import appdaemon.appdaemon as ad
-from .dependency_manager import DependencyManager
 import appdaemon.utils as utils
 from appdaemon import exceptions as ade
 from appdaemon.app_management import UpdateMode
@@ -34,6 +32,7 @@
 from appdaemon.http import HTTP
 from appdaemon.logging import Logging
 
+from .dependency_manager import DependencyManager
 from .models.config.yaml import MainConfig
 
 logger = logging.getLogger(__name__)
@@ -52,41 +51,36 @@
 
 # This dict sets up the default logging before the config has even been read.
 PRE_LOGGING = {
-    'version': 1,
-    'disable_existing_loggers': False,
-    'formatters': {
-        'bare': {
-            'format': "{levelname}: {message}",
-            'style': '{',
+    "version": 1,
+    "disable_existing_loggers": False,
+    "formatters": {
+        "bare": {
+            "format": "{levelname}: {message}",
+            "style": "{",
+        },
+        "full": {
+            "format": "{asctime}.{msecs:03.0f} {levelname} AppDaemon: {message}",
+            "style": "{",
+            "datefmt": "%Y-%m-%d %H:%M:%S",
         },
-        'full': {
-            'format': "{asctime}.{msecs:03.0f} {levelname} AppDaemon: {message}",
-            'style': '{',
-            'datefmt': '%Y-%m-%d %H:%M:%S'
-        }
     },
-    'handlers': {
-        'stdout': {
-            'class': 'logging.StreamHandler',
-            'formatter': 'full',
-            'stream': 'ext://sys.stdout'
+    "handlers": {
+        "stdout": {
+            "class": "logging.StreamHandler",
+            "formatter": "full",
+            "stream": "ext://sys.stdout",
+        },
+        "stderr": {
+            "class": "logging.StreamHandler",
+            "formatter": "bare",
+            "stream": "ext://sys.stderr",
         },
-        'stderr': {
-            'class': 'logging.StreamHandler',
-            'formatter': 'bare',
-            'stream': 'ext://sys.stderr'
-        }
     },
-    'root': {
-        'level': 'INFO',
-        'handlers': ['stdout'],
+    "root": {
+        "level": "INFO",
+        "handlers": ["stdout"],
     },
-    'loggers': {
-        'bare': {
-            'handlers': ['stderr'],
-            'propagate': False
-        }
-    }
+    "loggers": {"bare": {"handlers": ["stderr"], "propagate": False}},
 }
 
 
@@ -196,7 +190,7 @@ def resolve_config_file(args: argparse.Namespace) -> tuple[Path, Path]:
     return config_file, config_dir
 
 
-def parse_config(args: argparse.Namespace, stop_function: Callable) -> MainConfig:
+def parse_config(args: argparse.Namespace) -> MainConfig:
     """Parse configuration file and return MainConfig model.
 
     Args:
@@ -228,26 +222,24 @@ def parse_config(args: argparse.Namespace, stop_function: Callable) -> MainConfi
     assert isinstance(ad_kwargs, dict), "AppDaemon configuration must be a dictionary"
 
     # Batch assign required parameters
-    ad_kwargs.update({
-        "config_dir": config_dir,
-        "config_file": config_file,
-        "write_toml": args.write_toml,
-        "stop_function": stop_function,
-    })
+    ad_kwargs.update(
+        {
+            "config_dir": config_dir,
+            "config_file": config_file,
+            "write_toml": args.write_toml,
+        }
+    )
 
     # Conditionally assign time-related parameters
     for attr in ("timewarp", "starttime", "endtime"):
-        if (value := getattr(args, attr)):
+        if value := getattr(args, attr):
             ad_kwargs[attr] = value
 
     # Set log level with fallback
     ad_kwargs["loglevel"] = args.debug or ad_kwargs.get("loglevel", "INFO")
 
     # Handle module debug efficiently
-    module_debug_cli = (
-        {arg[0]: arg[1] for arg in args.moduledebug}
-        if args.moduledebug else {}
-    )
+    module_debug_cli = {arg[0]: arg[1] for arg in args.moduledebug} if args.moduledebug else {}
 
     if isinstance(ad_kwargs.get("module_debug"), dict):
         ad_kwargs["module_debug"] |= module_debug_cli
@@ -290,16 +282,13 @@ class ADMain:
     """Pydantic model of the top-level object for the appdaemon.yaml file."""
     args: argparse.Namespace
 
-    stop_time: float = 0.0
-    """Stores the value of perf_counter() when self.stop is first called."""
-
     def __init__(self, args: argparse.Namespace) -> None:
         self.args = args
         self.http_object = None
         self._cleanup_stack = ExitStack()
 
         try:
-            self.model = parse_config(self.args, self.stop)
+            self.model = parse_config(self.args)
             self.setup_logging()
             utils.deprecation_warnings(self.model.appdaemon, self.logger)
 
@@ -319,7 +308,11 @@ def __init__(self, args: argparse.Namespace) -> None:
     def __enter__(self):
         try:
             self._cleanup_stack.enter_context(
-                ade.exception_context(self.logger, self.model.appdaemon.app_dir, header="ADMain")
+                ade.exception_context(
+                    self.logger,
+                    self.model.appdaemon.app_dir,
+                    header="ADMain",
+                )
             )
 
             if self.args.pidfile is not None and pid is not None:
@@ -362,7 +355,7 @@ def handle_sig(self, signum: int):
                 self.AD.thread_async.call_async_no_wait(self.AD.app_management.check_app_updates, mode=UpdateMode.TERMINATE)
             case (signal.SIGINT | signal.SIGTERM) as sig:
                 self.logger.info(f"Received signal: {signal.Signals(sig).name}")
-                self.stop()
+                self.AD.stop()
 
     @contextmanager
     def loop_context(self) -> Generator[asyncio.AbstractEventLoop]:
@@ -409,7 +402,7 @@ def signal_handlers(self, loop: asyncio.AbstractEventLoop):
     def stop(self):
         """Stop AppDaemon and stop the event loop afterwards."""
         self.stop_time = perf_counter()
-        task = self.loop.create_task(self.AD.stop())
+        task = self.loop.create_task(self.AD._stop())
         task.add_done_callback(lambda _: self.loop.stop())
 
     def run(self) -> None:
@@ -460,13 +453,12 @@ def run_context(self, loop: asyncio.AbstractEventLoop):
             self.logger.warning("-" * 60, exc_info=True)
             self.logger.warning("-" * 60)
         finally:
-            self.logger.debug('Exiting self.run_context')
+            self.logger.debug("Exiting self.run_context")
             self.loop.set_exception_handler(None)
             self.logger.info("AppDaemon is stopped.")
 
     def setup_logging(self) -> None:
-        """Set up logging configuration and timezone.
-        """
+        """Set up logging configuration and timezone."""
         log_cfg = self.model.logs.model_dump(mode="python", by_alias=True, exclude_unset=True)
         self.logging = Logging(log_cfg, self.args.debug)
         self.logger = self.logging.get_logger().getChild("_startup")
@@ -491,7 +483,7 @@ def startup_text(self):
             # self.logging.dump_log_config()
             yield
         finally:
-            stop_duration = perf_counter() - self.stop_time
+            stop_duration = perf_counter() - self.AD.stop_time
             self.logger.info("AppDaemon main() stopped gracefully in %s", utils.format_timedelta(stop_duration))
 
 

appdaemon/adapi.py

@@ -14,9 +14,8 @@
 from pathlib import Path
 from typing import TYPE_CHECKING, Any, Literal, TypeVar, overload
 
-from appdaemon import dependency
+from appdaemon import dependency, utils
 from appdaemon import exceptions as ade
-from appdaemon import utils
 from appdaemon.appdaemon import AppDaemon
 from appdaemon.entity import Entity
 from appdaemon.events import EventCallback

appdaemon/app_management.py

@@ -21,7 +21,6 @@
 
 from pydantic import ValidationError
 
-
 from appdaemon.dependency import DependencyResolutionFail, get_full_module_name
 from appdaemon.dependency_manager import DependencyManager
 from appdaemon.models.config import AllAppConfig, AppConfig, GlobalModule
@@ -33,9 +32,9 @@
 from .models.internal.app_management import LoadingActions, ManagedObject, UpdateActions, UpdateMode
 
 if TYPE_CHECKING:
-    from .appdaemon import AppDaemon
-    from .adbase import ADBase
     from .adapi import ADAPI
+    from .adbase import ADBase
+    from .appdaemon import AppDaemon
     from .plugin_management import PluginBase
 
 T = TypeVar("T")

appdaemon/appdaemon.py

@@ -6,6 +6,7 @@
 from contextlib import ExitStack
 from pathlib import Path
 from threading import RLock
+from time import perf_counter
 from typing import TYPE_CHECKING, Any
 
 from appdaemon.admin_loop import AdminLoop
@@ -23,7 +24,6 @@
 from appdaemon.threads import Threading
 from appdaemon.utility_loop import Utility
 
-
 if TYPE_CHECKING:
     from appdaemon.http import HTTP
     from appdaemon.logging import Logging
@@ -82,7 +82,6 @@ class AppDaemon:
     """
     exit_stack: ExitStack
 
-
     # subsystems
     app_management: AppManagement
     callbacks: Callbacks
@@ -102,8 +101,10 @@ class AppDaemon:
     http: "HTTP | None" = None
     global_lock: RLock = RLock()
 
-    # shut down flag
     stop_event: asyncio.Event
+    """Flag to indicate that AppDaemon is stopping. Set by :meth:`~.appdaemon.AppDaemon.stop` and checked by subsystems."""
+    stop_time: float = 0.0
+    """Stores the value of perf_counter() when self.stop is first called."""
 
     def __init__(
         self,
@@ -121,7 +122,6 @@ def __init__(
         self.logging.register_ad(self)  # needs to go last to reference the config object
         self.stop_event = asyncio.Event()
 
-
         self.global_vars: Any = {}
         self.main_thread_id = threading.current_thread().ident
 
@@ -314,9 +314,7 @@ def real_time(self, value: bool) -> None:
         if value:
             self.timewarp = 1.0
         else:
-            raise NotImplementedError(
-                "Setting real_time to False is not supported. Set timewarp to a value other than 1.0 instead."
-            )
+            raise NotImplementedError("Setting real_time to False is not supported. Set timewarp to a value other than 1.0 instead.")
 
     @property
     def starttime(self):
@@ -336,10 +334,6 @@ def stopping(self, value: bool) -> None:
         else:
             self.stop_event.clear()
 
-    @property
-    def stop_function(self):
-        return self.config.stop_function or self.stop
-
     @property
     def thread_duration_warning_threshold(self):
         return self.config.thread_duration_warning_threshold
@@ -397,7 +391,17 @@ def start(self) -> None:
         if self.apps_enabled:
             self.app_management.start()
 
-    async def stop(self) -> None:
+    def stop(self) -> None:
+        """Stop AppDaemon gracefully by initiating the shutdown sequence.
+
+        Creates an async task to handle the shutdown process and schedules the event loop to stop once shutdown is
+        complete. The actual shutdown logic is handled by _stop().
+        """
+        self.stop_time = perf_counter()
+        task = self.loop.create_task(self._stop())
+        task.add_done_callback(lambda _: self.loop.stop())
+
+    async def _stop(self) -> None:
         """Stop AppDaemon by calling the stop method of the subsystems.
 
         This does not stop the event loop, but waits for all the existings tasks to finish before returning, which has a 3s timeout.

appdaemon/exceptions.py

@@ -18,7 +18,7 @@
 from pathlib import Path
 from typing import TYPE_CHECKING, Any, Type
 
-from aiohttp.client_exceptions import ClientConnectorError
+from aiohttp.client_exceptions import ClientConnectorError, ConnectionTimeoutError
 from pydantic import ValidationError
 
 if TYPE_CHECKING:
@@ -102,7 +102,7 @@ def user_exception_block(logger: Logger, exception: Exception, app_dir: Path, he
                 if user_line := get_user_line(exc, app_dir):
                     for line, filename, func_name in list(user_line)[::-1]:
                         logger.error(f"{indent}{filename} line {line} in {func_name}")
-            case ClientConnectorError():
+            case ClientConnectorError() | ConnectionTimeoutError():
                 logger.error(f"{indent}{exc.__class__.__name__}: {exc}")
                 break
             case OSError() if str(exc).endswith("address already in use"):

appdaemon/futures.py

@@ -1,7 +1,7 @@
 import asyncio
 from collections import defaultdict
-from typing import TYPE_CHECKING
 from concurrent.futures import Future
+from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
     from appdaemon.appdaemon import AppDaemon