Get query in device query service.

        :param int query_id: ID of the query to get (Required)
        :returns: device query object
        :rtype: Query
341386
def get_query(self, query_id):
        
        api = self._get_api(device_directory.DefaultApi)
        return Query(api.device_query_retrieve(query_id))
197220
def _get(self, url, query=None, **kwargs):
        

        return self._request('get', url, query, **kwargs)
695880
def get(self, id):
        
        try:
            session_json = self.db[id]
        except KeyError:
            session_json = "{}"
        return json_loads(session_json)
1181198
def fetch(self, query_id, start_over, fetch_size):
    
    self.send_fetch(query_id, start_over, fetch_size)
    return self.recv_fetch()
236139
def get_device(self, device_id, refresh=False):
        """"""
        if self._devices is None:
            self.get_devices()
            refresh = False

        device = self._devices.get(device_id)

        if device and refresh:
            device.refresh()

        return device
1364004
def get(self, id):
        
        with rconnect() as conn:
            if id is None:
                raise ValueError

            if isinstance(id, uuid.UUID):
                id = str(id)

            if type(id) != str and type(id) != unicode:
                raise ValueError

            try:
                query = self._base().get(id)
                log.debug(query)
                rv = query.run(conn)
            except ReqlOpFailedError as e:
                log.warn(e)
                raise
            except Exception as e:
                log.warn(e)
                raise
            if rv is not None:
                return self._model(rv)

            return None
1010762
def get_by_id(cls, id):
        

        if any((isinstance(id, basestring) and id.isdigit(), isinstance(id,
               (int, float)))):
            return cls.query.get(int(id))
        return None
1361476
def get(self, sid):
        
        return QueryContext(self._version, assistant_sid=self._solution['assistant_sid'], sid=sid, )
784149
def gql(query_string, *args, **kwds):
  
  qry = _gql(query_string)
  if args or kwds:
    qry = qry._bind(args, kwds)
  return qry
646607
def get(self, id):
        
        data = self.fetch('documents/%s.json' % id).get("document")
        data['_connection'] = self._connection
        return Document(data)
412939
def get_records(self, ids):
        
        return self.query(Ids(values=[str(id_) for id_ in ids]))
565609
def get(self, tx_id: str) -> Transaction:
        
        query = (
            self.book.session.query(Transaction)
            .filter(Transaction.guid == tx_id)
        )
        return query.one()
1218974
def query(self, **kwargs):
        
        path = partial(_path, self.adapter)
        path = _path(self.adapter)
        return self._get(path, **kwargs)
74594
def get(self, id_):
        
        if self.api.queue_exists(id_):
            return Queue(self, {"queue": {"name": id_, "id_": id_}}, key="queue")
        raise exc.NotFound("The queue '%s' does not exist." % id_)
1006964
def slice_query(self, slice_id):
        
        viz_obj = get_viz(slice_id)
        security_manager.assert_datasource_permission(viz_obj.datasource)
        return self.get_query_string_response(viz_obj)
1050769
def request(self, id, **kwargs):
        
        data = self.get('requests', id, **kwargs)
        return data
501943
def device(self, device_id, *args, **kwargs):
        
        return Device(device_id, self.corsair_sdk, self._corsair_sdk_path, *args, **kwargs)