AppDaemon 4 Method for Dynamic App Reloading

app_reloader.py

import adbase as ad
import re


class AppReloader(ad.ADBase):

    def initialize(self):
        self.adbase = self.get_ad_api()
        self.adbase.listen_event(
            self.announce_dependency_event_cb,
            "app_reloader.dependency",
            namespace="appdaemon")
        self.adbase.listen_event(
            self.module_reloaded_event_cb,
            "app_reloader.module_reloaded",
            namespace="appdaemon")
        self.adbase.listen_log(
            self.module_reloaded_log_parser_cb,
            level="INFO",
            log="main_log")

        self._dep_apps = {}

    def announce_dependency_event_cb(self, event_name, data, kwargs):
        app = data['app']
        module = data['module']

        if module not in self._dep_apps:
            self._dep_apps[module] = []
        if app not in self._dep_apps[module]:
            self._dep_apps[module].append(app)

        self.adbase.log(
            "Dependency of App '{}' on Module '{}' registered".format(
                app, module))

    def module_reloaded_event_cb(self, event_name, data, kwargs):
        module = data['module']
        self.adbase.log("Module Reload Detected: {}".format(module))

        if module not in self._dep_apps:
            return

        to_restart = list(self._dep_apps[module])
        del self._dep_apps[module]
        for app in to_restart:
            if self.adbase.get_app(app) is not None:
                self.adbase.log(
                    "Restarting App '{}' due to Dependency '{}'".format(
                        app, module))
                self.adbase.restart_app(app)

    def module_reloaded_log_parser_cb(
            self,
            name,
            ts,
            level,
            log,
            message,
            kwargs):

        if name != 'AppDaemon':
            return

        if "Reloading Module:" not in message:
            return

        module_pattern = re.compile(
            "^Reloading Module: /(.*)/(?P<module_name>.*)[.]py$")
        m = module_pattern.search(message)
        if m is None:
            return

        module_name = m.group('module_name')
        self.adbase.fire_event(
            "app_reloader.module_reloaded",
            module=module_name,
            namespace="appdaemon")

apps.yaml

global_modules:
  - somemodule
  
app_reloader:
  module: app_reloader
  class: AppReloader
  priority: 1
  
my_app:
  module: some_app_module
  class: MyApp

some_app_module.py

import appdaemon.plugins.hass.hassapi as hass

import somemodule as something


class MyApp(hass.Hass):
  def initialize(self):
    self.register_dependency(something)
    
    self.log(something.any_thing_you_want())
    
  def register_dependency(self, module):
      module_name = module.__name__
      self.fire_event(
          'app_reloader.dependency',
          app=self.name,
          module=module_name,
          namespace="appdaemon")
    

somemodule.py

def any_thing_you_want():
  return "thing"