code: def resolve_hooks(self):
          
          mro = inspect.getmro(self)
  
          hooks = defaultdict(list)
  
          for attr_name in dir(self):
              # Need to look up the actual descriptor, not whatever might be
              # bound to the class. This needs to come from the __dict__ of the
              # declaring class.
              for parent in mro:
                  try:
                      attr = parent.__dict__[attr_name]
                  except KeyError:
                      continue
                  else:
                      break
              else:
                  # In case we didn't find the attribute and didn't break above.
                  # We should never hit this - it's just here for completeness
                  # to exclude the possibility of attr being undefined.
                  continue
  
              try:
                  hook_config = attr.__marshmallow_hook__
              except AttributeError:
                  pass
              else:
                  for key in iterkeys(hook_config):
                      # Use name here so we can get the bound method later, in
                      # case the processor was a descriptor or something.
                      hooks[key].append(attr_name)
  
          return hooks
docs: Add in the decorated processors
  
          By doing this after constructing the class, we let standard inheritance
          do all the hard work.