An MD5 hash of the current vertices and entities.

        Returns
        ------------
        md5: str, two appended MD5 hashes
762174
def md5(self):
        
        # first MD5 the points in every entity
        target = '{}{}'.format(
            util.md5_object(bytes().join(e._bytes()
                                         for e in self.entities)),
            self.vertices.md5())

        return target
96444
def identifier_md5(self):
        
        as_int = (self.identifier * 1e4).astype(np.int64)
        hashed = util.md5_object(as_int.tostring(order='C'))
        return hashed
940522
def crc(self):
        
        # first CRC the points in every entity
        target = caching.crc32(bytes().join(e._bytes()
                                            for e in self.entities))
        # add the CRC for the vertices
        target ^= self.vertices.crc()
        return target
1534
def md5(source):
    
    # fix passing char '+' from source
    source = source.replace("%2B", "+")
    with open(source) as file_to_check:
        data = file_to_check.read()
        return hashlib.md5(data).hexdigest()
971216
def digest_chunks(chunks, algorithms=(hashlib.md5, hashlib.sha1)):
    

    hashes = [algorithm() for algorithm in algorithms]

    for chunk in chunks:
        for h in hashes:
            h.update(chunk)

    return [_b64encode_to_str(h.digest()) for h in hashes]
998241
def md5(self):
        """"""
        md5 = self.meta.get("md5")
        if md5 is None:
            md5 = str(hashlib.md5(self.value).hexdigest())

        return md5
1156060
def checksum(self):
        
        
        m = md5()
        for hl in self.hidden_layers:
            m.update(str(hl.architecture))
        m.update(str(self.top_layer.architecture))
        return m.hexdigest()
751261
def get_content_hash(self):
        
        if not self.rexists():
            return SCons.Util.MD5signature('')
        fname = self.rfile().get_abspath()
        try:
            cs = SCons.Util.MD5filesignature(fname,
                chunksize=SCons.Node.FS.File.md5_chunksize*1024)
        except EnvironmentError as e:
            if not e.filename:
                e.filename = fname
            raise
        return cs
239940
def todict(self):
        
        return {'index': self.index,
                'seed': hb_encode(self.seed),
                'n': self.n,
                'root': hb_encode(self.root),
                'hmac': hb_encode(self.hmac),
                'timestamp': self.timestamp}
1175932
def get_md5_hash(file_path):
    
    checksum = hashlib.md5()
    with open(file_path, 'rb') as f:
        for chunk in iter(lambda: f.read(128 * checksum.block_size), b''):
            checksum.update(chunk)
    return checksum.hexdigest()
1024559
def md5(value):
    
    m = hashlib.md5()
    m.update(value)
    return str(m.hexdigest())
231187
def Hash(self):
        
        if not self.__hash:
            ba = bytearray(binascii.unhexlify(self.GetHashData()))
            hash = Crypto.Hash256(ba)
            self.__hash = UInt256(data=hash)
        return self.__hash
1077482
def as_dict(self):
        

        d = {"@module": self.__class__.__module__,
             "@class": self.__class__.__name__,
             "molecule": self.molecule.as_dict(),
             "graphs": json_graph.adjacency_data(self.graph)}

        return d
743246
def checkIfHashIsCracked(hash=None):
	

	apiURL = "http://md5db.net/api/" + str(hash).lower()

	try:

		# Getting the result of the query from MD5db.net
		data = urllib2.urlopen(apiURL).read()
		return data

	except:
		# No information was found, then we return a null entity
		return []
818807
def get_checksum(self):
        
        arr = [ ]
        for elem in self.parsed:
            s = elem_checksum(elem)
            if s:
                arr.append(s)
        arr.sort()
        #print arr
        return md5(json.dumps(arr))
691696
def md5_of_file(abspath):
    
    chunk_size = 1024 * 1024
    m = hashlib.md5()
    with open(abspath, "rb") as f:
        while True:
            data = f.read(chunk_size)
            if not data:
                break
            m.update(data)
    return m.hexdigest()
937427
def get_signature_hash(params, secret)
      Digest::MD5.hexdigest(get_signature_string(params, secret)).to_s
    end