Get an array of params to use in an API request.
492885
public function getRequestData($sent = true)
    {
        if(!($this instanceof EntityInterface)){
            throw new \Exception(sprintf(
                '%s can only be used if the class implements %s',
                __TRAIT__,
                EntityInterface::class
            ));
        }

        if(!($this instanceof \JsonSerializable)){
            throw new \Exception(sprintf(
                '%s can only be used if the class implements %s',
                __TRAIT__,
                \JsonSerializable::class
            ));
        }

        if($sent && ($request = $this->getRequest())){
            //TODO, figure out what the request data actually was
        }

        return $this->jsonSerialize();
    }
430412
def _process_params(self, params):
        
        processed_params = {}
        for key, value in params.items():
            processed_params[key] = self._process_param_value(value)

        return processed_params
1063769
def _get_api_params(api_url=None,
                    api_version=None,
                    api_key=None):
    '''
    
    '''
    mandrill_cfg = __salt__['config.merge']('mandrill')
    if not mandrill_cfg:
        mandrill_cfg = {}
    return {
        'api_url': api_url or mandrill_cfg.get('api_url') or BASE_URL,  # optional
        'api_key': api_key or mandrill_cfg.get('key'),  # mandatory
        'api_version': api_version or mandrill_cfg.get('api_version') or DEFAULT_VERSION
    }
1148368
def gather_parameters(self, request, response, context, api_version=None, **input_parameters):
        """"""
        input_parameters.update(request.params)

        if self.parse_body and request.content_length:
            body = request.stream
            content_type, content_params = parse_content_type(request.content_type)
            body_formatter = body and self.inputs.get(content_type, self.api.http.input_format(content_type))
            if body_formatter:
                body = body_formatter(body, content_length=request.content_length, **content_params)
            if 'body' in self.all_parameters:
                input_parameters['body'] = body
            if isinstance(body, dict):
                input_parameters.update(body)
        elif 'body' in self.all_parameters:
            input_parameters['body'] = None

        if 'request' in self.all_parameters:
            input_parameters['request'] = request
        if 'response' in self.all_parameters:
            input_parameters['response'] = response
        if 'api_version' in self.all_parameters:
            input_parameters['api_version'] = api_version
        for parameter, directive in self.directives.items():
            arguments = (self.defaults[parameter], ) if parameter in self.defaults else ()
            input_parameters[parameter] = directive(*arguments, response=response, request=request,
                                                    api=self.api, api_version=api_version, context=context,
                                                    interface=self)
        return input_parameters
1197045
def getparams(self, param):
        

        return list(cparam for cparam in self.values() if cparam == param)
1068379
def request_params(additional_params)
      client_params.merge(additional_params).select { |_, v| !v.nil? }
    end
258304
def get_query_params(self):
        """"""
        params = self.request.query_params.copy()
        params.update(self.request.data)
        return params
32862
function request_params(params) {
  'use strict';
  var base_params, merged_params, key;

  // Omit defaults, to make smaller requests
  // output: 'JSON',
  // version: '2',
  // validation: 'HMACSHA1'  
  base_params = { apikey: global.monitis.apikey };
  merged_params = {};

  for (key in base_params) {
    merged_params[key] = base_params[key];
  }
  for (key in params) {
    merged_params[key] = params[key];
  }
  return merged_params;
}
563522
function decodeParams(cache, API_URL, params) {
  var obj = {}, v;
  for (var k in params) {
    if (!params.hasOwnProperty(k)) continue;
    obj[k] = decode(cache, API_URL, params[k]);
  }
  return obj;
}
324474
def array(self):
        
        url = "{}/{}".format(__endpoint__, self.type.RESOURCE)
        return RestClient.get(url, self.params)[self.type.RESOURCE]
602721
function getParams()
    {
        $params = array();
        foreach (get_object_vars($this) as $k => $v) {
            if ($k[0] == '_') {
                $params[substr($k, 1)] = $v;
            }
        }

        return $params;
    }
948502
protected function getArrayRequest(): array
    {
        if (null === $this->arrayRequest) {
            return ArrayHelper::fromObject($this->getRequest()->call->params ?? []);
        }

        return $this->arrayRequest;
    }
769110
public function params($requestParams): array
    {
        // apply type and default value for request params
        $params = [];
        foreach ($this->params as $param => $type) {
            if (isset($requestParams[$param])) {
                switch ($type) {
                    case 'bool':
                    case 'boolean':
                        $params[] = (bool)$requestParams[$param];
                        break;
                    case 'int':
                    case 'integer':
                        $params[] = (int)$requestParams[$param];
                        break;
                    case 'float':
                        $params[] = (float)$requestParams[$param];
                        break;
                    case 'string':
                        $params[] = (string)$requestParams[$param];
                        break;
                    case 'array':
                        $params[] = (array)$requestParams[$param];
                        break;
                    default:
                        $params[] = $requestParams[$param];
                        break;
                }
            } elseif (isset($this->values[$param])) {
                $params[] = $this->values[$param];
            } else {
                $params[] = null;
            }
        }
        return $params;
    }
664639
def params(self):
        
        if self._GETPOST is None:
            self._GETPOST = MultiDict(self.GET)
            self._GETPOST.update(dict(self.POST))
        return self._GETPOST
1147892
def _extract_params(request_dict, param_list, param_fallback=False):
        '''  '''

        if not param_list or not request_dict:
            return dict()

        query = dict()
        for param in param_list:
            # Retrieve all items in the form of {param: value} and
            # convert {param__key: value} into {param: {key: value}}
            for query_key, query_value in request_dict.items():
                if param == query_key:
                    query[param] = query_value
                else:
                    query_key_parts = query_key.split('__', 1)
                    if param == query_key_parts[0]:
                        query[param] = {query_key_parts[1]: query_value}

        # Convert special string "__null__" into Python None
        nullifier = lambda d: {k:(nullifier(v) if isinstance(v, dict) else # pylint: disable=used-before-assignment
                                  (None if v == '__null__' else v)) for k, v in d.items()}

        # When fallback is enabled and no parameter matched, assume query refers to first parameter
        if param_fallback and all([param_key not in query.keys() for param_key in param_list]):
            query = {param_list[0]: dict(request_dict)}

        # Return a dictionary with only the requested parameters
        return {k:v for k, v in nullifier(query).items() if k in param_list}
1111618
def get_api_params(self):
        
        result = self.params
        if type(result) != dict:
            raise ValueError(
                '{}.params should return dictionary'.format(
                    self.__class__.__name__
                )
            )
        return result
899000
def _extract_params(self):
        
        # Because in this endpoint we handle both GET
        # and POST request.
        query_dict = (self.request.POST if self.request.method == 'POST'
                      else self.request.GET)

        self.params['client_id'] = query_dict.get('client_id', '')
        self.params['redirect_uri'] = query_dict.get('redirect_uri', '')
        self.params['response_type'] = query_dict.get('response_type', '')
        self.params['scope'] = query_dict.get('scope', '').split()
        self.params['state'] = query_dict.get('state', '')
        self.params['nonce'] = query_dict.get('nonce', '')

        self.params['prompt'] = self._allowed_prompt_params.intersection(
            set(query_dict.get('prompt', '').split()))

        self.params['code_challenge'] = query_dict.get('code_challenge', '')
        self.params['code_challenge_method'] = query_dict.get('code_challenge_method', '')