returns the 'query' from the request
489003
def get_query():
    
    q = get("q", "")

    qs = q.lstrip("*.!$%&/()=#-+:'`´^")
    if qs and not qs.endswith("*"):
        qs += "*"
    return qs
1245512
def backend_query(self, **kwargs):
        ''''''
        q = self.construct()
        return q if isinstance(q, EmptyQuery) else q.backend_query(**kwargs)
534520
def _query(self):
        '''
        
        '''
        query = salt.utils.stringutils.to_bytes(
            "{}{}".format(self.signature, time.time()))
        self._socket.sendto(query, ('<broadcast>', self.port))

        return query
1006006
def query(self):
        
        if self._rawquery==True:
            return self.__query
        return flatten(self.__query)
421686
async def _query_json(
        self, path, method="GET", *, params=None, data=None, headers=None, timeout=None
    ):
        
        if headers is None:
            headers = {}
        headers["content-type"] = "application/json"
        if not isinstance(data, (str, bytes)):
            data = json.dumps(data)
        response = await self._query(
            path, method, params=params, data=data, headers=headers, timeout=timeout
        )
        data = await parse_result(response)
        return data
150114
function query(params, callback) {
  const args = utils.getArgs(params, [config], callback);
  const url = `http://${args.options.ip}:${args.options.port}/`;

  return request.get({
    url,
    qs: args.options,
  }, function(err, res, body) {
    if (err) {
      return args.callback(err);
    }
    return args.callback(null, body);
  });
}
77327
def parse_querystring(self, req, name, field):
        """"""
        return core.get_value(req.params, name, field)
990766
def query(self, query):
    '''
    '''
    self.logger.info('%s: query %s' % (self, query))
    return super(LoggingDatastore, self).query(query)
894595
def query(cls, name=None, offset=None, limit=None, api=None):
        

        api = api or cls._API
        return super(Automation, cls)._query(
            url=cls._URL['query'],
            name=name,
            offset=offset,
            limit=limit,
            api=api,
        )
57796
def query(self):
        """"""

        if not hasattr(self, '_decoded_query'):
            self._decoded_query = list(urls._url_decode_impl(
                self.querystr.split('&'), 'utf-8', False, True, 'strict'))
        return self.query_cls(self._decoded_query)
262823
def _query_service(self, name):
        """"""
        if self.query_cmd:
            try:
                return sos_get_command_output("%s %s" % (self.query_cmd, name))
            except Exception:
                return None
        return None
203774
def parse_querystring(self, req, name, field):
        """"""
        return core.get_value(req.GET, name, field)
239034
def paginate_query(self, query):
        

        if self.paginator is None:
            return None

        return self.paginator.paginate_query(query, self.request)
921554
def _http_get(self, url, query, **kwargs):
        

        self._normalize_query(query)

        kwargs.update({'params': query})

        return self._http_request('get', url, kwargs)
758727
def basic_query(returns):
    """"""
    return compose(
        reusable,
        map_send(parse_request),
        map_yield(prepare_params, snug.prefix_adder(API_PREFIX)),
        map_return(loads(returns)),
        oneyield,
    )
1273834
def _get_query(self, **query_dict):
        """"""
        param_dict = query_dict.copy()
        return self._send_query(do_post=False, **param_dict)
185175
def GET_query(self, req_hook, req_args):
        '''  '''
        # GET request methods only require sessionTokens
        headers = {'content-type': 'application/json',
                   'sessionToken': self.__session__}

        # HTTP GET query method using requests module
        try:
            if req_args is None:
                response = requests.get(self.__url__ + req_hook,
                                        headers=headers,
                                        verify=True)
            else:
                response = requests.get(self.__url__ + req_hook + str(req_args),
                                        headers=headers,
                                        verify=True)
        except requests.exceptions.RequestException as err:
            self.logger.error(err)
            return '500', 'Internal Error in RESTful.GET_query()'
        # return the token
        return response.status_code, response.text