Check for a key without waiting.  This method is deprecated.  Use
        :py:meth:`.get_event` instead.
971937
def get_key(self):
        
        event = self.get_event()
        if event and isinstance(event, KeyboardEvent):
            return event.key_code
        return None
1130158
def get_alert(thing_name, key, session=None):
    
    return _request('get', '/get/alert/for/{0}'.format(thing_name), params={'key': key}, session=session)
774680
def get_event_action(cls) -> Optional[str]:
        
        if not cls.actor:
            return None
        return event_context.get_event_action(cls.event_type)
199103
def wait_event(self, filter: Callable[[T_Event], bool] = None) -> Awaitable[T_Event]:
        """"""
        return wait_event([self], filter)
1266242
def wait(self):
        
        ret = os.read(self.event_fd, 64 / 8)
        return struct.unpack('Q', ret)
1129083
function (key, cb) {

            _util.buildQuery('events', {event_key: key}, function (error, data) {

                return cb(error, data);

            });

        }
914861
def get(self, key):
        

        if not key in self._actions:
            return None
        if not key in self._cache:
            self._cache[key] = self._actions[key]()

        return self._cache[key]
771420
def OnNewGpgKey(self, event):
        

        if gnupg is None:
            return

        if genkey is None:
            # gnupg is not present
            self.interfaces.display_warning(
                _("Python gnupg not found. No key selected."),
                _("Key selection failed."))
        else:
            # gnupg is present
            genkey()
172549
def get_event(self):
        

        if not self.is_event_message:
            return None

        # select a dummy field (eg. subject) to avoid pull unneccesary data
        query = self.q().select('subject').expand('event')

        url = self.build_url(self._endpoints.get('get_message').format(id=self.object_id))

        response = self.con.get(url, params=query.as_params())

        if not response:
            return None

        data = response.json()
        event_data = data.get(self._cc('event'))

        return Event(parent=self, **{self._cloud_data_key: event_data})
873163
def check_key(request):
    
    try:
        access_key = request.session.get('oauth_token', None)
        if not access_key:
            return False
    except KeyError:
        return False
    return True
182756
def get(self, key, alt=None):
        
        with self.lock:
            if key in self:
                return self.getitem(key)

            else:
                return alt
1304571
def get(self, key):
        
        # Catch the case where the key is "."
        if "." in key and len(key) > 1:
            return self._recursive_get(key)
        return self._requirements.get(key, None)
313885
def then_the_return_element_have_no_key(context, line, key):
    
    line = int(line)
    data = context.apiRequest.data
    assert 0 <= line < len(data)
    assert key not in data[line]
587140
def get(self, key, default=None):
        
        try:
            return self[key]
        except KeyError:
            return default or self._default
1092860
def event_exists(self, client, check):
        '''
        
        '''
        return self.api_request(
            'get',
            'events/{}/{}'.format(client, check)
            ).status_code == 200
1203625
def read_key(suppress=False):
    
    event = read_event(suppress)
    return event.name or event.scan_code
265473
def wait_for_event(event):
    
    f = Future()
    def ready():
        get_event_loop().remove_win32_handle(event)
        f.set_result(None)
    get_event_loop().add_win32_handle(event, ready)
    return f