Better handling of bytes

This adds a `byte_ord` version of `ord` which will let `bytes`
safely pass through in Python 3.

`cmp` was also swapped out as it has been dropped in Python 3.

Author: kevin-brown

gitdb/fun.py

@@ -10,7 +10,7 @@
     BadObjectType
 )
 
-from gitdb.util import zlib
+from gitdb.util import byte_ord, zlib
 decompressobj = zlib.decompressobj
 
 import mmap
@@ -411,13 +411,13 @@ def pack_object_header_info(data):
         The type_id should be interpreted according to the ``type_id_to_type_map`` map
         The byte-offset specifies the start of the actual zlib compressed datastream
     :param m: random-access memory, like a string or memory map"""
-    c = ord(data[0])                # first byte
+    c = byte_ord(data[0])           # first byte
     i = 1                           # next char to read
     type_id = (c >> 4) & 7          # numeric type
     size = c & 15                   # starting size
     s = 4                           # starting bit-shift size
     while c & 0x80:
-        c = ord(data[i])
+        c = byte_ord(data[i])
         i += 1
         size += (c & 0x7f) << s
         s += 7
@@ -668,12 +668,12 @@ def is_equal_canonical_sha(canonical_length, match, sha1):
         hence the comparison will only use the last 4 bytes for uneven canonical representations
     :param match: less than 20 byte sha
     :param sha1: 20 byte sha"""
-    binary_length = canonical_length/2
+    binary_length = canonical_length // 2
     if match[:binary_length] != sha1[:binary_length]:
         return False
 
     if canonical_length - binary_length and \
-        (ord(match[-1]) ^ ord(sha1[len(match)-1])) & 0xf0:
+        (byte_ord(match[-1]) ^ byte_ord(sha1[len(match)-1])) & 0xf0:
         return False
     # END handle uneven canonnical length
     return True

gitdb/pack.py

@@ -15,6 +15,7 @@
     LazyMixin,
     unpack_from,
     bin_to_hex,
+    byte_ord,
 )
 
 from gitdb.fun import (
@@ -421,7 +422,7 @@ def sha_to_index(self, sha):
         :return: index usable with the ``offset`` or ``entry`` method, or None
             if the sha was not found in this pack index
         :param sha: 20 byte sha to lookup"""
-        first_byte = ord(sha[0])
+        first_byte = byte_ord(sha[0])
         get_sha = self.sha
         lo = 0                  # lower index, the left bound of the bisection
         if first_byte != 0:
@@ -430,11 +431,11 @@ def sha_to_index(self, sha):
 
         # bisect until we have the sha
         while lo < hi:
-            mid = (lo + hi) / 2
-            c = cmp(sha, get_sha(mid))
-            if c < 0:
+            mid = (lo + hi) // 2
+            mid_sha = get_sha(mid)
+            if sha < mid_sha:
                 hi = mid
-            elif not c:
+            elif sha == mid_sha:
                 return mid
             else:
                 lo = mid + 1
@@ -453,23 +454,24 @@ def partial_sha_to_index(self, partial_bin_sha, canonical_length):
         if len(partial_bin_sha) < 2:
             raise ValueError("Require at least 2 bytes of partial sha")
 
-        first_byte = ord(partial_bin_sha[0])
+        first_byte = byte_ord(partial_bin_sha[0])
+
         get_sha = self.sha
         lo = 0                  # lower index, the left bound of the bisection
         if first_byte != 0:
             lo = self._fanout_table[first_byte-1]
         hi = self._fanout_table[first_byte]     # the upper, right bound of the bisection
 
         # fill the partial to full 20 bytes
-        filled_sha = partial_bin_sha + '\0'*(20 - len(partial_bin_sha))
+        filled_sha = partial_bin_sha + '\0'.encode("ascii") * (20 - len(partial_bin_sha))
 
         # find lowest
         while lo < hi:
-            mid = (lo + hi) / 2
-            c = cmp(filled_sha, get_sha(mid))
-            if c < 0:
+            mid = (lo + hi) // 2
+            mid_sha = get_sha(mid)
+            if filled_sha < mid_sha:
                 hi = mid
-            elif not c:
+            elif filled_sha == mid_sha:
                 # perfect match
                 lo = mid
                 break
@@ -482,7 +484,7 @@ def partial_sha_to_index(self, partial_bin_sha, canonical_length):
             cur_sha = get_sha(lo)
             if is_equal_canonical_sha(canonical_length, partial_bin_sha, cur_sha):
                 next_sha = None
-                if lo+1 < self.size():
+                if lo + 1 < self.size():
                     next_sha = get_sha(lo+1)
                 if next_sha and next_sha == cur_sha:
                     raise AmbiguousObjectName(partial_bin_sha)

gitdb/util.py

@@ -118,14 +118,27 @@ def __getitem__(self, i):
     def __getslice__(self, start, end):
         return self.getvalue()[start:end]
 
+def byte_ord(b):
+    """
+    Return the integer representation of the byte string.  This supports Python
+    3 byte arrays as well as standard strings.
+    """
+    try:
+        return ord(b)
+    except TypeError:
+        return b
+
 #} END compatibility stuff ...
 
 #{ Routines
 
-def make_sha(source=''):
+def make_sha(source=None):
     """A python2.4 workaround for the sha/hashlib module fiasco
 
     **Note** From the dulwich project """
+    if source is None:
+        source = "".encode("ascii")
+
     try:
         return hashlib.sha1(source)
     except NameError: