refactoring State, Event, Handler, TrigTime and GlobalContextMgr

Author: craigbarratt

custom_components/pyscript/__init__.py

@@ -41,12 +41,12 @@
 
 async def async_setup(hass, config):
     """Initialize the pyscript component."""
-    handler_func = Handler(hass)
-    event_func = Event(hass)
-    trig_time_func = TrigTime(hass, handler_func)
-    state_func = State(hass, handler_func)
-    state_func.register_functions()
-    global_ctx_mgr = GlobalContextMgr(handler_func)
+    Handler.init(hass)
+    Event.init(hass)
+    TrigTime.init(hass)
+    State.init(hass)
+    State.register_functions()
+    GlobalContextMgr.init()
 
     path = hass.config.path(FOLDER)
 
@@ -60,14 +60,7 @@ def check_isdir(path):
     hass.data.setdefault(DOMAIN, {})
     hass.data[DOMAIN]["allow_all_imports"] = config[DOMAIN].get(CONF_ALLOW_ALL_IMPORTS)
 
-    await compile_scripts(  # pylint: disable=unused-variable
-        hass,
-        event_func=event_func,
-        state_func=state_func,
-        handler_func=handler_func,
-        trig_time_func=trig_time_func,
-        global_ctx_mgr=global_ctx_mgr,
-    )
+    await compile_scripts(hass)
 
     _LOGGER.debug("adding reload handler")
 
@@ -78,25 +71,18 @@ async def reload_scripts_handler(call):
         )
 
         ctx_delete = {}
-        for global_ctx_name, global_ctx in global_ctx_mgr.items():
+        for global_ctx_name, global_ctx in GlobalContextMgr.items():
             if not global_ctx_name.startswith("file."):
                 continue
             await global_ctx.stop()
             global_ctx.set_auto_start(False)
             ctx_delete[global_ctx_name] = global_ctx
         for global_ctx_name, global_ctx in ctx_delete.items():
-            await global_ctx_mgr.delete(global_ctx_name)
-
-        await compile_scripts(
-            hass,
-            event_func=event_func,
-            state_func=state_func,
-            handler_func=handler_func,
-            trig_time_func=trig_time_func,
-            global_ctx_mgr=global_ctx_mgr,
-        )
+            await GlobalContextMgr.delete(global_ctx_name)
 
-        for global_ctx_name, global_ctx in global_ctx_mgr.items():
+        await compile_scripts(hass)
+
+        for global_ctx_name, global_ctx in GlobalContextMgr.items():
             if not global_ctx_name.startswith("file."):
                 continue
             await global_ctx.start()
@@ -107,29 +93,15 @@ async def jupyter_kernel_start(call):
         """Handle Jupyter kernel start call."""
         _LOGGER.debug("service call to jupyter_kernel_start: %s", call.data)
 
-        global_ctx_name = global_ctx_mgr.new_name("jupyter_")
-        global_ctx = GlobalContext(
-            global_ctx_name,
-            hass,
-            global_sym_table={},
-            state_func=state_func,
-            event_func=event_func,
-            handler_func=handler_func,
-            trig_time_func=trig_time_func,
-        )
+        global_ctx_name = GlobalContextMgr.new_name("jupyter_")
+        global_ctx = GlobalContext(global_ctx_name, hass, global_sym_table={})
         global_ctx.set_auto_start(True)
 
-        global_ctx_mgr.set(global_ctx_name, global_ctx)
+        GlobalContextMgr.set(global_ctx_name, global_ctx)
 
-        ast_ctx = AstEval(
-            global_ctx_name,
-            global_ctx=global_ctx,
-            state_func=state_func,
-            event_func=event_func,
-            handler_func=handler_func,
-        )
-        handler_func.install_ast_funcs(ast_ctx)
-        kernel = Kernel(call.data, ast_ctx, global_ctx_name, global_ctx_mgr)
+        ast_ctx = AstEval(global_ctx_name, global_ctx)
+        Handler.install_ast_funcs(ast_ctx)
+        kernel = Kernel(call.data, ast_ctx, global_ctx_name)
         await kernel.session_start()
         hass.states.async_set(call.data["state_var"], json.dumps(kernel.get_ports()))
 
@@ -158,20 +130,20 @@ async def state_changed(event):
             "value": new_val,
             "old_value": old_val,
         }
-        await state_func.update(new_vars, func_args)
+        await State.update(new_vars, func_args)
 
     async def start_triggers(event):
         _LOGGER.debug("adding state changed listener and starting triggers")
         hass.bus.async_listen(EVENT_STATE_CHANGED, state_changed)
-        for global_ctx_name, global_ctx in global_ctx_mgr.items():
+        for global_ctx_name, global_ctx in GlobalContextMgr.items():
             if not global_ctx_name.startswith("file."):
                 continue
             await global_ctx.start()
             global_ctx.set_auto_start(True)
 
     async def stop_triggers(event):
         _LOGGER.debug("stopping triggers")
-        for global_ctx_name, global_ctx in global_ctx_mgr.items():
+        for global_ctx_name, global_ctx in GlobalContextMgr.items():
             if not global_ctx_name.startswith("file."):
                 continue
             await global_ctx.stop()
@@ -183,14 +155,7 @@ async def stop_triggers(event):
 
 
 @bind_hass
-async def compile_scripts(
-    hass,
-    event_func=None,
-    state_func=None,
-    handler_func=None,
-    trig_time_func=None,
-    global_ctx_mgr=None,
-):
+async def compile_scripts(hass):
     """Compile all python scripts in FOLDER."""
 
     path = hass.config.path(FOLDER)
@@ -213,25 +178,11 @@ def read_file(path):
         source = await hass.async_add_executor_job(read_file, file)
 
         global_ctx_name = f"file.{name}"
-        global_ctx = GlobalContext(
-            global_ctx_name,
-            hass,
-            global_sym_table={},
-            state_func=state_func,
-            event_func=event_func,
-            handler_func=handler_func,
-            trig_time_func=trig_time_func,
-        )
+        global_ctx = GlobalContext(global_ctx_name, hass, global_sym_table={})
         global_ctx.set_auto_start(False)
 
-        ast_ctx = AstEval(
-            global_ctx_name,
-            global_ctx=global_ctx,
-            state_func=state_func,
-            event_func=event_func,
-            handler_func=handler_func,
-        )
-        handler_func.install_ast_funcs(ast_ctx)
+        ast_ctx = AstEval(global_ctx_name, global_ctx)
+        Handler.install_ast_funcs(ast_ctx)
 
         if not ast_ctx.parse(source, filename=file):
             exc = ast_ctx.get_exception_long()
@@ -242,4 +193,4 @@ def read_file(path):
         if exc is not None:
             ast_ctx.get_logger().error(exc)
             continue
-        global_ctx_mgr.set(global_ctx_name, global_ctx)
+        GlobalContextMgr.set(global_ctx_name, global_ctx)

custom_components/pyscript/eval.py

@@ -10,6 +10,8 @@
 import sys
 
 from .const import ALLOWED_IMPORTS, DOMAIN, LOGGER_PATH
+from .handler import Handler
+from .state import State
 
 _LOGGER = logging.getLogger(LOGGER_PATH + ".eval")
 
@@ -30,13 +32,7 @@ def ast_eval_exec_factory(ast_ctx, str_type):
     """Generate a function that executes eval() or exec() with given ast_ctx."""
 
     async def eval_func(arg_str, eval_globals=None, eval_locals=None):
-        eval_ast = AstEval(
-            ast_ctx.name,
-            global_ctx=ast_ctx.global_ctx,
-            state_func=ast_ctx.state,
-            event_func=ast_ctx.event,
-            handler_func=ast_ctx.handler,
-        )
+        eval_ast = AstEval(ast_ctx.name, ast_ctx.global_ctx)
         eval_ast.parse(arg_str, f"{str_type}()")
         if eval_ast.exception_obj:
             raise eval_ast.exception_obj  # pylint: disable=raising-bad-type
@@ -334,15 +330,7 @@ async def call(self, ast_ctx, args=None, kwargs=None):
 class AstEval:
     """Python interpreter AST object evaluator."""
 
-    def __init__(
-        self,
-        name,
-        global_ctx=None,
-        state_func=None,
-        event_func=None,
-        handler_func=None,
-        logger_name=None,
-    ):
+    def __init__(self, name, global_ctx, logger_name=None):
         """Initialize an interpreter execution context."""
         self.name = name
         self.str = None
@@ -359,9 +347,6 @@ def __init__(
         self.exception = None
         self.exception_obj = None
         self.exception_long = None
-        self.state = state_func
-        self.handler = handler_func
-        self.event = event_func
         self.lineno = 1
         self.col_offset = 0
         self.logger_handlers = set()
@@ -648,7 +633,7 @@ async def recurse_assign(self, lhs, val):
                     f"unknown lhs type {lhs} (got {var_name}) in assign"
                 )
             if var_name.find(".") >= 0:
-                self.state.set(var_name, val)
+                State.set(var_name, val)
                 return
             if self.curr_func and var_name in self.curr_func.global_names:
                 self.global_sym_table[var_name] = val
@@ -694,8 +679,8 @@ async def ast_augassign(self, arg):
                         break
                 else:
                     raise TypeError(f"can't find nonlocal '{var_name}' for assignment")
-            elif self.state.exist(var_name):
-                self.state.set(var_name, val)
+            elif State.exist(var_name):
+                State.set(var_name, val)
             else:
                 self.sym_table[var_name] = val
 
@@ -805,19 +790,15 @@ async def ast_name(self, arg):
                 and arg.id[0] != "_"
             ):
                 return getattr(builtins, arg.id)
-            if self.handler.get(arg.id):
-                return self.handler.get(arg.id)
+            if Handler.get(arg.id):
+                return Handler.get(arg.id)
             num_dots = arg.id.count(".")
             #
             # any single-dot name could be a state variable
             # a two-dot name for state.attr needs to exist
             #
-            if num_dots == 2:
-                _LOGGER.debug(
-                    "ast_name: arg = {arg.id}, exist = {self.state.exist(arg.id)}"
-                )
-            if num_dots == 1 or (num_dots == 2 and self.state.exist(arg.id)):
-                return self.state.get(arg.id)
+            if num_dots == 1 or (num_dots == 2 and State.exist(arg.id)):
+                return State.get(arg.id)
             #
             # Couldn't find it, so return just the name wrapped in EvalName to
             # distinguish from a string variable value.  This is to support

custom_components/pyscript/event.py

@@ -8,19 +8,24 @@
 
 
 class Event:
-    """Defined event functions."""
+    """Define event functions."""
 
-    def __init__(self, hass):
+    def __init__():
+        """Warn on Event instantiation."""
+        _LOGGER.error("Event class is not meant to be instantiated")
+
+    def init(hass):
         """Initialize Event."""
+        Event.hass = hass
 
-        self.hass = hass
+        Event.hass = hass
         #
         # notify message queues by event type
         #
-        self.notify = {}
-        self.notify_remove = {}
+        Event.notify = {}
+        Event.notify_remove = {}
 
-    async def event_listener(self, event):
+    async def event_listener(event):
         """Listen callback for given event which updates any notifications."""
 
         _LOGGER.debug("event_listener(%s)", event)
@@ -29,35 +34,35 @@ async def event_listener(self, event):
             "event_type": event.event_type,
         }
         func_args.update(event.data)
-        await self.update(event.event_type, func_args)
+        await Event.update(event.event_type, func_args)
 
-    def notify_add(self, event_type, queue):
+    def notify_add(event_type, queue):
         """Register to notify for events of given type to be sent to queue."""
 
-        if event_type not in self.notify:
-            self.notify[event_type] = set()
+        if event_type not in Event.notify:
+            Event.notify[event_type] = set()
             _LOGGER.debug("event.notify_add(%s) -> adding event listener", event_type)
-            self.notify_remove[event_type] = self.hass.bus.async_listen(
-                event_type, self.event_listener
+            Event.notify_remove[event_type] = Event.hass.bus.async_listen(
+                event_type, Event.event_listener
             )
-        self.notify[event_type].add(queue)
+        Event.notify[event_type].add(queue)
 
-    def notify_del(self, event_type, queue):
+    def notify_del(event_type, queue):
         """Unregister to notify for events of given type for given queue."""
 
-        if event_type not in self.notify or queue not in self.notify[event_type]:
+        if event_type not in Event.notify or queue not in Event.notify[event_type]:
             return
-        self.notify[event_type].discard(queue)
-        if len(self.notify[event_type]) == 0:
-            self.notify_remove[event_type]()
+        Event.notify[event_type].discard(queue)
+        if len(Event.notify[event_type]) == 0:
+            Event.notify_remove[event_type]()
             _LOGGER.debug("event.notify_del(%s) -> removing event listener", event_type)
-            del self.notify[event_type]
-            del self.notify_remove[event_type]
+            del Event.notify[event_type]
+            del Event.notify_remove[event_type]
 
-    async def update(self, event_type, func_args):
+    async def update(event_type, func_args):
         """Deliver all notifications for an event of the given type."""
 
         _LOGGER.debug("event.update(%s, %s, %s)", event_type, vars, func_args)
-        if event_type in self.notify:
-            for queue in self.notify[event_type]:
+        if event_type in Event.notify:
+            for queue in Event.notify[event_type]:
                 await queue.put(["event", func_args])