PYTHON-2133 Remove Py2 compatibility from bson

Author: behackett

bson/__init__.py

@@ -75,6 +75,7 @@
 
 from codecs import (utf_8_decode as _utf_8_decode,
  utf_8_encode as _utf_8_encode)
+from collections import abc as _abc
 
 from bson.binary import (Binary, UuidRepresentation, ALL_UUID_SUBTYPES,
  OLD_UUID_SUBTYPE,
@@ -92,13 +93,6 @@
 from bson.max_key import MaxKey
 from bson.min_key import MinKey
 from bson.objectid import ObjectId
-from bson.py3compat import (abc,
- b,
- PY3,
- iteritems,
- text_type,
- string_type,
- reraise)
 from bson.regex import Regex
 from bson.son import SON, RE_TYPE
 from bson.timestamp import Timestamp
@@ -147,46 +141,18 @@
 _UNPACK_TIMESTAMP_FROM = struct.Struct("<II").unpack_from
 
 
-if PY3:
- _OBJEND = 0
- # Only used to generate the _ELEMENT_GETTER dict
- def _maybe_ord(element_type):
- return ord(element_type)
- # Only used in _raise_unkown_type below
- def _elt_to_hex(element_type):
- return chr(element_type).encode()
- _supported_buffer_types = (bytes, bytearray)
-else:
- _OBJEND = b"\x00"
- def _maybe_ord(element_type):
- return element_type
- def _elt_to_hex(element_type):
- return element_type
- _supported_buffer_types = (bytes,)
-
-
-
-if platform.python_implementation() == 'Jython':
- # This is why we can't have nice things.
- # https://bugs.jython.org/issue2788
- def get_data_and_view(data):
- if isinstance(data, _supported_buffer_types):
- return data, data
- data = memoryview(data).tobytes()
- return data, data
-else:
- def get_data_and_view(data):
- if isinstance(data, _supported_buffer_types):
- return data, memoryview(data)
- view = memoryview(data)
- return view.tobytes(), view
+def get_data_and_view(data):
+ if isinstance(data, (bytes, bytearray)):
+ return data, memoryview(data)
+ view = memoryview(data)
+ return view.tobytes(), view
 
 
 def _raise_unknown_type(element_type, element_name):
  """Unknown type helper."""
  raise InvalidBSON("Detected unknown BSON type %r for fieldname '%s'. Are "
  "you using the latest driver version?" % (
- _elt_to_hex(element_type), element_name))
+ chr(element_type).encode(), element_name))
 
 
 def _get_int(data, view, position, dummy0, dummy1, dummy2):
@@ -213,7 +179,7 @@ def _get_string(data, view, position, obj_end, opts, dummy):
  if length < 1 or obj_end - position < length:
  raise InvalidBSON("invalid string length")
  end = position + length - 1
- if data[end] != _OBJEND:
+ if data[end] != 0:
  raise InvalidBSON("invalid end of string")
  return _utf_8_decode(view[position:end],
  opts.unicode_decode_error_handler, True)[0], end + 1
@@ -226,7 +192,7 @@ def _get_object_size(data, position, obj_end):
  except struct.error as exc:
  raise InvalidBSON(str(exc))
  end = position + obj_size - 1
- if data[end] != _OBJEND:
+ if data[end] != 0:
  raise InvalidBSON("bad eoo")
  if end >= obj_end:
  raise InvalidBSON("invalid object length")
@@ -256,7 +222,7 @@ def _get_array(data, view, position, obj_end, opts, element_name):
  """Decode a BSON array to python list."""
  size = _UNPACK_INT_FROM(data, position)[0]
  end = position + size - 1
- if data[end] != _OBJEND:
+ if data[end] != 0:
  raise InvalidBSON("bad eoo")
 
  position += 4
@@ -321,8 +287,8 @@ def _get_binary(data, view, position, obj_end, opts, dummy1):
  uuid_representation = UuidRepresentation.PYTHON_LEGACY
  return binary_value.as_uuid(uuid_representation), end
 
- # Python3 special case. Decode subtype 0 to 'bytes'.
- if PY3 and subtype == 0:
+ # Decode subtype 0 to 'bytes'.
+ if subtype == 0:
  value = data[position:end]
  else:
  value = Binary(data[position:end], subtype)
@@ -410,27 +376,27 @@ def _get_decimal128(data, view, position, dummy0, dummy1, dummy2):
 # - obj_end: int, end of object to decode in 'data' if variable-length type
 # - opts: a CodecOptions
 _ELEMENT_GETTER = {
- _maybe_ord(BSONNUM): _get_float,
- _maybe_ord(BSONSTR): _get_string,
- _maybe_ord(BSONOBJ): _get_object,
- _maybe_ord(BSONARR): _get_array,
- _maybe_ord(BSONBIN): _get_binary,
- _maybe_ord(BSONUND): lambda u, v, w, x, y, z: (None, w), # Deprecated undefined
- _maybe_ord(BSONOID): _get_oid,
- _maybe_ord(BSONBOO): _get_boolean,
- _maybe_ord(BSONDAT): _get_date,
- _maybe_ord(BSONNUL): lambda u, v, w, x, y, z: (None, w),
- _maybe_ord(BSONRGX): _get_regex,
- _maybe_ord(BSONREF): _get_ref, # Deprecated DBPointer
- _maybe_ord(BSONCOD): _get_code,
- _maybe_ord(BSONSYM): _get_string, # Deprecated symbol
- _maybe_ord(BSONCWS): _get_code_w_scope,
- _maybe_ord(BSONINT): _get_int,
- _maybe_ord(BSONTIM): _get_timestamp,
- _maybe_ord(BSONLON): _get_int64,
- _maybe_ord(BSONDEC): _get_decimal128,
- _maybe_ord(BSONMIN): lambda u, v, w, x, y, z: (MinKey(), w),
- _maybe_ord(BSONMAX): lambda u, v, w, x, y, z: (MaxKey(), w)}
+ ord(BSONNUM): _get_float,
+ ord(BSONSTR): _get_string,
+ ord(BSONOBJ): _get_object,
+ ord(BSONARR): _get_array,
+ ord(BSONBIN): _get_binary,
+ ord(BSONUND): lambda u, v, w, x, y, z: (None, w), # Deprecated undefined
+ ord(BSONOID): _get_oid,
+ ord(BSONBOO): _get_boolean,
+ ord(BSONDAT): _get_date,
+ ord(BSONNUL): lambda u, v, w, x, y, z: (None, w),
+ ord(BSONRGX): _get_regex,
+ ord(BSONREF): _get_ref, # Deprecated DBPointer
+ ord(BSONCOD): _get_code,
+ ord(BSONSYM): _get_string, # Deprecated symbol
+ ord(BSONCWS): _get_code_w_scope,
+ ord(BSONINT): _get_int,
+ ord(BSONTIM): _get_timestamp,
+ ord(BSONLON): _get_int64,
+ ord(BSONDEC): _get_decimal128,
+ ord(BSONMIN): lambda u, v, w, x, y, z: (MinKey(), w),
+ ord(BSONMAX): lambda u, v, w, x, y, z: (MaxKey(), w)}
 
 
 if _USE_C:
@@ -488,7 +454,7 @@ def _bson_to_dict(data, opts):
  except Exception:
  # Change exception type to InvalidBSON but preserve traceback.
  _, exc_value, exc_tb = sys.exc_info()
- reraise(InvalidBSON, exc_value, exc_tb)
+ raise InvalidBSON(str(exc_value)).with_traceback(exc_tb)
 if _USE_C:
  _bson_to_dict = _cbson._bson_to_dict
 
@@ -498,7 +464,7 @@ def _bson_to_dict(data, opts):
 _PACK_LENGTH_SUBTYPE = struct.Struct("<iB").pack
 _PACK_LONG = struct.Struct("<q").pack
 _PACK_TIMESTAMP = struct.Struct("<II").pack
-_LIST_NAMES = tuple(b(str(i)) + b"\x00" for i in range(1000))
+_LIST_NAMES = tuple((str(i) + "\x00").encode('utf8') for i in range(1000))
 
 
 def gen_list_name():
@@ -513,7 +479,7 @@ def gen_list_name():
 
  counter = itertools.count(1000)
  while True:
- yield b(str(next(counter))) + b"\x00"
+ yield (str(next(counter)) + "\x00").encode('utf8')
 
 
 def _make_c_string_check(string):
@@ -548,46 +514,32 @@ def _make_c_string(string):
  return _utf_8_encode(string)[0] + b"\x00"
 
 
-if PY3:
- def _make_name(string):
- """Make a 'C' string suitable for a BSON key."""
- # Keys can only be text in python 3.
- if "\x00" in string:
- raise InvalidDocument("BSON keys / regex patterns must not "
- "contain a NUL character")
- return _utf_8_encode(string)[0] + b"\x00"
-else:
- # Keys can be unicode or bytes in python 2.
- _make_name = _make_c_string_check
+def _make_name(string):
+ """Make a 'C' string suitable for a BSON key."""
+ # Keys can only be text in python 3.
+ if "\x00" in string:
+ raise InvalidDocument("BSON keys / regex patterns must not "
+ "contain a NUL character")
+ return _utf_8_encode(string)[0] + b"\x00"
 
 
 def _encode_float(name, value, dummy0, dummy1):
  """Encode a float."""
  return b"\x01" + name + _PACK_FLOAT(value)
 
 
-if PY3:
- def _encode_bytes(name, value, dummy0, dummy1):
- """Encode a python bytes."""
- # Python3 special case. Store 'bytes' as BSON binary subtype 0.
- return b"\x05" + name + _PACK_INT(len(value)) + b"\x00" + value
-else:
- def _encode_bytes(name, value, dummy0, dummy1):
- """Encode a python str (python 2.x)."""
- try:
- _utf_8_decode(value, None, True)
- except UnicodeError:
- raise InvalidStringData("strings in documents must be valid "
- "UTF-8: %r" % (value,))
- return b"\x02" + name + _PACK_INT(len(value) + 1) + value + b"\x00"
+def _encode_bytes(name, value, dummy0, dummy1):
+ """Encode a python bytes."""
+ # Python3 special case. Store 'bytes' as BSON binary subtype 0.
+ return b"\x05" + name + _PACK_INT(len(value)) + b"\x00" + value
 
 
 def _encode_mapping(name, value, check_keys, opts):
  """Encode a mapping type."""
  if _raw_document_class(value):
  return b'\x03' + name + value.raw
  data = b"".join([_element_to_bson(key, val, check_keys, opts)
- for key, val in iteritems(value)])
+ for key, val in value.items()])
  return b"\x03" + name + _PACK_INT(len(data) + 5) + data + b"\x00"
 
 
@@ -603,7 +555,7 @@ def _encode_dbref(name, value, check_keys, opts):
  if value.database is not None:
  buf += _name_value_to_bson(
  b"$db\x00", value.database, check_keys, opts)
- for key, val in iteritems(value._DBRef__kwargs):
+ for key, val in value._DBRef__kwargs.items():
  buf += _element_to_bson(key, val, check_keys, opts)
 
  buf += b"\x00"
@@ -751,8 +703,7 @@ def _encode_maxkey(name, dummy0, dummy1, dummy2):
  float: _encode_float,
  int: _encode_int,
  list: _encode_list,
- # unicode in py2, str in py3
- text_type: _encode_text,
+ str: _encode_text,
  tuple: _encode_list,
  type(None): _encode_none,
  uuid.UUID: _encode_uuid,
@@ -770,7 +721,7 @@ def _encode_maxkey(name, dummy0, dummy1, dummy2):
  UUIDLegacy: _encode_binary,
  Decimal128: _encode_decimal128,
  # Special case. This will never be looked up directly.
- abc.Mapping: _encode_mapping,
+ _abc.Mapping: _encode_mapping,
 }
 
 
@@ -786,9 +737,6 @@ def _encode_maxkey(name, dummy0, dummy1, dummy2):
  255: _encode_minkey,
 }
 
-if not PY3:
- _ENCODERS[long] = _encode_long
-
 
 _BUILT_IN_TYPES = tuple(t for t in _ENCODERS)
 
@@ -848,7 +796,7 @@ def _name_value_to_bson(name, value, check_keys, opts,
 
 def _element_to_bson(key, value, check_keys, opts):
  """Encode a single key, value pair."""
- if not isinstance(key, string_type):
+ if not isinstance(key, str):
  raise InvalidDocument("documents must have only string keys, "
  "key was %r" % (key,))
  if check_keys:
@@ -870,7 +818,7 @@ def _dict_to_bson(doc, check_keys, opts, top_level=True):
  if top_level and "_id" in doc:
  elements.append(_name_value_to_bson(b"_id\x00", doc["_id"],
  check_keys, opts))
- for (key, value) in iteritems(doc):
+ for key, value in doc.items():
  if not top_level or key != "_id":
  elements.append(_element_to_bson(key, value,
  check_keys, opts))
@@ -1017,7 +965,7 @@ def decode_all(data, codec_options=DEFAULT_CODEC_OPTIONS):
  if data_len - position < obj_size:
  raise InvalidBSON("invalid object size")
  obj_end = position + obj_size - 1
- if data[obj_end] != _OBJEND:
+ if data[obj_end] != 0:
  raise InvalidBSON("bad eoo")
  if use_raw:
  docs.append(
@@ -1036,7 +984,7 @@ def decode_all(data, codec_options=DEFAULT_CODEC_OPTIONS):
  except Exception:
  # Change exception type to InvalidBSON but preserve traceback.
  _, exc_value, exc_tb = sys.exc_info()
- reraise(InvalidBSON, exc_value, exc_tb)
+ raise InvalidBSON(str(exc_value)).with_traceback(exc_tb)
 
 
 if _USE_C:
@@ -1051,7 +999,7 @@ def _decode_selective(rawdoc, fields, codec_options):
  else:
  # Else, use the specified document_class.
  doc = codec_options.document_class()
- for key, value in iteritems(rawdoc):
+ for key, value in rawdoc.items():
  if key in fields:
  if fields[key] == 1:
  doc[key] = _bson_to_dict(rawdoc.raw, codec_options)[key]

bson/binary.py

@@ -15,8 +15,6 @@
 from uuid import UUID
 from warnings import warn
 
-from bson.py3compat import PY3
-
 """Tools for representing BSON binary data.
 """
 
@@ -318,7 +316,7 @@ def subtype(self):
  def __getnewargs__(self):
  # Work around http://bugs.python.org/issue7382
  data = super(Binary, self).__getnewargs__()[0]
- if PY3 and not isinstance(data, bytes):
+ if not isinstance(data, bytes):
  data = data.encode('latin-1')
  return data, self.__subtype
 

bson/code.py

@@ -15,7 +15,7 @@
 """Tools for representing JavaScript code in BSON.
 """
 
-from bson.py3compat import abc, string_type, PY3, text_type
+from collections.abc import Mapping as _Mapping
 
 
 class Code(str):
@@ -49,22 +49,18 @@ class Code(str):
  _type_marker = 13
 
  def __new__(cls, code, scope=None, **kwargs):
- if not isinstance(code, string_type):
- raise TypeError("code must be an "
- "instance of %s" % (string_type.__name__))
+ if not isinstance(code, str):
+ raise TypeError("code must be an instance of str")
 
- if not PY3 and isinstance(code, text_type):
- self = str.__new__(cls, code.encode('utf8'))
- else:
- self = str.__new__(cls, code)
+ self = str.__new__(cls, code)
 
  try:
  self.__scope = code.scope
  except AttributeError:
  self.__scope = None
 
  if scope is not None:
- if not isinstance(scope, abc.Mapping):
+ if not isinstance(scope, _Mapping):
  raise TypeError("scope must be an instance of dict")
  if self.__scope is not None:
  self.__scope.update(scope)