Return a hashable key, representing the command.

        Returns
        -------
        tuple
172686
def __key(self):
        

        return (self.latex_name, self.arguments, self.options,
                self.extra_arguments)
630989
def make_dict_hash(o):
    
    if isinstance(o, (set, tuple, list)):
        return tuple([make_dict_hash(e) for e in o])
    elif not isinstance(o, dict):
        return hash(o)

    new_o = copy.deepcopy(o)
    for k, v in new_o.items():
        new_o[k] = make_dict_hash(v)

    return hash(tuple(frozenset(sorted(new_o.items()))))
1275412
def get_keys_for(self, value):
        
        if callable(value):
            return value(self)
        hash_value = self.get_hash_for(value)
        return self._index[hash_value][:]
77850
function getKey() {
      let paramString =
        width + 'x' + height + '-'
        + path
        + (is2x ? '-@2x' : '')
        + (bg ? `_${bg}` : '')
        + (crop ? '_crop' : '')
        + (mode ? `_${mode}` : '')
        + (trim ? '_trim' : '');

      return paramString + '-' + crypto.createHash('sha1').update(paramString).digest('hex');
    }
662290
def keys(self):
        ""
        return tuple(set(self.new.keys()).union(self.old.keys()))
1143242
def hashable(self):
        

        output = []
        values = self._get_values(self)
        for key in sorted(values.keys()):
            output.append('%s: %s' % (key, values[key]))
        # Unit separator is used here since the normalization process for
        # values moves any such character, and the keys are all dotted integers
        # or under_score_words
        return '\x1F'.join(output)
26248
def get_key(key, host=None, port=None, db=None, password=None):
    '''
    
    '''
    server = _connect(host, port, db, password)
    return server.get(key)
180287
def get(self, key_id=None):
        
        url = self.bitbucket.url('GET_SSH_KEY', key_id=key_id)
        return self.bitbucket.dispatch('GET', url, auth=self.bitbucket.auth)
971937
def get_key(self):
        
        event = self.get_event()
        if event and isinstance(event, KeyboardEvent):
            return event.key_code
        return None
464214
def hash_key(self, key):
        
        for i, destination_key in enumerate(self._dict):
            if key < destination_key:
                return destination_key

        return key
786132
def hash_tuple(val, encoding='utf8', hash_key=None):
    
    hashes = (_hash_scalar(v, encoding=encoding, hash_key=hash_key)
              for v in val)

    h = _combine_hash_arrays(hashes, len(val))[0]

    return h
578530
def previous_key(tuple_of_tuples, key):
    
    for i, t in enumerate(tuple_of_tuples):
        if t[0] == key:
            try:
                return tuple_of_tuples[i - 1][0]
            except IndexError:
                return None
740556
def wrap_key(self, key):
        
        return tuple(np.round(
            self.integer_cell.shortest_vector(key)
        ).astype(int))
1217413
def _path(self, key):
        
        hash_type, parts_count = self._HASHES[self._hash_type]
        h = hash_type(encode(key)).hexdigest()

        parts = [h[i:i+2] for i in range(0, len(h), 2)][:parts_count]

        return os.path.join(self._directory, os.path.sep.join(parts), h)
455283
def _hashed_key(self):
        
        return abs(int(hashlib.md5(
            self.key_prefix.encode('utf8')
        ).hexdigest(), 16)) % (10 ** (
            self._size_mod if hasattr(self, '_size_mod') else 5))
842655
def primary_key_tuple(self, item):
        
        if self.range_key is None:
            return (item[self.hash_key.name],)
        else:
            return (item[self.hash_key.name], item[self.range_key.name])
1030063
def get_key(soup):
    '''
    
    '''

    crypto_tag = soup.find(_crypto_tag)
    if crypto_tag is None:
        return _default_key

    pat = re.compile('\["(.+)"\]')
    keys = pat.findall(crypto_tag.text)
    if len(keys) > 0:
        unhashed_key = keys[-1].encode().decode('unicode_escape')
        return _generate_sha(unhashed_key)
    else:
        return _default_key