docs: def hook(self, function, dependencies=None):
          """Tries to load a hook
  
          Args:
              function (func): Function that will be called when the event is called
  
          Kwargs:
              dependencies (str): String or Iterable with modules whose hooks should be called before this one
  
          Raises:
              :class:TypeError
  
          Note that the dependencies are module-wide, that means that if
          `parent.foo` and `parent.bar` are both subscribed to `example` event
          and `child` enumerates `parent` as dependcy, **both** `foo` and `bar`
          must be called in order for the dependcy to get resolved.
          """
          if not isinstance(dependencies, (Iterable, type(None), str)):
              raise TypeError("Invalid list of dependencies provided!")
  
          # Tag the function with its dependencies
          if not hasattr(function, "__deps__"):
              function.__deps__ = dependencies
  
          # If a module is loaded before all its dependencies are loaded, put
          # it in _later list and don't load yet
          if self.isloaded(function.__deps__):
              self.append(function)
          else:
              self._later.append(function)
  
          # After each module load, retry to resolve dependencies
          for ext in self._later:
              if self.isloaded(ext.__deps__):
                  self._later.remove(ext)
                  self.hook(ext)