remove length member from Multihash

A multihash with a mismatching digest length doesn't make sense (see
multiformats/multihash#21).  This also leaves explicit truncation as the only way to
force the shortening of a digest.

Author: ivilata

multihash.py

@@ -165,41 +165,41 @@ def get_decoder(cls, encoding):
 Codecs.reset()
 
 
-class Multihash(namedtuple('Multihash', 'func length digest')):
-    """A named tuple representing multihash function, length and digest.
+class Multihash(namedtuple('Multihash', 'func digest')):
+    """A named tuple representing a multihash function and digest.
 
     The hash function is a `Func` member:
 
-    >>> mh = Multihash(Func.sha1, 20, b'BINARY_DIGEST')
-    >>> mh == (Func.sha1, 20, b'BINARY_DIGEST')
+    >>> mh = Multihash(Func.sha1, b'BINARY_DIGEST')
+    >>> mh == (Func.sha1, b'BINARY_DIGEST')
     True
-    >>> mh == (mh.func, mh.length, mh.digest)
+    >>> mh == (mh.func, mh.digest)
     True
 
     Although it can also be its integer value (the function code) or its
     string name (the function name, with either underscore or hyphen):
 
-    >>> mhfc = Multihash(Func.sha1.value, mh.length, mh.digest)
+    >>> mhfc = Multihash(Func.sha1.value, mh.digest)
     >>> mhfc == mh
     True
-    >>> mhfn = Multihash('sha2-256', 32, b'...')
+    >>> mhfn = Multihash('sha2-256', b'...')
     >>> mhfn.func is Func.sha2_256
     True
 
     Application-specific codes (0x00-0x0f) are also accepted.  Other codes
     raise a `ValueError`:
 
-    >>> mhfc = Multihash(0x01, 4, b'...')
+    >>> mhfc = Multihash(0x01, b'...')
     >>> mhfc.func
     1
-    >>> mhfc = Multihash(1234, 4, b'...')
+    >>> mhfc = Multihash(1234, b'...')
     Traceback (most recent call last):
         ...
     ValueError: ('invalid hash function code', 1234)
     """
     __slots__ = ()
 
-    def __new__(cls, func, length, digest):
+    def __new__(cls, func, digest):
         try:
             f = Func(func)  # function or function code
         except ValueError as ve:
@@ -209,8 +209,7 @@ def __new__(cls, func, length, digest):
                 f = _func_from_name[func]  # function name
             else:
                 raise ValueError("invalid hash function code", func)
-        return super(cls, Multihash).__new__(
-            cls, f, int(length), bytes(digest))
+        return super(cls, Multihash).__new__(cls, f, bytes(digest))
 
     @classmethod
     def from_hash(self, hash):
@@ -220,7 +219,7 @@ def from_hash(self, hash):
         >>> hash = hashlib.sha1(b'foo')
         >>> digest = hash.digest()
         >>> mh = Multihash.from_hash(hash)
-        >>> mh == (Func.sha1, len(digest), digest)
+        >>> mh == (Func.sha1, digest)
         True
 
         If there is no matching multihash hash function for the given `hash`,
@@ -237,14 +236,14 @@ def from_hash(self, hash):
         except KeyError:
             raise ValueError("no matching multihash function", hash.name)
         digest = hash.digest()
-        return Multihash(func, len(digest), digest)
+        return Multihash(func, digest)
 
     def encode(self, encoding=None):
         r"""Encode into a multihash-encoded digest.
 
         If `encoding` is `None`, a binary digest is produced:
 
-        >>> mh = Multihash(0x01, 4, b'TEST')
+        >>> mh = Multihash(0x01, b'TEST')
         >>> mh.encode()
         b'\x01\x04TEST'
 
@@ -258,7 +257,7 @@ def encode(self, encoding=None):
             fc = self.func.value
         except AttributeError:  # application-specific function code
             fc = self.func
-        mhash = bytes([fc, self.length]) + self.digest
+        mhash = bytes([fc, len(self.digest)]) + self.digest
         if encoding:
             mhash = Codecs.get_encoder(encoding)(mhash)
         return mhash
@@ -278,7 +277,7 @@ def verify(self, data):
         Application-specific hash functions are currently not supported and a
         `ValueError` is raised:
 
-        >>> mh = Multihash(0x01, 4, b'TEST')
+        >>> mh = Multihash(0x01, b'TEST')
         >>> mh.verify(data)
         Traceback (most recent call last):
             ...
@@ -292,27 +291,27 @@ def verify(self, data):
             raise ValueError("no available hash function for hash", self.func)
         hash.update(data)
         digest = bytes(hash.digest())
-        return digest[:self.length] == self.digest
+        return digest[:len(self.digest)] == self.digest
 
     def truncate(self, length):
         """Return a new `Multihash` with a shorter digest `length`.
 
         If the given `length` is greater than the original, a `ValueError`
         is raised.
 
-        >>> mh1 = Multihash(0x01, 6, b'FOOBAR')
+        >>> mh1 = Multihash(0x01, b'FOOBAR')
         >>> mh2 = mh1.truncate(3)
-        >>> mh2 == (0x01, 3, b'FOO')
+        >>> mh2 == (0x01, b'FOO')
         True
         >>> mh3 = mh1.truncate(10)
         Traceback (most recent call last):
             ...
         ValueError: cannot enlarge the original digest by 4 bytes
         """
-        if length > self.length:
+        if length > len(self.digest):
             raise ValueError("cannot enlarge the original digest by %d bytes"
-                             % (length - self.length))
-        return self.__class__(self.func, length, self.digest[:length])
+                             % (length - len(self.digest)))
+        return self.__class__(self.func, self.digest[:length])
 
 
 def decode(mhash, encoding=None):
@@ -322,7 +321,7 @@ def decode(mhash, encoding=None):
 
     >>> mhash = b'\x11\x0a\x0b\xee\xc7\xb5\xea?\x0f\xdb\xc9]'
     >>> mh = decode(mhash)
-    >>> mh == (Func.sha1, 10, mhash[2:])
+    >>> mh == (Func.sha1, mhash[2:])
     True
 
     If an `encoding` is specified, it is used to decode the digest
@@ -336,7 +335,8 @@ def decode(mhash, encoding=None):
     """
     if encoding:
         mhash = Codecs.get_decoder(encoding)(mhash)
-    return Multihash(int(mhash[0]), int(mhash[1]), mhash[2:])
+    # TODO: check lenghts
+    return Multihash(int(mhash[0]), mhash[2:])
 
 
 def _test():