docs: def args_to_inject(self, function, bindings, owner_key):
          """Inject arguments into a function.
  
          :param function: The function.
          :param bindings: Map of argument name to binding key to inject.
          :param owner_key: A key uniquely identifying the *scope* of this function.
              For a method this will be the owning class.
          :returns: Dictionary of resolved arguments.
          """
          dependencies = {}
  
          key = (owner_key, function, tuple(sorted(bindings.items())))
  
          def repr_key(k):
              owner_key, function, bindings = k
              return '%s.%s(injecting %s)' % (tuple(map(_describe, k[:2])) + (dict(k[2]),))
  
          log.debug('%sProviding %r for %r', self._log_prefix, bindings, function)
  
          if key in self._stack:
              raise CircularDependency(
                  'circular dependency detected: %s -> %s'
                  % (' -> '.join(map(repr_key, self._stack)), repr_key(key))
              )
  
          self._stack += (key,)
          try:
              for arg, key in bindings.items():
                  try:
                      instance = self.get(key.interface)
                  except UnsatisfiedRequirement as e:
                      if not e.args[0]:
                          e = UnsatisfiedRequirement(owner_key, e.args[1])
                      raise e
                  dependencies[arg] = instance
          finally:
              self._stack = tuple(self._stack[:-1])
  
          return dependencies