PYTHON-2133 Remove u prefixes from code

Author: behackett

pymongo/bulk.py

@@ -54,12 +54,6 @@
 _COMMANDS = ('insert', 'update', 'delete')
 
 
-# These string literals are used when we create fake server return
-# documents client side. We use unicode literals in python 2.x to
-# match the actual return values from the server.
-_UOP = u"op"
-
-
 class _Run(object):
  """Represents a batch of write operations.
  """
@@ -123,7 +117,7 @@ def _merge_command(run, full_result, offset, result):
  idx = doc["index"] + offset
  replacement["index"] = run.index(idx)
  # Add the failed operation to the error document.
- replacement[_UOP] = run.ops[idx]
+ replacement["op"] = run.ops[idx]
  full_result["writeErrors"].append(replacement)
 
  wc_error = result.get("writeConcernError")

pymongo/collection.py

@@ -52,7 +52,6 @@
  UpdateResult)
 from pymongo.write_concern import WriteConcern
 
-_UJOIN = u"%s.%s"
 _FIND_AND_MODIFY_DOC_FIELDS = {'value': 1}
 _HAYSTACK_MSG = (
  "geoHaystack indexes are deprecated as of MongoDB 4.4."
@@ -179,7 +178,7 @@ def __init__(self, database, name, create=False, codec_options=None,
 
  self.__database = database
  self.__name = name
- self.__full_name = _UJOIN % (self.__database.name, self.__name)
+ self.__full_name = "%s.%s" % (self.__database.name, self.__name)
  if create or kwargs or collation:
  self.__create(kwargs, collation, session)
 
@@ -272,7 +271,7 @@ def __getattr__(self, name):
  - `name`: the name of the collection to get
  """
  if name.startswith('_'):
- full_name = _UJOIN % (self.__name, name)
+ full_name = "%s.%s" % (self.__name, name)
  raise AttributeError(
  "Collection has no attribute %r. To access the %s"
  " collection, use database['%s']." % (
@@ -281,7 +280,7 @@ def __getattr__(self, name):
 
  def __getitem__(self, name):
  return Collection(self.__database,
- _UJOIN % (self.__name, name),
+ "%s.%s" % (self.__name, name),
  False,
  self.codec_options,
  self.read_preference,

pymongo/helpers.py

@@ -53,12 +53,11 @@
  9001, # SocketException
  262, # ExceededTimeLimit
 ])
-_UUNDER = u"_"
 
 
 def _gen_index_name(keys):
  """Generate an index name from the set of fields it is over."""
- return _UUNDER.join(["%s_%s" % item for item in keys])
+ return "_".join(["%s_%s" % item for item in keys])
 
 
 def _index_list(key_or_list, direction=None):

pymongo/message.py

@@ -81,8 +81,6 @@
  'delete': 'deletes'
 }
 
-_UJOIN = u"%s.%s"
-
 _UNICODE_REPLACE_CODEC_OPTIONS = CodecOptions(
  unicode_decode_error_handler='replace')
 
@@ -263,7 +261,7 @@ def __init__(self, flags, db, coll, ntoskip, spec, fields,
  self._as_command = None
 
  def namespace(self):
- return _UJOIN % (self.db, self.coll)
+ return "%s.%s" % (self.db, self.coll)
 
  def use_command(self, sock_info, exhaust):
  use_find_cmd = False
@@ -346,7 +344,7 @@ def get_message(self, set_slave_ok, sock_info, use_cmd=False):
  set_slave_ok, False, self.codec_options,
  ctx=sock_info.compression_context)
  return request_id, msg, size
- ns = _UJOIN % (self.db, "$cmd")
+ ns = "%s.%s" % (self.db, "$cmd")
  ntoreturn = -1 # All DB commands return 1 document
  else:
  # OP_QUERY treats ntoreturn of -1 and 1 the same, return
@@ -393,7 +391,7 @@ def __init__(self, db, coll, ntoreturn, cursor_id, codec_options,
  self._as_command = None
 
  def namespace(self):
- return _UJOIN % (self.db, self.coll)
+ return "%s.%s" % (self.db, self.coll)
 
  def use_command(self, sock_info, exhaust):
  sock_info.validate_session(self.client, self.session)
@@ -435,7 +433,7 @@ def get_message(self, dummy0, sock_info, use_cmd=False):
  False, False, self.codec_options,
  ctx=sock_info.compression_context)
  return request_id, msg, size
- ns = _UJOIN % (self.db, "$cmd")
+ ns = "%s.%s" % (self.db, "$cmd")
  return query(0, ns, 0, -1, spec, None, self.codec_options, ctx=ctx)
 
  return get_more(ns, self.ntoreturn, self.cursor_id, ctx)

pymongo/saslprep.py

@@ -24,7 +24,7 @@ def saslprep(data):
  if isinstance(data, str):
  raise TypeError(
  "The stringprep module is not available. Usernames and "
- "passwords must be ASCII strings.")
+ "passwords must be instances of bytes.")
  return data
 else:
  HAVE_STRINGPREP = True
@@ -74,8 +74,8 @@ def saslprep(data, prohibit_unassigned_code_points=True):
  # commonly mapped to nothing characters to, well, nothing.
  in_table_c12 = stringprep.in_table_c12
  in_table_b1 = stringprep.in_table_b1
- data = u"".join(
- [u"\u0020" if in_table_c12(elt) else elt
+ data = "".join(
+ ["\u0020" if in_table_c12(elt) else elt
  for elt in data if not in_table_b1(elt)])
 
  # RFC3454 section 2, step 2 - Normalize

test/qcheck.py

@@ -83,7 +83,7 @@ def gen_unichar():
 
 
 def gen_unicode(gen_length):
- return lambda: u"".join([x for x in
+ return lambda: "".join([x for x in
  gen_list(gen_unichar(), gen_length)() if
  x not in ".$"])
 
@@ -116,7 +116,7 @@ def gen_regexp(gen_length):
  # TODO our patterns only consist of one letter.
  # this is because of a bug in CPython's regex equality testing,
  # which I haven't quite tracked down, so I'm just ignoring it...
- pattern = lambda: u"".join(gen_list(choose_lifted(u"a"), gen_length)())
+ pattern = lambda: "".join(gen_list(choose_lifted("a"), gen_length)())
 
  def gen_flags():
  flags = 0

test/test_binary.py

@@ -100,7 +100,7 @@ def test_exceptions(self):
  if platform.python_implementation() != "Jython":
  # Jython's memoryview accepts unicode strings...
  # https://bugs.jython.org/issue2784
- self.assertRaises(TypeError, Binary, u"hello")
+ self.assertRaises(TypeError, Binary, "hello")
 
  def test_subtype(self):
  one = Binary(b"hello")

test/test_bson.py

@@ -132,17 +132,17 @@ def helper(doc):
  self.assertEqual(doc, decoder(encoder(doc)))
 
  helper({})
- helper({"test": u"hello"})
+ helper({"test": "hello"})
  self.assertTrue(isinstance(decoder(encoder(
  {"hello": "world"}))["hello"], str))
  helper({"mike": -10120})
  helper({"long": Int64(10)})
  helper({"really big long": 2147483648})
- helper({u"hello": 0.0013109})
+ helper({"hello": 0.0013109})
  helper({"something": True})
  helper({"false": False})
- helper({"an array": [1, True, 3.8, u"world"]})
- helper({"an object": doc_class({"test": u"something"})})
+ helper({"an array": [1, True, 3.8, "world"]})
+ helper({"an object": doc_class({"test": "something"})})
  helper({"a binary": Binary(b"test", 100)})
  helper({"a binary": Binary(b"test", 128)})
  helper({"a binary": Binary(b"test", 254)})
@@ -191,7 +191,7 @@ def test_encoding_defaultdict(self):
 
  def test_basic_validation(self):
  self.assertRaises(TypeError, is_valid, 100)
- self.assertRaises(TypeError, is_valid, u"test")
+ self.assertRaises(TypeError, is_valid, "test")
  self.assertRaises(TypeError, is_valid, 10.4)
 
  self.assertInvalid(b"test")
@@ -277,22 +277,22 @@ def test_random_data_is_not_bson(self):
  qcheck.gen_string(qcheck.gen_range(0, 40)))
 
  def test_basic_decode(self):
- self.assertEqual({"test": u"hello world"},
+ self.assertEqual({"test": "hello world"},
  decode(b"\x1B\x00\x00\x00\x0E\x74\x65\x73\x74\x00\x0C"
  b"\x00\x00\x00\x68\x65\x6C\x6C\x6F\x20\x77\x6F"
  b"\x72\x6C\x64\x00\x00"))
- self.assertEqual([{"test": u"hello world"}, {}],
+ self.assertEqual([{"test": "hello world"}, {}],
  decode_all(b"\x1B\x00\x00\x00\x0E\x74\x65\x73\x74"
  b"\x00\x0C\x00\x00\x00\x68\x65\x6C\x6C"
  b"\x6f\x20\x77\x6F\x72\x6C\x64\x00\x00"
  b"\x05\x00\x00\x00\x00"))
- self.assertEqual([{"test": u"hello world"}, {}],
+ self.assertEqual([{"test": "hello world"}, {}],
  list(decode_iter(
  b"\x1B\x00\x00\x00\x0E\x74\x65\x73\x74"
  b"\x00\x0C\x00\x00\x00\x68\x65\x6C\x6C"
  b"\x6f\x20\x77\x6F\x72\x6C\x64\x00\x00"
  b"\x05\x00\x00\x00\x00")))
- self.assertEqual([{"test": u"hello world"}, {}],
+ self.assertEqual([{"test": "hello world"}, {}],
  list(decode_file_iter(BytesIO(
  b"\x1B\x00\x00\x00\x0E\x74\x65\x73\x74"
  b"\x00\x0C\x00\x00\x00\x68\x65\x6C\x6C"
@@ -380,11 +380,11 @@ def test_basic_encode(self):
 
  self.assertEqual(encode({}), BSON(b"\x05\x00\x00\x00\x00"))
  self.assertEqual(encode({}), b"\x05\x00\x00\x00\x00")
- self.assertEqual(encode({"test": u"hello world"}),
+ self.assertEqual(encode({"test": "hello world"}),
  b"\x1B\x00\x00\x00\x02\x74\x65\x73\x74\x00\x0C\x00"
  b"\x00\x00\x68\x65\x6C\x6C\x6F\x20\x77\x6F\x72\x6C"
  b"\x64\x00\x00")
- self.assertEqual(encode({u"mike": 100}),
+ self.assertEqual(encode({"mike": 100}),
  b"\x0F\x00\x00\x00\x10\x6D\x69\x6B\x65\x00\x64\x00"
  b"\x00\x00\x00")
  self.assertEqual(encode({"hello": 1.5}),
@@ -433,7 +433,7 @@ def test_basic_encode(self):
  b"=\x00\x00\x00\x0f$field\x000\x00\x00\x00\x1f\x00"
  b"\x00\x00return function(){ return x; }\x00\t\x00"
  b"\x00\x00\x08x\x00\x00\x00\x00")
- unicode_empty_scope = Code(u"function(){ return 'héllo';}", {})
+ unicode_empty_scope = Code("function(){ return 'héllo';}", {})
  self.assertEqual(encode({'$field': unicode_empty_scope}),
  b"8\x00\x00\x00\x0f$field\x00+\x00\x00\x00\x1e\x00"
  b"\x00\x00function(){ return 'h\xc3\xa9llo';}\x00\x05"
@@ -660,10 +660,10 @@ def test_non_string_keys(self):
  self.assertRaises(InvalidDocument, encode, {8.9: "test"})
 
  def test_utf8(self):
- w = {u"aéあ": u"aéあ"}
+ w = {"aéあ": "aéあ"}
  self.assertEqual(w, decode(encode(w)))
 
- # b'a\xe9' == u"aé".encode("iso-8859-1")
+ # b'a\xe9' == "aé".encode("iso-8859-1")
  iso8859_bytes = b'a\xe9'
  y = {"hello": iso8859_bytes}
  # Stored as BSON binary subtype 0.
@@ -678,16 +678,16 @@ def test_null_character(self):
  # This test doesn't make much sense in Python2
  # since {'a': '\x00'} == {'a': u'\x00'}.
  # Decoding here actually returns {'a': '\x00'}
- doc = {"a": u"\x00"}
+ doc = {"a": "\x00"}
  self.assertEqual(doc, decode(encode(doc)))
 
  self.assertRaises(InvalidDocument, encode, {b"\x00": "a"})
- self.assertRaises(InvalidDocument, encode, {u"\x00": "a"})
+ self.assertRaises(InvalidDocument, encode, {"\x00": "a"})
 
  self.assertRaises(InvalidDocument, encode,
  {"a": re.compile(b"ab\x00c")})
  self.assertRaises(InvalidDocument, encode,
- {"a": re.compile(u"ab\x00c")})
+ {"a": re.compile("ab\x00c")})
 
  def test_move_id(self):
  self.assertEqual(b"\x19\x00\x00\x00\x02_id\x00\x02\x00\x00\x00a\x00"
@@ -996,11 +996,11 @@ def test_unicode_decode_error_handler(self):
 
  dec = decode(invalid_key,
  CodecOptions(unicode_decode_error_handler="replace"))
- self.assertEqual(dec, {replaced_key: u"foobar"})
+ self.assertEqual(dec, {replaced_key: "foobar"})
 
  dec = decode(invalid_key,
  CodecOptions(unicode_decode_error_handler="ignore"))
- self.assertEqual(dec, {ignored_key: u"foobar"})
+ self.assertEqual(dec, {ignored_key: "foobar"})
 
  self.assertRaises(InvalidBSON, decode, invalid_key, CodecOptions(
  unicode_decode_error_handler="strict"))
@@ -1014,11 +1014,11 @@ def test_unicode_decode_error_handler(self):
 
  dec = decode(invalid_val,
  CodecOptions(unicode_decode_error_handler="replace"))
- self.assertEqual(dec, {u"keystr": replaced_val})
+ self.assertEqual(dec, {"keystr": replaced_val})
 
  dec = decode(invalid_val,
  CodecOptions(unicode_decode_error_handler="ignore"))
- self.assertEqual(dec, {u"keystr": ignored_val})
+ self.assertEqual(dec, {"keystr": ignored_val})
 
  self.assertRaises(InvalidBSON, decode, invalid_val, CodecOptions(
  unicode_decode_error_handler="strict"))

test/test_client.py

@@ -712,8 +712,8 @@ def test_list_databases(self):
  self.assertEqual(["name"], list(doc))
 
  def test_list_database_names(self):
- self.client.pymongo_test.test.insert_one({"dummy": u"object"})
- self.client.pymongo_test_mike.test.insert_one({"dummy": u"object"})
+ self.client.pymongo_test.test.insert_one({"dummy": "object"})
+ self.client.pymongo_test_mike.test.insert_one({"dummy": "object"})
  cmd_docs = self.client.admin.command("listDatabases")["databases"]
  cmd_names = [doc["name"] for doc in cmd_docs]
 
@@ -726,8 +726,8 @@ def test_drop_database(self):
  self.assertRaises(TypeError, self.client.drop_database, 5)
  self.assertRaises(TypeError, self.client.drop_database, None)
 
- self.client.pymongo_test.test.insert_one({"dummy": u"object"})
- self.client.pymongo_test2.test.insert_one({"dummy": u"object"})
+ self.client.pymongo_test.test.insert_one({"dummy": "object"})
+ self.client.pymongo_test2.test.insert_one({"dummy": "object"})
  dbs = self.client.list_database_names()
  self.assertIn("pymongo_test", dbs)
  self.assertIn("pymongo_test2", dbs)
@@ -1134,8 +1134,8 @@ def test_ipv6(self):
  uri += '/?replicaSet=' + client_context.replica_set_name
 
  client = rs_or_single_client_noauth(uri)
- client.pymongo_test.test.insert_one({"dummy": u"object"})
- client.pymongo_test_bernie.test.insert_one({"dummy": u"object"})
+ client.pymongo_test.test.insert_one({"dummy": "object"})
+ client.pymongo_test_bernie.test.insert_one({"dummy": "object"})
 
  dbs = client.list_database_names()
  self.assertTrue("pymongo_test" in dbs)

test/test_code.py

@@ -28,11 +28,8 @@ def test_types(self):
  self.assertRaises(TypeError, Code, 5)
  self.assertRaises(TypeError, Code, None)
  self.assertRaises(TypeError, Code, "aoeu", 5)
- self.assertRaises(TypeError, Code, u"aoeu", 5)
  self.assertTrue(Code("aoeu"))
- self.assertTrue(Code(u"aoeu"))
  self.assertTrue(Code("aoeu", {}))
- self.assertTrue(Code(u"aoeu", {}))
 
  def test_read_only(self):
  c = Code("blah")