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                 return call(dispatcher, node, *args, **kwargs)
  38
  39         return ConcreteHook(*tuple(self))
  40
  41
  42 class DispatcherMeta(type):
  43     __hooks__ = {}
  44
  45     def __new__(metacls, name, bases, ns):
  46         hooks = {}
  47         ishook = lambda member: isinstance(member, Hook)
  48
  49         for basecls in reversed(bases):
  50             members = inspect.getmembers(basecls, predicate=ishook)
  51             for (_, hook) in members:
  52                 hooks.update(dict.fromkeys(hook, hook))
  53
  54         conflicts = collections.defaultdict(list)
  55         for (key, value) in tuple(ns.items()):
  56             if not ishook(value):
  57                 continue
  58             hook = value
  59             for typeid in hook:
  60                 hooks[typeid] = hook
  61                 conflicts[typeid].append(key)
  62             ns[key] = hook
  63
  64         for (typeid, keys) in conflicts.items():
  65             if len(keys) > 1:
  66                 raise ValueError(f"dispatch conflict: {keys!r}")
  67
  68         ns["__hooks__"] = types.MappingProxyType(hooks)
  69
  70         return super().__new__(metacls, name, bases, ns)
  71
  72     @functools.lru_cache(maxsize=None)
  73     def dispatch(cls, typeid=object):
  74         hook = cls.__hooks__.get(typeid)
  75         if hook is not None:
  76             return hook
  77         for (checker, hook) in cls.__hooks__.items():
  78             if not isinstance(checker, type) and checker(typeid):
  79                 return hook
  80         return None
  81
  82
  83 class Dispatcher(metaclass=DispatcherMeta):
  84     def __call__(self, node, *args, **kwargs):
  85         for typeid in node.__class__.__mro__:
  86             hook = self.__class__.dispatch(typeid=typeid)
  87             if hook is not None:
  88                 break
  89         if hook is None:
  90             hook = self.__class__.dispatch()
  91         return hook(self, node, *args, **kwargs)
  92
  93     @Hook(object)
  94     def dispatch_object(self, node, *args, **kwargs):
  95         raise NotImplementedError()