<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
 def inject_positional_args(self, method):
 """Decorator for injecting positional arguments from the configuration. This decorator wraps the given method, so that any positional arguments are passed with corresponding values from the configuration. The name of the positional argument must match the configuration key. Keyword arguments are *NEVER* modified, even if their names match configuration keys. Avoid naming keyword args names that are also configuration keys to avoid confusion. Additional positional arguments may be used that do not appear in the configuration, but those arguments *MUST* be specified as keyword arguments upon invocation of the method. This is to avoid ambiguity in which positional arguments are getting which values. Args: method: The method to wrap. Returns: A wrapper that, when invoked, will call the wrapped method, passing in configuration values for positional arguments. """

    inspect = self._modules['inspect']
    argspec = inspect.getargspec(method)

    # Index in argspec.args of the first keyword argument.  This index is a
    # negative number if there are any kwargs, or 0 if there are no kwargs.
    keyword_arg_index = -1 * len(argspec.defaults or [])
    arg_names = argspec.args[:keyword_arg_index or None]
    kwarg_names = argspec.args[len(arg_names):]
    functools = self._modules['functools']  # pylint: disable=redefined-outer-name

    # Create the actual method wrapper, all we do is update kwargs.  Note we
    # don't pass any *args through because there can't be any - we've filled
    # them all in with values from the configuration.  Any positional args that
    # are missing from the configuration *must* be explicitly specified as
    # kwargs.
    @functools.wraps(method)
    def method_wrapper(**kwargs):
      """Wrapper that pulls values from openhtf.util.conf."""
      # Check for keyword args with names that are in the config so we can warn.
      for kwarg in kwarg_names:
        if kwarg in self:
          self._logger.warning('Keyword arg %s not set from configuration, but '
                               'is a configuration key', kwarg)

      # Set positional args from configuration values.
      final_kwargs = {name: self[name] for name in arg_names if name in self}

      for overridden in set(kwargs) & set(final_kwargs):
        self._logger.warning('Overriding configuration value for kwarg %s (%s) '
                             'with provided kwarg value: %s', overridden,
                             self[overridden], kwargs[overridden])

      final_kwargs.update(kwargs)
      if inspect.ismethod(method):
        name = '%s.%s' % (method.__self__.__class__.__name__, method.__name__)
      else:
        name = method.__name__
      self._logger.debug('Invoking %s with %s', name, final_kwargs)
      return method(**final_kwargs)

    # We have to check for a 'self' parameter explicitly because Python doesn't
    # pass it as a keyword arg, it passes it as the first positional arg.
    if argspec.args[0] == 'self':
      @functools.wraps(method)
      def self_wrapper(self, **kwargs):  # pylint: disable=invalid-name
        """Wrapper that pulls values from openhtf.util.conf."""
        kwargs['self'] = self
        return method_wrapper(**kwargs)
      return self_wrapper
    return method_wrapper