code: def validate_arguments(func, args, kwargs, drop_extra=True):
      
      parser = _parse_signature(func)
      args, kwargs, missing, extra, extra_positional = parser(args, kwargs)[:5]
      if missing:
          raise ArgumentValidationError(tuple(missing))
      elif (extra or extra_positional) and not drop_extra:
          raise ArgumentValidationError(None, extra, extra_positional)
      return tuple(args), kwargs
docs: Checks if the function accepts the arguments and keyword arguments.
      Returns a new ``(args, kwargs)`` tuple that can safely be passed to
      the function without causing a `TypeError` because the function signature
      is incompatible.  If `drop_extra` is set to `True` (which is the default)
      any extra positional or keyword arguments are dropped automatically.
  
      The exception raised provides three attributes:
  
      `missing`
          A set of argument names that the function expected but where
          missing.
  
      `extra`
          A dict of keyword arguments that the function can not handle but
          where provided.
  
      `extra_positional`
          A list of values that where given by positional argument but the
          function cannot accept.
  
      This can be useful for decorators that forward user submitted data to
      a view function::
  
          from werkzeug.utils import ArgumentValidationError, validate_arguments
  
          def sanitize(f):
              def proxy(request):
                  data = request.values.to_dict()
                  try:
                      args, kwargs = validate_arguments(f, (request,), data)
                  except ArgumentValidationError:
                      raise BadRequest('The browser failed to transmit all '
                                       'the data expected.')
                  return f(*args, **kwargs)
              return proxy
  
      :param func: the function the validation is performed against.
      :param args: a tuple of positional arguments.
      :param kwargs: a dict of keyword arguments.
      :param drop_extra: set to `False` if you don't want extra arguments
                         to be silently dropped.
      :return: tuple in the form ``(args, kwargs)``.