:return: list of keys ending with given :suffix:.
551372
def keys_with_suffix(self, suffix):
        
        return [k.rstrip(suffix) for k in self.keys() if k.endswith(suffix)]
217817
def list_keys(self):
    
    return [k for k, el in self._keystore.items() if not el.is_expired]
800520
def get_prefix(self, key_prefix, sort_order=None, sort_target=None):
        
        return self.get(key_prefix,
                        metadata=True,
                        range_end=_encode(_increment_last_byte(key_prefix)),
                        sort_order=sort_order,
                        sort_target=sort_target)
1040213
def chunk_suffixes
      chunks.map { |chunk| File.extname(chunk).split("-").last }.sort
    end
408483
def _key(self):
        
        return (self.start_key, self.start_inclusive, self.end_key, self.end_inclusive)
487301
def keys(self):
        
        return GramGenerator(self.path, self.elem, keys=True,
                             ignore_hash=self.ignore_hash)
417097
def keys(self, prefix=None, delimiter=None):
        
        if delimiter:
            # WE REALLY DO NOT GET KEYS, BUT RATHER Prefix OBJECTS
            # AT LEAST THEY ARE UNIQUE
            candidates = [k.name.rstrip(delimiter) for k in self.bucket.list(prefix=prefix, delimiter=delimiter)]
        else:
            candidates = [strip_extension(k.key) for k in self.bucket.list(prefix=prefix)]

        if prefix == None:
            return set(c for c in candidates if c != "0.json")
        else:
            return set(k for k in candidates if k == prefix or k.startswith(prefix + ".") or k.startswith(prefix + ":"))
1267644
def __ensure_suffix(t, suffix):
    
    tpath = str(t)
    if not tpath.endswith(suffix):
        return tpath+suffix
    
    return t
1088855
def __get_keys(self, chrom, start, end=None):
    
    keys = []
    if chrom in self.whole_chrom_files:
      keys.append(self.whole_chrom_files[chrom])
    if chrom in self.partial_trees:
      if end is not None:
        hits = self.partial_trees[chrom].intersectingInterval(start, end)
      else:
        hits = self.partial_trees[chrom].intersectingPoint(start, end)
      for hit in hits:
        keys.append(hit.key)
    return keys
152539
def get_keys(self, key=None):
        
        if key:
            value = _lxc.Container.get_keys(self, key)
        else:
            value = _lxc.Container.get_keys(self)

        if value is False:
            return False
        elif value.endswith("\n"):
            return value.rstrip("\n").split("\n")
        else:
            return value
1269139
def suffix(filename,suffix):
    '''  '''
    return os.path.split(re.sub(_afni_suffix_regex,"%s\g<1>" % suffix,str(filename)))[1]
867264
def keys_at(self, x):
		
		return [key for key, segs in self.items() if x in segs]
1027018
def _suffix(self):
        """"""
        _output_formats={'GCG':'.msf',
                        'GDE':'.gde',
                        'PHYLIP':'.phy',
                        'PIR':'.pir',
                        'NEXUS':'.nxs'}

        if self.Parameters['-output'].isOn():
            return _output_formats[self.Parameters['-output'].Value]
        else:
            return '.aln'
575166
def keys(self):
        
        if ver == (2, 7):
            return self.viewkeys()
        elif ver == (2, 6):
            return self.iterkeys()
        elif ver >= (3, 0):
            return self.keys()
645136
def all(self):
        
        return {
            self._decode(k): self._loads(v)
            for k, v in self._client.hgetall(self.key_prefix).items()
        }
1022991
function(key) {
    if (!key.match(suffixRegex)) {
      return key + '2';
    }

    return key.replace(suffixRegex, function(suffix) {
      return Number(suffix) + 1;
    });
  }
1130204
def _keys(self, pattern):
        
        result = []
        for client in self.redis_clients:
            result.extend(list(client.scan_iter(match=pattern)))
        return result