Merge branch 'threading'

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

@@ -23,9 +23,7 @@
 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,7 +32,9 @@
 from appdaemon.http import HTTP
 from appdaemon.logging import Logging
 
+from .dependency_manager import DependencyManager
 from .models.config.yaml import MainConfig
+from .version import __version__, __version_comments__
 
 logger = logging.getLogger(__name__)
 err_logger = logging.getLogger("bare")
@@ -137,7 +137,7 @@ def parse_arguments() -> argparse.Namespace:
         choices=["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"],
     )
     parser.add_argument("-m", "--moduledebug", nargs=2, action="append")
-    parser.add_argument("-v", "--version", action="version", version="%(prog)s " + utils.__version__)
+    parser.add_argument("-v", "--version", action="version", version="%(prog)s " + __version__)
     parser.add_argument("--profiledash", help=argparse.SUPPRESS, action="store_true")
     parser.add_argument("--write_toml", help="use TOML for creating new app configuration files", action="store_true")
     # TODO Implement --write_toml
@@ -355,7 +355,7 @@ def handle_sig(self, signum: int):
             case signal.SIGUSR1:
                 self.AD.thread_async.call_async_no_wait(self.AD.sched.dump_schedule)
                 self.AD.thread_async.call_async_no_wait(self.AD.callbacks.dump_callbacks)
-                self.AD.thread_async.call_async_no_wait(self.AD.threading.dump_threads)
+                self.AD.loop.call_soon_threadsafe(self.AD.threading.dump_threads)
                 self.AD.thread_async.call_async_no_wait(self.AD.app_management.dump_objects)
                 self.AD.thread_async.call_async_no_wait(self.AD.sched.dump_sun)
             case signal.SIGHUP:
@@ -479,10 +479,10 @@ def startup_text(self):
         try:
             # Startup message
             self.logger.info("-" * 60)
-            self.logger.info("AppDaemon Version %s starting", utils.__version__)
+            self.logger.info("AppDaemon Version %s starting", __version__)
 
-            if utils.__version_comments__ is not None and utils.__version_comments__ != "":
-                self.logger.info("Additional version info: %s", utils.__version_comments__)
+            if __version_comments__ is not None and __version_comments__ != "":
+                self.logger.info("Additional version info: %s", __version_comments__)
 
             self.logger.info("-" * 60)
             self.logger.info("Python version is %s.%s.%s", *sys.version_info[:3])

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
@@ -25,6 +24,8 @@
 from appdaemon.parse import resolve_time_str
 from appdaemon.state import StateCallbackType
 
+from .version import __version__
+
 T = TypeVar("T")
 
 
@@ -777,18 +778,17 @@ def get_ad_version() -> str:
             >>> version = self.get_ad_version()
 
         """
-        return utils.__version__
+        return __version__
 
     #
     # Entity
     #
 
-    @utils.sync_decorator
-    async def add_entity(
+    def add_entity(
         self,
         entity_id: str,
         state: Any,
-        attributes: dict | None = None,
+        attributes: dict[str, Any] | None = None,
         namespace: str | None = None,
     ) -> None:
         """Adds a non-existent entity, by creating it within a namespaces.
@@ -817,11 +817,10 @@ async def add_entity(
             >>> self.add_entity('mqtt.living_room_temperature', namespace='mqtt')
 
         """
-        namespace = namespace or self.namespace
-        return await self.AD.state.add_entity(namespace, entity_id, state, attributes)
+        namespace = namespace if namespace is not None else self.namespace
+        return self.AD.state.add_entity(namespace, entity_id, state, attributes)
 
-    @utils.sync_decorator
-    async def entity_exists(self, entity_id: str, namespace: str | None = None) -> bool:
+    def entity_exists(self, entity_id: str, namespace: str | None = None) -> bool:
         """Checks the existence of an entity in AD.
 
         When working with multiple AD namespaces, it is possible to specify the
@@ -850,7 +849,7 @@ async def entity_exists(self, entity_id: str, namespace: str | None = None) -> b
             >>> if self.entity_exists("mqtt.security_settings", namespace = "mqtt"):
             >>>    #do something
         """
-        namespace = namespace or self.namespace
+        namespace = namespace if namespace is not None else self.namespace
         return self.AD.state.entity_exists(namespace, entity_id)
 
     @utils.sync_decorator
@@ -1724,7 +1723,7 @@ async def get_state(
         if kwargs:
             self.logger.warning(f"Extra kwargs passed to get_state, will be ignored: {kwargs}")
 
-        return await self.AD.state.get_state(
+        return self.AD.state.get_state(
             name=self.name,
             namespace=namespace or self.namespace,
             entity_id=entity_id,
@@ -2364,14 +2363,14 @@ async def sun_up(self) -> bool:
         """Determines if the sun is currently up.
 
         Returns:
-             bool: ``True`` if the sun is up, ``False`` otherwise.
+            bool: ``True`` if the sun is up, ``False`` otherwise.
 
         Examples:
             >>> if self.sun_up():
-            >>>    #do something
+            >>>    # do something
 
         """
-        return await self.AD.sched.sun_up()
+        return self.AD.sched.sun_up()
 
     @utils.sync_decorator
     async def sun_down(self) -> bool:
@@ -2382,10 +2381,10 @@ async def sun_down(self) -> bool:
 
         Examples:
             >>> if self.sun_down():
-            >>>    #do something
+            >>>    # do something
 
         """
-        return await self.AD.sched.sun_down()
+        return self.AD.sched.sun_down()
 
     @utils.sync_decorator
     async def parse_time(
@@ -2442,7 +2441,7 @@ async def parse_time(
             05:33:17
 
         """
-        return await self.AD.sched.parse_time(
+        return self.AD.sched.parse_time(
             time_str=time_str,
             aware=aware,
             today=today,
@@ -2506,7 +2505,7 @@ async def parse_datetime(
             >>> self.parse_datetime("sunrise + 01:00:00")
             2019-08-16 06:33:17
         """
-        return await self.AD.sched.parse_datetime(
+        return self.AD.sched.parse_datetime(
             input_=time_str,
             aware=aware,
             today=today,
@@ -2522,8 +2521,7 @@ async def get_now(self, aware: bool = True) -> dt.datetime:
             2019-08-16 21:17:41.098813-04:00
 
         """
-        now = await self.AD.sched.get_now()
-        return now.astimezone(self.AD.tz) if aware else self.AD.sched.make_naive(now)
+        return self.AD.sched.get_now_sync(_tz=None if aware else False)
 
     @utils.sync_decorator
     async def get_now_ts(self, aware: bool = False) -> float:
@@ -2578,7 +2576,7 @@ async def now_is_between(
             >>>     #do something
 
         """
-        return await self.AD.sched.now_is_between(start_time=start_time, end_time=end_time, now=now)
+        return self.AD.sched.now_is_between(start_time=start_time, end_time=end_time, now=now)
 
     @utils.sync_decorator
     async def sunrise(self, aware: bool = False, today: bool = False, days_offset: int = 0) -> dt.datetime:
@@ -2600,7 +2598,7 @@ async def sunrise(self, aware: bool = False, today: bool = False, days_offset: i
             2023-02-01 07:12:20.272403
 
         """
-        return await self.AD.sched.sunrise(aware, today, days_offset)
+        return self.AD.sched.sunrise(aware, today, days_offset)
 
     @utils.sync_decorator
     async def sunset(self, aware: bool = False, today: bool = False, days_offset: int = 0) -> dt.datetime:
@@ -2622,7 +2620,7 @@ async def sunset(self, aware: bool = False, today: bool = False, days_offset: in
             2023-02-02 18:09:46.252314
 
         """
-        return await self.AD.sched.sunset(aware, today, days_offset)
+        return self.AD.sched.sunset(aware, today, days_offset)
 
     @utils.sync_decorator
     async def datetime(self, aware: bool = False) -> dt.datetime:
@@ -2639,7 +2637,7 @@ async def datetime(self, aware: bool = False) -> dt.datetime:
             2019-08-15 20:15:55.549379
 
         """
-        return await self.get_now(aware=aware)
+        return self.get_now(aware=aware)
 
     @utils.sync_decorator
     async def time(self) -> dt.time:
@@ -2653,7 +2651,7 @@ async def time(self) -> dt.time:
             20:15:31.295751
 
         """
-        return (await self.get_now(aware=True)).time()
+        return self.get_now(aware=True).time()
 
     @utils.sync_decorator
     async def date(self) -> dt.date:
@@ -2667,11 +2665,11 @@ async def date(self) -> dt.date:
             2019-08-15
 
         """
-        return (await self.get_now(aware=True)).date()
+        return self.get_now(aware=True).date()
 
-    def get_timezone(self) -> str:
+    def get_timezone(self) -> str | None:
         """Returns the current time zone."""
-        return self.AD.time_zone
+        return self.AD.time_zone.zone
 
     #
     # Scheduler
@@ -2967,7 +2965,7 @@ async def run_at(
                 _, offset = resolve_time_str(start_str, now=now, location=self.AD.sched.location)
                 func = functools.partial(func, *args, repeat=True, offset=offset)
             case _:
-                start = await self.AD.sched.parse_datetime(start, aware=True)
+                start = self.AD.sched.parse_datetime(start, aware=True)
                 func = functools.partial(
                     self.AD.sched.insert_schedule,
                     name=self.name,
@@ -3371,7 +3369,7 @@ async def run_at_sunset(
             >>> self.run_at_sunset(self.sun, random_start = -60*60, random_end = 30*60)
 
         """
-        sunset = await self.AD.sched.next_sunset()
+        sunset = self.AD.sched.next_sunset()
         td = utils.parse_timedelta(offset)
         self.logger.debug(f"Registering run_at_sunset at {sunset + td} with {args}, {kwargs}")
         return await self.AD.sched.insert_schedule(
@@ -3444,7 +3442,7 @@ async def run_at_sunrise(
             >>> self.run_at_sunrise(self.sun, random_start = -60*60, random_end = 30*60)
 
         """
-        sunrise = await self.AD.sched.next_sunrise()
+        sunrise = self.AD.sched.next_sunrise()
         td = utils.parse_timedelta(offset)
         self.logger.debug(f"Registering run_at_sunrise at {sunrise + td} with {args}, {kwargs}")
         return await self.AD.sched.insert_schedule(

appdaemon/admin_loop.py

@@ -29,6 +29,6 @@ async def loop(self):
                 and self.AD.sched is not None
             ):  # fmt: skip
                 await self.AD.threading.get_callback_update()
-                await self.AD.threading.get_q_update()
+                await self.AD.threading.update_queue_sizes()
 
             await self.AD.utility.sleep(self.AD.admin_delay, timeout_ok=True)

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")
@@ -213,7 +212,7 @@ async def get_state(self, name: str, **kwargs):
         else:
             entity_id = name
 
-        return await self.AD.state.get_state("_app_management", "admin", entity_id, **kwargs)
+        return self.AD.state.get_state("_app_management", "admin", entity_id, **kwargs)
 
     async def init_admin_entities(self):
         for app_name, cfg in self.app_config.root.items():
@@ -237,7 +236,7 @@ async def add_entity(self, name: str, state, attributes):
         else:
             entity_id = name
 
-        await self.AD.state.add_entity("admin", entity_id, state, attributes)
+        self.AD.state.add_entity("admin", entity_id, state, attributes)
 
     async def remove_entity(self, name: str):
         await self.AD.state.remove_entity("admin", f"app.{name}")
@@ -291,12 +290,13 @@ def get_app(self, name: str):
         if obj := self.objects.get(name):
             return obj.object
 
-    def get_app_info(self, name: str):
+    def get_managed_object(self, name: str) -> ManagedObject | None:
         return self.objects.get(name)
 
-    def get_app_instance(self, name: str, id):
-        if (obj := self.objects.get(name)) and obj.id == id:
-            return obj.object
+    def get_app_instance(self, name: str, id: str) -> Any | None:
+        match self.get_managed_object(name):
+            case ManagedObject(object=obj, id=_id) if _id == id:
+                return obj
 
     def get_app_pin(self, name: str) -> bool:
         return self.objects[name].pin_app
@@ -1556,3 +1556,27 @@ async def manage_services(
                 return result
             case _:
                 self.logger.warning("Invalid app service call '%s' with app '%s' from  app %s.", service, app, __name)
+                self.logger.warning("Invalid app service call '%s' with app '%s' from  app %s.", service, app, __name)
+                self.logger.warning("Invalid app service call '%s' with app '%s' from  app %s.", service, app, __name)
+                self.logger.warning("Invalid app service call '%s' with app '%s' from  app %s.", service, app, __name)
+                self.logger.warning("Invalid app service call '%s' with app '%s' from  app %s.", service, app, __name)
+                self.logger.warning("Invalid app service call '%s' with app '%s' from  app %s.", service, app, __name)
+                self.logger.warning("Invalid app service call '%s' with app '%s' from  app %s.", service, app, __name)
+                self.logger.warning("Invalid app service call '%s' with app '%s' from  app %s.", service, app, __name)
+                self.logger.warning("Invalid app service call '%s' with app '%s' from  app %s.", service, app, __name)
+                self.logger.warning("Invalid app service call '%s' with app '%s' from  app %s.", service, app, __name)
+                self.logger.warning("Invalid app service call '%s' with app '%s' from  app %s.", service, app, __name)
+                self.logger.warning("Invalid app service call '%s' with app '%s' from  app %s.", service, app, __name)
+                self.logger.warning("Invalid app service call '%s' with app '%s' from  app %s.", service, app, __name)
+                self.logger.warning("Invalid app service call '%s' with app '%s' from  app %s.", service, app, __name)
+                self.logger.warning("Invalid app service call '%s' with app '%s' from  app %s.", service, app, __name)
+                self.logger.warning("Invalid app service call '%s' with app '%s' from  app %s.", service, app, __name)
+                self.logger.warning("Invalid app service call '%s' with app '%s' from  app %s.", service, app, __name)
+                self.logger.warning("Invalid app service call '%s' with app '%s' from  app %s.", service, app, __name)
+                self.logger.warning("Invalid app service call '%s' with app '%s' from  app %s.", service, app, __name)
+                self.logger.warning("Invalid app service call '%s' with app '%s' from  app %s.", service, app, __name)
+                self.logger.warning("Invalid app service call '%s' with app '%s' from  app %s.", service, app, __name)
+                self.logger.warning("Invalid app service call '%s' with app '%s' from  app %s.", service, app, __name)
+                self.logger.warning("Invalid app service call '%s' with app '%s' from  app %s.", service, app, __name)
+                self.logger.warning("Invalid app service call '%s' with app '%s' from  app %s.", service, app, __name)
+                self.logger.warning("Invalid app service call '%s' with app '%s' from  app %s.", service, app, __name)

appdaemon/appdaemon.py

@@ -23,7 +23,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
@@ -373,11 +372,11 @@ def use_stream(self):
         return self.config.use_stream
 
     @property
-    def write_toml(self):
+    def write_toml(self) -> bool:
         return self.config.write_toml
 
     @property
-    def utility_delay(self):
+    def utility_delay(self) -> int:
         return self.config.utility_delay
 
     def start(self) -> None: