binding of class instance methods to ast context done after instance creation

Author: craigbarratt

.gitignore

@@ -2,6 +2,7 @@ __pycache__
 icon
 venv
 hass-custom-pyscript.zip
+docs/_build
 .coverage
 .vscode
 .*.swp

custom_components/pyscript/eval.py

@@ -188,6 +188,10 @@ def __getattr__(self, attr):
             raise NameError(f"name '{self.name}' is not defined")
         return getattr(self.value, attr)
 
+    def __repr__(self):
+        """Generate string with address and value."""
+        return f"EvalLocalVar @{hex(id(self))} = {self.value if self.defined else 'undefined'}"
+
 
 class EvalName:
     """Identifier that hasn't yet been resolved."""
@@ -350,7 +354,7 @@ async def pyscript_service_handler(call):
                         func_args.update(call.data)
 
                         async def do_service_call(func, ast_ctx, data):
-                            await func.call(ast_ctx, [], call.data)
+                            await func.call(ast_ctx, **call.data)
                             if ast_ctx.get_exception_obj():
                                 ast_ctx.get_logger().error(ast_ctx.get_exception_long())
 
@@ -575,7 +579,7 @@ async def try_aeval(self, ast_ctx, arg):
             if ast_ctx.exception_long is None:
                 ast_ctx.exception_long = ast_ctx.format_exc(err, arg.lineno, arg.col_offset)
 
-    async def call(self, ast_ctx, args=None, kwargs=None):
+    async def call(self, ast_ctx, *args, **kwargs):
         """Call the function with the given context and arguments."""
         sym_table = {}
         if args is None:
@@ -668,6 +672,19 @@ def __del__(self):
         self.func.trigger_stop()
 
 
+class EvalFuncVarClassInst(EvalFuncVar):
+    """Class for a callable pyscript class instance function."""
+
+    def __init__(self, func, class_inst):
+        """Initialize instance with given EvalFunc function."""
+        super().__init__(func)
+        self.class_inst = class_inst
+
+    def call(self, ctx, *args, **kwargs):
+        """Call the EvalFunc function."""
+        return self.func.call(ctx, self.class_inst, *args, **kwargs)
+
+
 class AstEval:
     """Python interpreter AST object evaluator."""
 
@@ -858,19 +875,7 @@ async def ast_classdef(self, arg):
                 raise SyntaxError(f"{val.name()} statement outside loop")
         self.sym_table = self.sym_table_stack.pop()
 
-        for name, func in sym_table.items():
-            if not isinstance(func, EvalFuncVar):
-                continue
-
-            def class_func_factory(func):
-                async def class_func_wrapper(this_self, *args, **kwargs):
-                    method_args = [this_self, *args]
-                    return await func.call(self, method_args, kwargs)
-
-                return class_func_wrapper
-
-            sym_table[name] = class_func_factory(func.get_func())
-
+        sym_table["__init__evalfunc_wrap__"] = None
         if "__init__" in sym_table:
             sym_table["__init__evalfunc_wrap__"] = sym_table["__init__"]
             del sym_table["__init__"]
@@ -1017,7 +1022,7 @@ async def ast_with(self, arg, async_attr=""):
                 )
             for ctx in ctx_list:
                 if ctx["target"]:
-                    value = await self.call_func(ctx["enter"], enter_attr, [ctx["manager"]], {})
+                    value = await self.call_func(ctx["enter"], enter_attr, ctx["manager"])
                     await self.recurse_assign(ctx["target"], value)
             for arg1 in arg.body:
                 val = await self.aeval(arg1)
@@ -1027,14 +1032,14 @@ async def ast_with(self, arg, async_attr=""):
             hit_except = True
             exit_ok = True
             for ctx in reversed(ctx_list):
-                ret = await self.call_func(ctx["exit"], exit_attr, [ctx["manager"], *sys.exc_info()], {})
+                ret = await self.call_func(ctx["exit"], exit_attr, ctx["manager"], *sys.exc_info())
                 exit_ok = exit_ok and ret
             if not exit_ok:
                 raise
         finally:
             if not hit_except:
                 for ctx in reversed(ctx_list):
-                    await self.call_func(ctx["exit"], exit_attr, [ctx["manager"], None, None, None], {})
+                    await self.call_func(ctx["exit"], exit_attr, ctx["manager"], None, None, None)
         return val
 
     async def ast_asyncwith(self, arg):
@@ -1590,19 +1595,24 @@ async def ast_call(self, arg):
             func_name = func.get_name()
             func = func.get()
         _LOGGER.debug("%s: calling %s(%s, %s)", self.name, func_name, arg_str, kwargs)
-        return await self.call_func(func, func_name, args, kwargs)
+        return await self.call_func(func, func_name, *args, **kwargs)
 
-    async def call_func(self, func, func_name, args, kwargs):
+    async def call_func(self, func, func_name, *args, **kwargs):
         """Call a function with the given arguments."""
         if isinstance(func, EvalFuncVar):
-            return await func.get_func().call(self, args, kwargs)
+            return await func.call(self, *args, **kwargs)
         if inspect.isclass(func) and hasattr(func, "__init__evalfunc_wrap__"):
-            #
-            # since our __init__ function is async, create the class instance
-            # without arguments and then call the async __init__evalfunc_wrap__
-            #
             inst = func()
-            await inst.__init__evalfunc_wrap__(*args, **kwargs)
+            for name in inst.__dir__():
+                value = getattr(inst, name)
+                if type(value) is not EvalFuncVar:
+                    continue
+                setattr(inst, name, EvalFuncVarClassInst(value.get_func(), inst))
+            if getattr(func, "__init__evalfunc_wrap__") is not None:
+                #
+                # since our __init__ function is async, call the renamed one
+                #
+                await inst.__init__evalfunc_wrap__.call(self, *args, **kwargs)
             return inst
         if asyncio.iscoroutinefunction(func):
             return await func(*args, **kwargs)

custom_components/pyscript/trigger.py

@@ -534,10 +534,10 @@ async def trigger_watch(self):
 
         try:
 
-            async def do_func_call(func, ast_ctx, task_unique, kwargs=None):
+            async def do_func_call(func, ast_ctx, task_unique, **kwargs):
                 if task_unique and self.task_unique_func:
                     await self.task_unique_func(task_unique)
-                await func.call(ast_ctx, kwargs=kwargs)
+                await func.call(ast_ctx, **kwargs)
                 if ast_ctx.get_exception_obj():
                     ast_ctx.get_logger().error(ast_ctx.get_exception_long())
 
@@ -656,7 +656,7 @@ async def do_func_call(func, ast_ctx, task_unique, kwargs=None):
                     func_args,
                 )
                 Function.create_task(
-                    do_func_call(self.action, self.action_ast_ctx, self.task_unique, kwargs=func_args)
+                    do_func_call(self.action, self.action_ast_ctx, self.task_unique, **func_args)
                 )
 
         except asyncio.CancelledError:

pylintrc

@@ -52,7 +52,8 @@ disable=
   unused-argument,
   no-value-for-parameter,
   unsubscriptable-object,
-  wrong-import-order
+  wrong-import-order,
+  unidiomatic-typecheck
 enable=
   use-symbolic-message-instead