docs: def get_parameters(signature, transmute_attrs, arguments_to_ignore=None):
      """given a function, categorize which arguments should be passed by
      what types of parameters. The choices are:
  
      * query parameters: passed in as query parameters in the url
      * body parameters: retrieved from the request body (includes forms)
      * header parameters: retrieved from the request header
      * path parameters: retrieved from the uri path
  
      The categorization is performed for an argument "arg" by:
  
      1. examining the transmute parameters attached to the function (e.g.
      func.transmute_query_parameters), and checking if "arg" is mentioned. If so,
      it is added to the category.
  
      2. If the argument is available in the path, it will be added
      as a path parameter.
  
      3. If the method of the function is GET and only GET, then "arg" will be
      be added to the expected query parameters. Otherwise, "arg" will be added as
      a body parameter.
      """
      params = Parameters()
      used_keys = set(arguments_to_ignore or [])
      # examine what variables are categorized first.
      for key in ["query", "header", "path"]:
          param_set = getattr(params, key)
          explicit_parameters = getattr(transmute_attrs, key + "_parameters")
          used_keys |= load_parameters(
              param_set, explicit_parameters, signature, transmute_attrs
          )
  
      body_parameters = transmute_attrs.body_parameters
      if isinstance(body_parameters, str):
          name = body_parameters
          params.body = Param(
              argument_name=name,
              description=transmute_attrs.parameter_descriptions.get(name),
              arginfo=signature.get_argument(name),
          )
          used_keys.add(name)
      else:
          used_keys |= load_parameters(
              params.body, transmute_attrs.body_parameters, signature, transmute_attrs
          )
  
      # extract the parameters from the paths
      for name in _extract_path_parameters_from_paths(transmute_attrs.paths):
          params.path[name] = Param(
              argument_name=name,
              description=transmute_attrs.parameter_descriptions.get(name),
              arginfo=signature.get_argument(name),
          )
          used_keys.add(name)
  
      # check the method type, and decide if the parameters should be extracted
      # from query parameters or the body
      default_param_key = "query" if transmute_attrs.methods == set(["GET"]) else "body"
      default_params = getattr(params, default_param_key)
  
      # parse all positional params
      for arginfo in signature:
          if arginfo.name in used_keys:
              continue
          used_keys.add(arginfo.name)
          default_params[arginfo.name] = Param(
              arginfo.name,
              description=transmute_attrs.parameter_descriptions.get(arginfo.name),
              arginfo=arginfo,
          )
  
      return params