Ported all Python parts to Python 3.1 except for the C extension

Author: Alex Grönholm

bson/__init__.py

@@ -20,6 +20,7 @@
 import re
 import struct
 import warnings
+import uuid
 
 from bson.binary import Binary
 from bson.code import Code
@@ -41,12 +42,6 @@
 except ImportError:
     _use_c = False
 
-try:
-    import uuid
-    _use_uuid = True
-except ImportError:
-    _use_uuid = False
-
 
 # This sort of sucks, but seems to be as good as it gets...
 RE_TYPE = type(re.compile(""))
@@ -65,23 +60,26 @@ def _get_int(data, as_class=None, tz_aware=False, unsigned=False):
 def _get_c_string(data, length=None):
     if length is None:
         try:
-            length = data.index("\x00")
+            length = data.index(b"\x00")
         except ValueError:
             raise InvalidBSON()
 
     return (data[:length].decode("utf-8"), data[length + 1:])
 
 
 def _make_c_string(string, check_null=False):
-    if check_null and "\x00" in string:
-        raise InvalidDocument("BSON keys / regex patterns must not "
-                              "contain a NULL character")
-    if isinstance(string, unicode):
-        return string.encode("utf-8") + "\x00"
+    if isinstance(string, str):
+        if check_null and "\x00" in string:
+            raise InvalidDocument("BSON keys / regex patterns must not "
+                                  "contain a NULL character")
+        return string.encode('utf-8') + b"\x00"
     else:
+        if check_null and b"\x00" in string:
+            raise InvalidDocument("BSON keys / regex patterns must not "
+                                  "contain a NULL character")
         try:
             string.decode("utf-8")
-            return string + "\x00"
+            return string + b"\x00"
         except:
             raise InvalidStringData("strings in documents must be valid "
                                     "UTF-8: %r" % string)
@@ -118,15 +116,17 @@ def _get_array(data, as_class, tz_aware):
 
 def _get_binary(data, as_class, tz_aware):
     (length, data) = _get_int(data)
-    subtype = ord(data[0])
+    subtype = data[0]
     data = data[1:]
+    if subtype == 0:
+        return (data[:length], data[length:])
     if subtype == 2:
         (length2, data) = _get_int(data)
         if length2 != length - 4:
             raise InvalidBSON("invalid binary (st 2) - lengths don't match!")
         length = length2
-    if subtype == 3 and _use_uuid:
-        return (uuid.UUID(bytes=data[:length]), data[length:])
+    if subtype == 3:
+        return (uuid.UUID(bytes_le=data[:length]), data[length:])
     return (Binary(data[:length], subtype), data[length:])
 
 
@@ -135,11 +135,11 @@ def _get_oid(data, as_class, tz_aware):
 
 
 def _get_boolean(data, as_class, tz_aware):
-    return (data[0] == "\x01", data[1:])
+    return (data[0] == 1, data[1:])
 
 
 def _get_date(data, as_class, tz_aware):
-    seconds = float(struct.unpack("<q", data[:8])[0]) / 1000.0
+    seconds = struct.unpack("<q", data[:8])[0] / 1000
     if tz_aware:
         return (datetime.datetime.fromtimestamp(seconds, utc), data[8:])
     return (datetime.datetime.utcfromtimestamp(seconds), data[8:])
@@ -192,26 +192,26 @@ def _get_long(data, as_class, tz_aware):
 
 
 _element_getter = {
-    "\x01": _get_number,
-    "\x02": _get_string,
-    "\x03": _get_object,
-    "\x04": _get_array,
-    "\x05": _get_binary,
-    "\x06": _get_null,  # undefined
-    "\x07": _get_oid,
-    "\x08": _get_boolean,
-    "\x09": _get_date,
-    "\x0A": _get_null,
-    "\x0B": _get_regex,
-    "\x0C": _get_ref,
-    "\x0D": _get_string,  # code
-    "\x0E": _get_string,  # symbol
-    "\x0F": _get_code_w_scope,
-    "\x10": _get_int,  # number_int
-    "\x11": _get_timestamp,
-    "\x12": _get_long,
-    "\xFF": lambda x, y, z: (MinKey(), x),
-    "\x7F": lambda x, y, z: (MaxKey(), x)}
+    0x01: _get_number,
+    0x02: _get_string,
+    0x03: _get_object,
+    0x04: _get_array,
+    0x05: _get_binary,
+    0x06: _get_null,  # undefined
+    0x07: _get_oid,
+    0x08: _get_boolean,
+    0x09: _get_date,
+    0x0A: _get_null,
+    0x0B: _get_regex,
+    0x0C: _get_ref,
+    0x0D: _get_string,  # code
+    0x0E: _get_string,  # symbol
+    0x0F: _get_code_w_scope,
+    0x10: _get_int,  # number_int
+    0x11: _get_timestamp,
+    0x12: _get_long,
+    0xFF: lambda x, y, z: (MinKey(), x),
+    0x7F: lambda x, y, z: (MaxKey(), x)}
 
 
 def _element_to_dict(data, as_class, tz_aware):
@@ -233,7 +233,7 @@ def _bson_to_dict(data, as_class, tz_aware):
     obj_size = struct.unpack("<i", data[:4])[0]
     if len(data) < obj_size:
         raise InvalidBSON("objsize too large")
-    if data[obj_size - 1] != "\x00":
+    if data[obj_size - 1] != 0:
         raise InvalidBSON("bad eoo")
     elements = data[4:obj_size - 1]
     return (_elements_to_dict(elements, as_class, tz_aware), data[obj_size:])
@@ -242,7 +242,7 @@ def _bson_to_dict(data, as_class, tz_aware):
 
 
 def _element_to_bson(key, value, check_keys):
-    if not isinstance(key, basestring):
+    if not isinstance(key, str):
         raise InvalidDocument("documents must have only string keys, "
                               "key was %r" % key)
 
@@ -254,67 +254,66 @@ def _element_to_bson(key, value, check_keys):
 
     name = _make_c_string(key, True)
     if isinstance(value, float):
-        return "\x01" + name + struct.pack("<d", value)
+        return b"\x01" + name + struct.pack("<d", value)
 
     # Use Binary w/ subtype 3 for UUID instances
     try:
         import uuid
 
         if isinstance(value, uuid.UUID):
-            value = Binary(value.bytes, subtype=3)
+            value = Binary(value.bytes_le, subtype=3)
     except ImportError:
         pass
 
     if isinstance(value, Binary):
         subtype = value.subtype
         if subtype == 2:
             value = struct.pack("<i", len(value)) + value
-        return "\x05%s%s%s%s" % (name, struct.pack("<i", len(value)),
-                                 chr(subtype), value)
+        return (b"\x05" + name + struct.pack("<i", len(value)) +
+                bytes([subtype]) + value)
     if isinstance(value, Code):
         cstring = _make_c_string(value)
         scope = _dict_to_bson(value.scope, False, False)
         full_length = struct.pack("<i", 8 + len(cstring) + len(scope))
         length = struct.pack("<i", len(cstring))
-        return "\x0F" + name + full_length + length + cstring + scope
+        return b"\x0F" + name + full_length + length + cstring + scope
+    if isinstance(value, bytes):
+        length = struct.pack("<i", len(value))
+        return b"\x05" + name + length + b'\x00' + value
     if isinstance(value, str):
         cstring = _make_c_string(value)
         length = struct.pack("<i", len(cstring))
-        return "\x02" + name + length + cstring
-    if isinstance(value, unicode):
-        cstring = _make_c_string(value)
-        length = struct.pack("<i", len(cstring))
-        return "\x02" + name + length + cstring
-    if isinstance(value, dict):
-        return "\x03" + name + _dict_to_bson(value, check_keys, False)
+        return b"\x02" + name + length + cstring
+    if isinstance(value, (dict, SON)):
+        return b"\x03" + name + _dict_to_bson(value, check_keys, False)
     if isinstance(value, (list, tuple)):
-        as_dict = SON(zip([str(i) for i in range(len(value))], value))
-        return "\x04" + name + _dict_to_bson(as_dict, check_keys, False)
+        as_dict = SON(list(zip([str(i) for i in range(len(value))], value)))
+        return b"\x04" + name + _dict_to_bson(as_dict, check_keys, False)
     if isinstance(value, ObjectId):
-        return "\x07" + name + value.binary
+        return b"\x07" + name + value.binary
     if value is True:
-        return "\x08" + name + "\x01"
+        return b"\x08" + name + b"\x01"
     if value is False:
-        return "\x08" + name + "\x00"
-    if isinstance(value, (int, long)):
+        return b"\x08" + name + b"\x00"
+    if isinstance(value, int):
         # TODO this is a really ugly way to check for this...
-        if value > 2 ** 64 / 2 - 1 or value < -2 ** 64 / 2:
+        if value > 2 ** 63 - 1 or value < -2 ** 63:
             raise OverflowError("BSON can only handle up to 8-byte ints")
-        if value > 2 ** 32 / 2 - 1 or value < -2 ** 32 / 2:
-            return "\x12" + name + struct.pack("<q", value)
-        return "\x10" + name + struct.pack("<i", value)
+        if value > 2 ** 31 - 1 or value < -2 ** 31:
+            return b"\x12" + name + struct.pack("<q", value)
+        return b"\x10" + name + struct.pack("<i", value)
     if isinstance(value, datetime.datetime):
         if value.utcoffset() is not None:
             value = value - value.utcoffset()
         millis = int(calendar.timegm(value.timetuple()) * 1000 +
                      value.microsecond / 1000)
-        return "\x09" + name + struct.pack("<q", millis)
+        return b"\x09" + name + struct.pack("<q", millis)
     if isinstance(value, Timestamp):
         time = struct.pack("<I", value.time)
         inc = struct.pack("<I", value.inc)
-        return "\x11" + name + inc + time
+        return b"\x11" + name + inc + time
     if value is None:
-        return "\x0A" + name
+        return b"\x0A" + name
     if isinstance(value, RE_TYPE):
         pattern = value.pattern
         flags = ""
@@ -330,25 +329,25 @@ def _element_to_bson(key, value, check_keys):
             flags += "u"
         if value.flags & re.VERBOSE:
             flags += "x"
-        return "\x0B" + name + _make_c_string(pattern, True) + \
+        return b"\x0B" + name + _make_c_string(pattern, True) + \
             _make_c_string(flags)
     if isinstance(value, DBRef):
         return _element_to_bson(key, value.as_doc(), False)
     if isinstance(value, MinKey):
-        return "\xFF" + name
+        return b"\xFF" + name
     if isinstance(value, MaxKey):
-        return "\x7F" + name
+        return b"\x7F" + name
 
     raise InvalidDocument("cannot convert value of type %s to bson" %
                           type(value))
 
 
 def _dict_to_bson(dict, check_keys, top_level=True):
     try:
-        elements = ""
+        elements = b""
         if top_level and "_id" in dict:
             elements += _element_to_bson("_id", dict["_id"], False)
-        for (key, value) in dict.iteritems():
+        for (key, value) in dict.items():
             if not top_level or key != "_id":
                 elements += _element_to_bson(key, value, check_keys)
     except AttributeError:
@@ -358,7 +357,7 @@ def _dict_to_bson(dict, check_keys, top_level=True):
     if length > 4 * 1024 * 1024:
         raise InvalidDocument("document too large - BSON documents are"
                               "limited to 4 MB")
-    return struct.pack("<i", length) + elements + "\x00"
+    return struct.pack("<i", length) + elements + b"\x00"
 if _use_c:
     _dict_to_bson = _cbson._dict_to_bson
 
@@ -410,21 +409,21 @@ def is_valid(bson):
     :Parameters:
       - `bson`: the data to be validated
     """
-    if not isinstance(bson, str):
-        raise TypeError("BSON data must be an instance of a subclass of str")
+    if not isinstance(bson, bytes):
+        raise TypeError("BSON data must be an instance of a subclass of bytes")
 
     # 4 MB limit
     if len(bson) > 4 * 1024 * 1024:
         raise InvalidBSON("BSON documents are limited to 4MB")
 
     try:
         (_, remainder) = _bson_to_dict(bson, dict, True)
-        return remainder == ""
+        return remainder == b""
     except:
         return False
 
 
-class BSON(str):
+class BSON(bytes):
     """BSON (Binary JSON) data.
     """
 
@@ -447,7 +446,7 @@ def encode(cls, document, check_keys=False):
 
         Raises :class:`TypeError` if `document` is not a mapping type,
         or contains keys that are not instances of
-        :class:`basestring`.  Raises
+        :class:`str`.  Raises
         :class:`~bson.errors.InvalidDocument` if `document` cannot be
         converted to :class:`BSON`.
 

bson/binary.py

@@ -61,7 +61,7 @@
 """
 
 
-class Binary(str):
+class Binary(bytes):
     """Representation of BSON binary data.
 
     This is necessary because we want to represent Python strings as
@@ -81,13 +81,13 @@ class Binary(str):
     """
 
     def __new__(cls, data, subtype=OLD_BINARY_SUBTYPE):
-        if not isinstance(data, str):
-            raise TypeError("data must be an instance of str")
+        if not isinstance(data, bytes):
+            raise TypeError("data must be an instance of bytes")
         if not isinstance(subtype, int):
             raise TypeError("subtype must be an instance of int")
         if subtype >= 256 or subtype < 0:
             raise ValueError("subtype must be contained in [0, 256)")
-        self = str.__new__(cls, data)
+        self = bytes.__new__(cls, data)
         self.__subtype = subtype
         return self
 
@@ -99,7 +99,7 @@ def subtype(self):
 
     def __eq__(self, other):
         if isinstance(other, Binary):
-            return (self.__subtype, str(self)) == (other.subtype, str(other))
+            return (self.__subtype, bytes(self)) == (other.subtype, bytes(other))
         # We don't return NotImplemented here because if we did then
         # Binary("foo") == "foo" would return True, since Binary is a
         # subclass of str...
@@ -109,4 +109,4 @@ def __ne__(self, other):
         return not self == other
 
     def __repr__(self):
-        return "Binary(%s, %s)" % (str.__repr__(self), self.__subtype)
+        return "Binary(%s, %s)" % (bytes.__repr__(self), self.__subtype)

bson/code.py

@@ -20,7 +20,7 @@ class Code(str):
     """BSON's JavaScript code type.
 
     Raises :class:`TypeError` if `code` is not an instance of
-    :class:`basestring` or `scope` is not ``None`` or an instance of
+    :class:`str` or `scope` is not ``None`` or an instance of
     :class:`dict`.
 
     Scope variables can be set by passing a dictionary as the `scope`
@@ -41,8 +41,8 @@ class Code(str):
     """
 
     def __new__(cls, code, scope=None, **kwargs):
-        if not isinstance(code, basestring):
-            raise TypeError("code must be an instance of basestring")
+        if not isinstance(code, str):
+            raise TypeError("code must be an instance of str")
 
         self = str.__new__(cls, code)