code: def callback(self, name, before=None, after=None):
          
          if isinstance(name, (list, tuple)):
              for name in name:
                  self.callback(name, before, after)
          else:
              if not isinstance(getattr(self.subclass, name), MethodSpectator):
                  raise ValueError("No method specator for '%s'" % name)
              if before is None and after is None:
                  raise ValueError("No pre or post '%s' callbacks were given" % name)
              elif before is not None and not callable(before):
                  raise ValueError("Expected a callable, not %r." % before)
              elif after is not None and not callable(after):
                  raise ValueError("Expected a callable, not %r." % after)
              elif before is None and after is None:
                  raise ValueError("No callbacks were given.")
              if name in self._callback_registry:
                  callback_list = self._callback_registry[name]
              else:
                  callback_list = []
                  self._callback_registry[name] = callback_list
              callback_list.append((before, after))
docs: Add a callback pair to this spectator.
  
          You can specify, with keywords, whether each callback should be triggered
          before, and/or or after a given method is called - hereafter refered to as
          "beforebacks" and "afterbacks" respectively.
  
          Parameters
          ----------
          name: str
              The name of the method to which callbacks should respond.
          before: None or callable
              A callable of the form ``before(obj, call)`` where ``obj`` is
              the instance which called a watched method, and ``call`` is a
              :class:`Data` containing the name of the called method, along with
              its positional and keyword arguments under the attributes "name"
              "args", and "kwargs" respectively.
          after: None or callable
              A callable of the form ``after(obj, answer)`` where ``obj` is
              the instance which alled a watched method, and ``answer`` is a
              :class:`Data` containing the name of the called method, along with
              the value it returned, and data ``before`` may have returned
              under the attributes "name", "value", and "before" respectively.