Merge pull request CloudBotIRC#193 from linuxdaemon/gonzobot+clean-up-func-launches

Refactor hook launching system

Author: edwardslabs

cloudbot/event.py

@@ -372,6 +372,12 @@ def is_nick_valid(self, nick):
         """
         return self.conn.is_nick_valid(nick)
 
+    def __getitem__(self, item):
+        try:
+            return getattr(self, item)
+        except AttributeError:
+            raise KeyError(item)
+
     if sys.version_info < (3, 7, 0):
         # noinspection PyCompatibility
         @asyncio.coroutine

cloudbot/plugin.py

@@ -18,6 +18,7 @@
 from cloudbot.event import Event, PostHookEvent
 from cloudbot.hook import Priority, Action
 from cloudbot.util import database, async_util
+from cloudbot.util.func_utils import call_with_args
 
 logger = logging.getLogger("cloudbot")
 
@@ -411,39 +412,15 @@ def _log_hook(self, hook):
             logger.info("Loaded {}".format(hook))
             logger.debug("Loaded {}".format(repr(hook)))
 
-    def _prepare_parameters(self, hook, event):
-        """
-        Prepares arguments for the given hook
-
-        :type hook: cloudbot.plugin.Hook
-        :type event: cloudbot.event.Event
-        :rtype: list
-        """
-        parameters = []
-        for required_arg in hook.required_args:
-            if hasattr(event, required_arg):
-                value = getattr(event, required_arg)
-                parameters.append(value)
-            else:
-                logger.error("Plugin {} asked for invalid argument '{}', cancelling execution!"
-                             .format(hook.description, required_arg))
-                logger.debug("Valid arguments are: {} ({})".format(dir(event), event))
-                return None
-        return parameters
-
     def _execute_hook_threaded(self, hook, event):
         """
         :type hook: Hook
         :type event: cloudbot.event.Event
         """
         event.prepare_threaded()
 
-        parameters = self._prepare_parameters(hook, event)
-        if parameters is None:
-            return None
-
         try:
-            return hook.function(*parameters)
+            return call_with_args(hook.function, event)
         finally:
             event.close_threaded()
 
@@ -455,12 +432,8 @@ def _execute_hook_sync(self, hook, event):
         """
         yield from event.prepare()
 
-        parameters = self._prepare_parameters(hook, event)
-        if parameters is None:
-            return None
-
         try:
-            return (yield from hook.function(*parameters))
+            return (yield from call_with_args(hook.function, event))
         finally:
             yield from event.close()
 

cloudbot/util/async_util.py

@@ -3,10 +3,11 @@
 """
 
 import asyncio
-
 import sys
 from functools import partial
 
+from cloudbot.util.func_utils import call_with_args
+
 
 def wrap_future(fut, *, loop=None):
     """
@@ -33,6 +34,19 @@ def run_func(loop, func, *args, **kwargs):
         return (yield from loop.run_in_executor(None, part))
 
 
+@asyncio.coroutine
+def run_func_with_args(loop, func, arg_data, executor=None):
+    if asyncio.iscoroutine(func):
+        raise TypeError('A coroutine function or a normal, non-async callable are required')
+
+    if asyncio.iscoroutinefunction(func):
+        coro = call_with_args(func, arg_data)
+    else:
+        coro = loop.run_in_executor(executor, call_with_args, func, arg_data)
+
+    return (yield from coro)
+
+
 def run_coroutine_threadsafe(coro, loop):
     """
     Runs a coroutine in a threadsafe manner

cloudbot/util/func_utils.py

@@ -0,0 +1,19 @@
+import inspect
+
+
+class ParameterError(Exception):
+    def __init__(self, name, valid_args):
+        self.__init__(name, list(valid_args))
+
+    def __str__(self):
+        return "'{}' is not a valid parameter, valid parameters are: {}".format(self.args[0], self.args[1])
+
+
+def call_with_args(func, arg_data):
+    sig = inspect.signature(func)
+    try:
+        args = [arg_data[key] for key in sig.parameters.keys() if not key.startswith('_')]
+    except KeyError as e:
+        raise ParameterError(e.args[0], arg_data.keys()) from e
+
+    return func(*args)

plugins/core/cap.py

@@ -1,5 +1,5 @@
 import asyncio
-import inspect
+from collections import ChainMap
 from functools import partial
 
 from cloudbot import hook
@@ -56,24 +56,12 @@ def _decorate(func):
 def _launch_handler(subcmd, event, **kwargs):
     subcmd = subcmd.upper()
     kwargs["subcmd"] = subcmd
-    handler = HANDLERS.get(subcmd)
-    if handler:
-        sig = inspect.signature(handler)
-        args = []
-
-        for arg in sig.parameters.keys():
-            if arg in kwargs:
-                args.append(kwargs[arg])
-            else:
-                try:
-                    value = getattr(event, arg)
-                except AttributeError:
-                    event.logger.warning("CAP subcommand handler requested unknown argument: %s", arg)
-                    return
-                else:
-                    args.append(value)
-
-        yield from async_util.run_func(event.loop, handler, *args)
+    try:
+        handler = HANDLERS[subcmd]
+    except LookupError:
+        return
+
+    yield from async_util.run_func_with_args(event.loop, handler, ChainMap(event, kwargs))
 
 
 @_subcmd_handler("LS")