docs: def _processArgs(self, entry, *_args, **_kwargs):
          """ Given an entry, positional and keyword arguments, figure out what
          the query-string options, payload and api arguments are.
          """
  
          # We need the args to be a list so we can mutate them
          args = list(_args)
          kwargs = copy.deepcopy(_kwargs)
  
          reqArgs = entry['args']
          routeParams = {}
  
          query = {}
          payload = None
          kwApiArgs = {}
  
          paginationHandler = None
          paginationLimit = None
  
          # There are three formats for calling methods:
          #   1. method(v1, v1, payload)
          #   2. method(payload, k1=v1, k2=v2)
          #   3. method(payload=payload, query=query, params={k1: v1, k2: v2})
          if len(kwargs) == 0:
              if 'input' in entry and len(args) == len(reqArgs) + 1:
                  payload = args.pop()
              if len(args) != len(reqArgs):
                  log.debug(args)
                  log.debug(reqArgs)
                  raise exceptions.TaskclusterFailure('Incorrect number of positional arguments')
              log.debug('Using method(v1, v2, payload) calling convention')
          else:
              # We're considering kwargs which are the api route parameters to be
              # called 'flat' because they're top level keys.  We're special
              # casing calls which have only api-arg kwargs and possibly a payload
              # value and handling them directly.
              isFlatKwargs = True
              if len(kwargs) == len(reqArgs):
                  for arg in reqArgs:
                      if not kwargs.get(arg, False):
                          isFlatKwargs = False
                          break
                  if 'input' in entry and len(args) != 1:
                      isFlatKwargs = False
                  if 'input' not in entry and len(args) != 0:
                      isFlatKwargs = False
                  else:
                      pass  # We're using payload=, query= and param=
              else:
                  isFlatKwargs = False
  
              # Now we're going to handle the two types of kwargs.  The first is
              # 'flat' ones, which are where the api params
              if isFlatKwargs:
                  if 'input' in entry:
                      payload = args.pop()
                  kwApiArgs = kwargs
                  log.debug('Using method(payload, k1=v1, k2=v2) calling convention')
                  warnings.warn(
                      "The method(payload, k1=v1, k2=v2) calling convention will soon be deprecated",
                      PendingDeprecationWarning
                  )
              else:
                  kwApiArgs = kwargs.get('params', {})
                  payload = kwargs.get('payload', None)
                  query = kwargs.get('query', {})
                  paginationHandler = kwargs.get('paginationHandler', None)
                  paginationLimit = kwargs.get('paginationLimit', None)
                  log.debug('Using method(payload=payload, query=query, params={k1: v1, k2: v2}) calling convention')
  
          if 'input' in entry and isinstance(payload, type(None)):
              raise exceptions.TaskclusterFailure('Payload is required')
  
          # These all need to be rendered down to a string, let's just check that
          # they are up front and fail fast
          for arg in args:
              if not isinstance(arg, six.string_types) and not isinstance(arg, int):
                  raise exceptions.TaskclusterFailure(
                      'Positional arg "%s" to %s is not a string or int' % (arg, entry['name']))
  
          for name, arg in six.iteritems(kwApiArgs):
              if not isinstance(arg, six.string_types) and not isinstance(arg, int):
                  raise exceptions.TaskclusterFailure(
                      'KW arg "%s: %s" to %s is not a string or int' % (name, arg, entry['name']))
  
          if len(args) > 0 and len(kwApiArgs) > 0:
              raise exceptions.TaskclusterFailure('Specify either positional or key word arguments')
  
          # We know for sure that if we don't give enough arguments that the call
          # should fail.  We don't yet know if we should fail because of two many
          # arguments because we might be overwriting positional ones with kw ones
          if len(reqArgs) > len(args) + len(kwApiArgs):
              raise exceptions.TaskclusterFailure(
                  '%s takes %d args, only %d were given' % (
                      entry['name'], len(reqArgs), len(args) + len(kwApiArgs)))
  
          # We also need to error out when we have more positional args than required
          # because we'll need to go through the lists of provided and required args
          # at the same time.  Not disqualifying early means we'll get IndexErrors if
          # there are more positional arguments than required
          if len(args) > len(reqArgs):
              raise exceptions.TaskclusterFailure('%s called with too many positional args',
                                                  entry['name'])
  
          i = 0
          for arg in args:
              log.debug('Found a positional argument: %s', arg)
              routeParams[reqArgs[i]] = arg
              i += 1
  
          log.debug('After processing positional arguments, we have: %s', routeParams)
  
          routeParams.update(kwApiArgs)
  
          log.debug('After keyword arguments, we have: %s', routeParams)
  
          if len(reqArgs) != len(routeParams):
              errMsg = '%s takes %s args, %s given' % (
                  entry['name'],
                  ','.join(reqArgs),
                  routeParams.keys())
              log.error(errMsg)
              raise exceptions.TaskclusterFailure(errMsg)
  
          for reqArg in reqArgs:
              if reqArg not in routeParams:
                  errMsg = '%s requires a "%s" argument which was not provided' % (
                      entry['name'], reqArg)
                  log.error(errMsg)
                  raise exceptions.TaskclusterFailure(errMsg)
  
          return routeParams, payload, query, paginationHandler, paginationLimit