Start processing next unique key.
176758
public boolean nextKey() throws IOException,InterruptedException {
    while (hasMore && nextKeyIsSame) {
      nextKeyValue();
    }
    if (hasMore) {
      if (inputKeyCounter != null) {
        inputKeyCounter.increment(1);
      }
      return nextKeyValue();
    } else {
      return false;
    }
  }
846659
def distinct(self, fieldname, key=None):
        
        return tuple(unique_everseen(self[fieldname], key=key))
917429
def fromkeys(cls, seq, value=None, **kwargs):
        
        other = cls(**kwargs)
        other.update(((key, value) for key in seq))

        return other
730684
def _process_key_val(self, instance, key, val):
        '''
        
        '''
        if instance.check_precondition(key, val):
            combined = '{k}:{v}'.format(k=key, v=val)
            self._increment_total_stat(combined)
            self._increment_plugin_stat(
                instance.__class__.__name__,
                combined)
            instance.handle(key, val)
            self.redis_conn.delete(key)
            failkey = self._get_fail_key(key)
            if self.redis_conn.exists(failkey):
                self.redis_conn.delete(failkey)
860466
def displayNewKey(key):
    """"""

    if key.keyring:
        gpg.keyring = key.keyring
    if key.secring:
        gpg.secring = key.secring

    # Using '--fingerprint' twice will display subkey fingerprints too:
    gpg.options = ['--fingerprint', '--fingerprint']
    keylist = gpg.list_keys(secret=True)

    # `result` is a `gnupg._parsers.ListKeys`, which is list-like, so iterate
    # over all the keys and display their info:
    for gpgkey in keylist:
        for k, v in gpgkey.items():
            log.info("%s: %s" % (k.capitalize(), v))

    return keylist
1287636
def flush(self, key=None):
        

        if not key is None:
            if key in self.data:
                del self.data[key]
        else:
            self.data = {}
            self.next_cleaning = time.time() + self.cleaning_interval
1089036
def _batch_key(self, query):
    '''
    
    '''
    return ''.join( ['%s%s'%(k,v) for k,v in sorted(query.items())] )
147468
def on_key_up(self):
        
        if (self.last_pressed is not None):
            self.set_key_state(self.last_pressed, 0)
            self.buffer = self.last_pressed.update_buffer(self.buffer)
            self.text_consumer(self.buffer)
            self.last_pressed = None
772298
def decrement(self, key, value=1):
        
        return self._memcache.decr(self._prefix + key, value)
517685
def tap_key(self, character='', n=1, interval=0):
        """"""
        for i in range(n):
            self.press_key(character)
            self.release_key(character)
            time.sleep(interval)
1190221
def send_key(self, key, repeat=1):
                
        for _ in range(repeat):
            self.mediator.send_key(key)
        self.mediator.flush()
64941
def each_key(pattern = nil, secret_only = false, &block)
      keylist_start(pattern, secret_only)
      begin
        loop { yield keylist_next }
      rescue EOFError
        # The last key in the list has already been returned.
      ensure
        keylist_end
      end
    end
646006
def updateAllKeys(self):
        """"""
        for kf, key in zip(self.kf_list, self.sorted_key_list()):
            kf.update(key, self.dct[key])
1241461
def start(self, key):
        
        start_d = self._get_limiter(key).start()
        self._cleanup_limiter(key)
        return start_d
369433
def hkeys(self, key, *, encoding=_NOTSET):
        """"""
        return self.execute(b'HKEYS', key, encoding=encoding)
35053
function wait(key, cb) {
    if (!waiting[key]) {
        waiting[key] = [];
    }

    waiting[key].push(cb);
}
297894
function tick(key) {
    var next;
    if (waiting[key]) {
        //there's somone waiting for this resource
        if (!locks[key]) {
            locks[key] = true;
            stats.lock_add();
            next = waiting[key].shift();
            if (waiting[key].length === 0) {
                //nobody is waiting for this resource anymore, clean it up
                delete waiting[key];
            }
            next(key);
        }
    }
}