src/mdis/dispatcher.py

   1 __all__ = [
   2     "Dispatcher",
   3     "DispatcherMeta",
   4     "Hook",
   5 ]
   6
   7 import collections
   8 import functools
   9 import inspect
  10 import types
  11
  12
  13 class Hook(object):
  14     def __init__(self, *typeids):
  15         for typeid in typeids:
  16             if not callable(typeid):
  17                 raise ValueError(typeid)
  18         self.__typeids = typeids
  19         return super().__init__()
  20
  21     def __iter__(self):
  22         yield from self.__typeids
  23
  24     def __repr__(self):
  25         names = []
  26         for typeid in self.__typeids:
  27             name = typeid.__qualname__
  28             module = typeid.__module__
  29             if module not in ("builtins",):
  30                 name = f"{module}.{name}"
  31             names.append(name)
  32         return f"<{', '.join(names)}>"
  33
  34     def __call__(self, call):
  35         class ConcreteHook(Hook):
  36             def __call__(self, dispatcher, node, *args, **kwargs):
  37                 # We do not force specific arguments other than node.
  38                 # API users can introduce additional *args and **kwargs.
  39                 # However, in case they choose not to, this is fine too.
  40                 parameters = tuple(inspect.signature(call).parameters.values())
  41                 if len(parameters) < 2:
  42                     raise TypeError(f"{call.__name__}: missing required arguments")
  43                 if parameters[0].kind != inspect.Parameter.POSITIONAL_OR_KEYWORD:
  44                     raise TypeError(f"{call.__name__}: incorrect self argument")
  45                 if parameters[1].kind != inspect.Parameter.POSITIONAL_OR_KEYWORD:
  46                     raise TypeError(f"{call.__name__}: incorrect node argument")
  47                 args_present = False
  48                 kwargs_present = False
  49                 for parameter in parameters:
  50                     positionals = (
  51                         inspect.Parameter.POSITIONAL_OR_KEYWORD,
  52                         inspect.Parameter.VAR_POSITIONAL,
  53                     )
  54                     keywords = (
  55                         inspect.Parameter.POSITIONAL_OR_KEYWORD,
  56                         inspect.Parameter.VAR_KEYWORD,
  57                         inspect.Parameter.KEYWORD_ONLY,
  58                     )
  59                     if parameter.kind in positionals:
  60                         args_present = True
  61                     elif parameter.kind in keywords:
  62                         kwargs_present = True
  63                 if args_present and kwargs_present:
  64                     return call(dispatcher, node, *args, **kwargs)
  65                 elif args_present:
  66                     return call(dispatcher, node, *args)
  67                 elif kwargs_present:
  68                     return call(dispatcher, node, **kwargs)
  69                 else:
  70                     return call(dispatcher, node)
  71
  72         return ConcreteHook(*tuple(self))
  73
  74
  75 class DispatcherMeta(type):
  76     __hooks__ = {}
  77
  78     def __new__(metacls, name, bases, ns):
  79         hooks = {}
  80         ishook = lambda member: isinstance(member, Hook)
  81
  82         for basecls in reversed(bases):
  83             members = inspect.getmembers(basecls, predicate=ishook)
  84             for (_, hook) in members:
  85                 hooks.update(dict.fromkeys(hook, hook))
  86
  87         conflicts = collections.defaultdict(list)
  88         for (key, value) in tuple(ns.items()):
  89             if not ishook(value):
  90                 continue
  91             hook = value
  92             for typeid in hook:
  93                 hooks[typeid] = hook
  94                 conflicts[typeid].append(key)
  95             ns[key] = hook
  96
  97         for (typeid, keys) in conflicts.items():
  98             if len(keys) > 1:
  99                 raise ValueError(f"dispatch conflict: {keys!r}")
 100
 101         ns["__hooks__"] = types.MappingProxyType(hooks)
 102
 103         return super().__new__(metacls, name, bases, ns)
 104
 105     @functools.lru_cache(maxsize=None)
 106     def dispatch(cls, typeid=object):
 107         hook = cls.__hooks__.get(typeid)
 108         if hook is not None:
 109             return hook
 110         for (checker, hook) in cls.__hooks__.items():
 111             if not isinstance(checker, type) and checker(typeid):
 112                 return hook
 113         return None
 114
 115
 116 class Dispatcher(metaclass=DispatcherMeta):
 117     def __call__(self, node, *args, **kwargs):
 118         for typeid in node.__class__.__mro__:
 119             hook = self.__class__.dispatch(typeid=typeid)
 120             if hook is not None:
 121                 break
 122         if hook is None:
 123             hook = self.__class__.dispatch()
 124         return hook(self, node, *args, **kwargs)
 125
 126     @Hook(object)
 127     def dispatch_object(self, node):
 128         raise NotImplementedError()