Return request parameters
554090
private function getParams($method, array $server, array $post) : array
    {
        // post data exists
        if ($method === 'post' && ! empty($post)) {
            return $post;
        }

        if (\in_array($method, ['post', 'put', 'patch', 'delete'], true)) {
            return $this->phpInput($server);
        }

        return $post;
    }
947025
def get(self, request, bot_id, id, format=None):
        
        return super(HeaderParameterList, self).get(request, bot_id, id, format)
1241431
def _request(self, function, params, method='POST', headers={}):
        """"""
        
        if method is 'POST':
            params = urllib.parse.urlencode(params)
            headers = { "Content-type": "application/x-www-form-urlencoded", "Accept": "text/plain" }
        
        path = '/%s/%s' % (self._version, function)
        
        self._conn.request(method, path, params, headers)
        return self._conn.getresponse()
982178
def query_params(*es_query_params):
    

    def _wrapper(func):
        @wraps(func)
        def _wrapped(*args, **kwargs):
            params = {}
            if "params" in kwargs:
                params = kwargs.pop("params").copy()
            for p in es_query_params + GLOBAL_PARAMS:
                if p in kwargs:
                    v = kwargs.pop(p)
                    if v is not None:
                        params[p] = _escape(v)

            # don't treat ignore and request_timeout as other params to avoid escaping
            for p in ("ignore", "request_timeout"):
                if p in kwargs:
                    params[p] = kwargs.pop(p)
            return func(*args, params=params, **kwargs)

        return _wrapped

    return _wrapper
692913
def getparams(self, result):
        """"""

        for key in self._cache:
            if self._cache[key][2] == result:
                args, kwargs, _ = self._cache[key]
                return args, kwargs

        else:
            raise ValueError('Result is not cached')
354323
async function fetchParams(conf) {
  await util.wait(100)  
  return { 
    Parameters: [ 
      {
        Name: "VARIABLE_A",
        Type: "String",
        Value: "value-a"
      },
      {
        Name: "VARIABLE_B",
        Type: "String",
        Value: "value-b"
      }
    ]
  }
}
841134
def get_params(self):
        
        return self.enabled, self.size, self.chunk_delay, self.start_delay
626260
def _req(self, method="get", verb=None, headers={}, params={}, data={}):
        
        url = self.BASE_URL.format(verb=verb)
        request_headers = {"content-type": "application/json"}
        request_params = {"api_key": self.API_KEY}
        request_headers.update(headers)
        request_params.update(params)
        return getattr(requests, method)(
            url, params=request_params, headers=request_headers, data=data
        )
83719
def build_base_parameters(request):
    """"""

    getParameters = {}
    postParameters = {}
    files = {}

    # Copy GET parameters, excluding ebuio_*
    for v in request.GET:
        if v[:6] != 'ebuio_':
            val = request.GET.getlist(v)

            if len(val) == 1:
                getParameters[v] = val[0]
            else:
                getParameters[v] = val

    # If using post, copy post parameters and files. Excluding ebuio_*
    if request.method == 'POST':
        for v in request.POST:
            if v[:6] != 'ebuio_':
                val = request.POST.getlist(v)

                if len(val) == 1:
                    postParameters[v] = val[0]
                else:
                    postParameters[v] = val

        for v in request.FILES:
            if v[:6] != 'ebuio_':
                files[v] = request.FILES[v]  # .chunks()

    return (getParameters, postParameters, files)
1012180
function getArguments(req) {
    const result = req.body || {};
    for (let i in req.query) {
        result[i] = req.query[i];
    }
    return result;
}
337312
def __get_param(self, param):
        
        try:
            return self.request_json[param]
        except KeyError:
            raise FnexchangeError(400, 'Bad request: {0} is required'.format(param))
533658
def request(method='GET'):
    

    def decorator(func):
        @functools.wraps(func)
        def action(self, *args, **kwargs):
            f = furl(self.server)
            path, body = func(self, *args, **kwargs)

            # deal with query string
            query = dict()
            if isinstance(path, tuple):
                path, query = path
            f.path.add(path)
            f.query.set(query)

            status_code, result = send_rest(f.url, method=method.upper(),
                                            body=body,
                                            session=self.session,
                                            headers=self.headers)
            if status_code != httplib.OK:
                self.logger.error("{impl} {url} headers: {headers}, code: {code}".format(
                    impl=method, url=f.url, headers=self.headers, code=status_code))
            return status_code, result

        return action

    return decorator
777533
function(params, req) {
    if (req.query._jsonpdata) {
      var jsonpdata = null;
      try {
        jsonpdata = JSON.parse(decodeURIComponent(req.query._jsonpdata));
        params = _.extend(params, jsonpdata);
      } catch (e) {
        params._jsonpdata = req.query._jsonpdata;
      }
    }
    return params;
  }
1241844
def get_params(self):
        
        return odict([(key,param.value) for key,param in self.params.items()])
65320
function allParams(req){
  var params = req.params.all();
  return _.merge(req.query, params);
}
1028805
function getRequestFileParameters(req, res, next) {
  //A valid getForms request must have an appId parameter set
  var submitFileParams = {};
  submitFileParams.fileDetails = {};

  //Get the content body for normal parameter
  var filesInRequest = req.files;

  if (_.size(filesInRequest) === 0) {
    logger.error("Middleware: getRequestFileParameters, Expected A File To Have Been Sent ", {params: req.params});
    return next(new Error("Expected A File To Have Been Submitted"));
  }

  var fileDetails = _.map(filesInRequest, function(fileValue) {
    return fileValue;
  });

  fileDetails = _.first(fileDetails);

  logger.debug("Middleware: getRequestFileParameters ", {fileDetails: fileDetails, body: req.body});

  submitFileParams.fileDetails = {
    fileStream: fileDetails.path,
    fileName: fileDetails.originalname || fileDetails.name,
    fileType: fileDetails.mimetype,
    fileSize: fileDetails.size
  };

  req.appformsResultPayload = {
    data: submitFileParams,
    type: constants.resultTypes.submissions
  };

  logger.debug("Middleware: getRequestFileParameters ", {params: req.appformsResultPayload});

  return next();
}
589205
def get_request_params(self) -> List[ExtensionParameter]:
        
        return _build_parameters(
            self.server_no_context_takeover,
            self.client_no_context_takeover,
            self.server_max_window_bits,
            self.client_max_window_bits,
        )