Replace (most) calls to tornado.util.b() with byte literals.

sed -E -e "s/b\('([^']*)'\)/b'\1'/g" -i '' tornado/*.py
sed -E -e 's/b\("([^"]*)"\)/b"\1"/g' -i '' tornado/*.py

tornado/auth.py

@@ -158,7 +158,7 @@ def _openid_args(self, callback_uri, ax_attrs=[], oauth_scope=None):
         return args
 
     def _on_authentication_verified(self, callback, response):
-        if response.error or b("is_valid:true") not in response.body:
+        if response.error or b"is_valid:true" not in response.body:
             gen_log.warning("Invalid OpenID response: %s", response.error or
                             response.body)
             callback(None)
@@ -327,7 +327,7 @@ def _on_request_token(self, authorize_url, callback_uri, response):
         if response.error:
             raise Exception("Could not get request token")
         request_token = _oauth_parse_response(response.body)
-        data = (base64.b64encode(request_token["key"]) + b("|") +
+        data = (base64.b64encode(request_token["key"]) + b"|" +
                 base64.b64encode(request_token["secret"]))
         self.set_cookie("_oauth_request_token", data)
         args = dict(oauth_token=request_token["key"])
@@ -589,7 +589,7 @@ def _oauth_consumer_token(self):
     def _oauth_get_user(self, access_token, callback):
         callback = self.async_callback(self._parse_user_response, callback)
         self.twitter_request(
-            "/users/show/" + escape.native_str(access_token[b("screen_name")]),
+            "/users/show/" + escape.native_str(access_token[b"screen_name"]),
             access_token=access_token, callback=callback)
 
     def _parse_user_response(self, callback, user):
@@ -1157,7 +1157,7 @@ def _oauth_signature(consumer_token, method, url, parameters={}, token=None):
 
     key_elems = [escape.utf8(consumer_token["secret"])]
     key_elems.append(escape.utf8(token["secret"] if token else ""))
-    key = b("&").join(key_elems)
+    key = b"&".join(key_elems)
 
     hash = hmac.new(key, escape.utf8(base_string), hashlib.sha1)
     return binascii.b2a_base64(hash.digest())[:-1]
@@ -1181,7 +1181,7 @@ def _oauth10a_signature(consumer_token, method, url, parameters={}, token=None):
     base_string = "&".join(_oauth_escape(e) for e in base_elems)
     key_elems = [escape.utf8(urllib_parse.quote(consumer_token["secret"], safe='~'))]
     key_elems.append(escape.utf8(urllib_parse.quote(token["secret"], safe='~') if token else ""))
-    key = b("&").join(key_elems)
+    key = b"&".join(key_elems)
 
     hash = hmac.new(key, escape.utf8(base_string), hashlib.sha1)
     return binascii.b2a_base64(hash.digest())[:-1]
@@ -1195,9 +1195,9 @@ def _oauth_escape(val):
 
 def _oauth_parse_response(body):
     p = escape.parse_qs(body, keep_blank_values=False)
-    token = dict(key=p[b("oauth_token")][0], secret=p[b("oauth_token_secret")][0])
+    token = dict(key=p[b"oauth_token"][0], secret=p[b"oauth_token_secret"][0])
 
     # Add the extra parameters the Provider included to the token
-    special = (b("oauth_token"), b("oauth_token_secret"))
+    special = (b"oauth_token", b"oauth_token_secret")
     token.update((k, p[k][0]) for k in p if k not in special)
     return token

tornado/httpserver.py

@@ -183,7 +183,7 @@ def __init__(self, stream, address, request_callback, no_keep_alive=False,
         # Save stack context here, outside of any request.  This keeps
         # contexts from one request from leaking into the next.
         self._header_callback = stack_context.wrap(self._on_headers)
-        self.stream.read_until(b("\r\n\r\n"), self._header_callback)
+        self.stream.read_until(b"\r\n\r\n", self._header_callback)
         self._write_callback = None
 
     def close(self):
@@ -244,7 +244,7 @@ def _finish_request(self):
             # Use a try/except instead of checking stream.closed()
             # directly, because in some cases the stream doesn't discover
             # that it's closed until you try to read from it.
-            self.stream.read_until(b("\r\n\r\n"), self._header_callback)
+            self.stream.read_until(b"\r\n\r\n", self._header_callback)
         except iostream.StreamClosedError:
             self.close()
 
@@ -281,7 +281,7 @@ def _on_headers(self, data):
                 if content_length > self.stream.max_buffer_size:
                     raise _BadRequestException("Content-Length too long")
                 if headers.get("Expect") == "100-continue":
-                    self.stream.write(b("HTTP/1.1 100 (Continue)\r\n\r\n"))
+                    self.stream.write(b"HTTP/1.1 100 (Continue)\r\n\r\n")
                 self.stream.read_bytes(content_length, self._on_request_body)
                 return
 

tornado/httputil.py

@@ -252,24 +252,24 @@ def parse_multipart_form_data(boundary, data, arguments, files):
     # xmpp).  I think we're also supposed to handle backslash-escapes
     # here but I'll save that until we see a client that uses them
     # in the wild.
-    if boundary.startswith(b('"')) and boundary.endswith(b('"')):
+    if boundary.startswith(b'"') and boundary.endswith(b'"'):
         boundary = boundary[1:-1]
-    final_boundary_index = data.rfind(b("--") + boundary + b("--"))
+    final_boundary_index = data.rfind(b"--" + boundary + b"--")
     if final_boundary_index == -1:
         gen_log.warning("Invalid multipart/form-data: no final boundary")
         return
-    parts = data[:final_boundary_index].split(b("--") + boundary + b("\r\n"))
+    parts = data[:final_boundary_index].split(b"--" + boundary + b"\r\n")
     for part in parts:
         if not part:
             continue
-        eoh = part.find(b("\r\n\r\n"))
+        eoh = part.find(b"\r\n\r\n")
         if eoh == -1:
             gen_log.warning("multipart/form-data missing headers")
             continue
         headers = HTTPHeaders.parse(part[:eoh].decode("utf-8"))
         disp_header = headers.get("Content-Disposition", "")
         disposition, disp_params = _parse_header(disp_header)
-        if disposition != "form-data" or not part.endswith(b("\r\n")):
+        if disposition != "form-data" or not part.endswith(b"\r\n"):
             gen_log.warning("Invalid multipart/form-data")
             continue
         value = part[eoh + 4:-2]

tornado/iostream.py

@@ -521,7 +521,7 @@ def _handle_write(self):
 
     def _consume(self, loc):
         if loc == 0:
-            return b("")
+            return b""
         _merge_prefix(self._read_buffer, loc)
         self._read_buffer_size -= loc
         return self._read_buffer.popleft()
@@ -905,7 +905,7 @@ def _merge_prefix(deque, size):
     if prefix:
         deque.appendleft(type(prefix[0])().join(prefix))
     if not deque:
-        deque.appendleft(b(""))
+        deque.appendleft(b"")
 
 
 def doctests():

tornado/platform/common.py

@@ -74,7 +74,7 @@ def write_fileno(self):
 
     def wake(self):
         try:
-            self.writer.send(b("x"))
+            self.writer.send(b"x")
         except (IOError, socket.error):
             pass
 

tornado/platform/posix.py

@@ -53,7 +53,7 @@ def write_fileno(self):
 
     def wake(self):
         try:
-            self.writer.write(b("x"))
+            self.writer.write(b"x")
         except IOError:
             pass
 

tornado/simple_httpclient.py

@@ -269,8 +269,8 @@ def _on_connect(self):
             username = self.request.auth_username
             password = self.request.auth_password or ''
         if username is not None:
-            auth = utf8(username) + b(":") + utf8(password)
-            self.request.headers["Authorization"] = (b("Basic ") +
+            auth = utf8(username) + b":" + utf8(password)
+            self.request.headers["Authorization"] = (b"Basic " +
                                                      base64.b64encode(auth))
         if self.request.user_agent:
             self.request.headers["User-Agent"] = self.request.user_agent
@@ -292,14 +292,14 @@ def _on_connect(self):
         request_lines = [utf8("%s %s HTTP/1.1" % (self.request.method,
                                                   req_path))]
         for k, v in self.request.headers.get_all():
-            line = utf8(k) + b(": ") + utf8(v)
-            if b('\n') in line:
+            line = utf8(k) + b": " + utf8(v)
+            if b'\n' in line:
                 raise ValueError('Newline in header: ' + repr(line))
             request_lines.append(line)
-        self.stream.write(b("\r\n").join(request_lines) + b("\r\n\r\n"))
+        self.stream.write(b"\r\n".join(request_lines) + b"\r\n\r\n")
         if self.request.body is not None:
             self.stream.write(self.request.body)
-        self.stream.read_until_regex(b("\r?\n\r?\n"), self._on_headers)
+        self.stream.read_until_regex(b"\r?\n\r?\n", self._on_headers)
 
     def _release(self):
         if self.release_callback is not None:
@@ -345,7 +345,7 @@ def _on_headers(self, data):
         assert match
         code = int(match.group(1))
         if 100 <= code < 200:
-            self.stream.read_until_regex(b("\r?\n\r?\n"), self._on_headers)
+            self.stream.read_until_regex(b"\r?\n\r?\n", self._on_headers)
             return
         else:
             self.code = code
@@ -376,7 +376,7 @@ def _on_headers(self, data):
         if self.request.method == "HEAD" or self.code == 304:
             # HEAD requests and 304 responses never have content, even
             # though they may have content-length headers
-            self._on_body(b(""))
+            self._on_body(b"")
             return
         if 100 <= self.code < 200 or self.code == 204:
             # These response codes never have bodies
@@ -385,15 +385,15 @@ def _on_headers(self, data):
                 content_length not in (None, 0)):
                 raise ValueError("Response with code %d should not have body" %
                                  self.code)
-            self._on_body(b(""))
+            self._on_body(b"")
             return
 
         if (self.request.use_gzip and
             self.headers.get("Content-Encoding") == "gzip"):
             self._decompressor = GzipDecompressor()
         if self.headers.get("Transfer-Encoding") == "chunked":
             self.chunks = []
-            self.stream.read_until(b("\r\n"), self._on_chunk_length)
+            self.stream.read_until(b"\r\n", self._on_chunk_length)
         elif content_length is not None:
             self.stream.read_bytes(content_length, self._on_body)
         else:
@@ -476,21 +476,21 @@ def _on_chunk_length(self, data):
                 # all the data has been decompressed, so we don't need to
                 # decompress again in _on_body
                 self._decompressor = None
-            self._on_body(b('').join(self.chunks))
+            self._on_body(b''.join(self.chunks))
         else:
             self.stream.read_bytes(length + 2,  # chunk ends with \r\n
                               self._on_chunk_data)
 
     def _on_chunk_data(self, data):
-        assert data[-2:] == b("\r\n")
+        assert data[-2:] == b"\r\n"
         chunk = data[:-2]
         if self._decompressor:
             chunk = self._decompressor.decompress(chunk)
         if self.request.streaming_callback is not None:
             self.request.streaming_callback(chunk)
         else:
             self.chunks.append(chunk)
-        self.stream.read_until(b("\r\n"), self._on_chunk_length)
+        self.stream.read_until(b"\r\n", self._on_chunk_length)
 
 
 # match_hostname was added to the standard library ssl module in python 3.2.

tornado/test/auth_test.py

@@ -61,7 +61,7 @@ def on_user(self, user):
         self.finish(user)
 
     def _oauth_get_user(self, access_token, callback):
-        if access_token != dict(key=b('uiop'), secret=b('5678')):
+        if access_token != dict(key=b'uiop', secret=b'5678'):
             raise Exception("incorrect access token %r" % access_token)
         callback(dict(email='[email protected]'))
 

tornado/test/concurrent_test.py

@@ -31,13 +31,13 @@ class CapServer(TCPServer):
     def handle_stream(self, stream, address):
         logging.info("handle_stream")
         self.stream = stream
-        self.stream.read_until(b("\n"), self.handle_read)
+        self.stream.read_until(b"\n", self.handle_read)
 
     def handle_read(self, data):
         logging.info("handle_read")
         data = to_unicode(data)
         if data == data.upper():
-            self.stream.write(b("error\talready capitalized\n"))
+            self.stream.write(b"error\talready capitalized\n")
         else:
             # data already has \n
             self.stream.write(utf8("ok\t%s" % data.upper()))
@@ -76,7 +76,7 @@ def capitalize(self, request_data, callback=None):
     def handle_connect(self):
         logging.info("handle_connect")
         self.stream.write(utf8(self.request_data + "\n"))
-        self.stream.read_until(b('\n'), callback=self.handle_read)
+        self.stream.read_until(b'\n', callback=self.handle_read)
 
     def handle_read(self, data):
         logging.info("handle_read")
@@ -100,7 +100,7 @@ def capitalize(self, request_data, callback):
     def handle_connect(self):
         logging.info("handle_connect")
         self.stream.write(utf8(self.request_data + "\n"))
-        self.stream.read_until(b('\n'), callback=self.handle_read)
+        self.stream.read_until(b'\n', callback=self.handle_read)
 
     def handle_read(self, data):
         logging.info("handle_read")
@@ -118,7 +118,7 @@ def capitalize(self, request_data, callback):
         yield gen.Task(stream.connect, ('127.0.0.1', self.port))
         stream.write(utf8(request_data + '\n'))
         logging.info('reading')
-        data = yield gen.Task(stream.read_until, b('\n'))
+        data = yield gen.Task(stream.read_until, b'\n')
         logging.info('returning')
         stream.close()
         callback(self.process_response(data))

tornado/test/escape_test.py

@@ -142,7 +142,7 @@ def test_xhtml_escape(self):
         tests = [
             ("<foo>", "&lt;foo&gt;"),
             (u("<foo>"), u("&lt;foo&gt;")),
-            (b("<foo>"), b("&lt;foo&gt;")),
+            (b"<foo>", b"&lt;foo&gt;"),
 
             ("<>&\"", "&lt;&gt;&amp;&quot;"),
             ("&amp;", "&amp;amp;"),
@@ -185,7 +185,7 @@ def test_escape_return_types(self):
     def test_json_decode(self):
         # json_decode accepts both bytes and unicode, but strings it returns
         # are always unicode.
-        self.assertEqual(json_decode(b('"foo"')), u("foo"))
+        self.assertEqual(json_decode(b'"foo"'), u("foo"))
         self.assertEqual(json_decode(u('"foo"')), u("foo"))
 
         # Non-ascii bytes are interpreted as utf8
@@ -196,4 +196,4 @@ def test_json_encode(self):
         # accept bytes as well as long as they are utf8.
         self.assertEqual(json_decode(json_encode(u("\u00e9"))), u("\u00e9"))
         self.assertEqual(json_decode(json_encode(utf8(u("\u00e9")))), u("\u00e9"))
-        self.assertRaises(UnicodeDecodeError, json_encode, b("\xe9"))
+        self.assertRaises(UnicodeDecodeError, json_encode, b"\xe9")

tornado/test/gen_test.py

@@ -318,7 +318,7 @@ def get(self):
         client = AsyncHTTPClient(io_loop=io_loop)
         response = yield gen.Task(client.fetch, self.get_argument('url'))
         response.rethrow()
-        self.finish(b("got response: ") + response.body)
+        self.finish(b"got response: " + response.body)
 
 
 class GenExceptionHandler(RequestHandler):
@@ -358,11 +358,11 @@ def get_app(self):
 
     def test_sequence_handler(self):
         response = self.fetch('/sequence')
-        self.assertEqual(response.body, b("123"))
+        self.assertEqual(response.body, b"123")
 
     def test_task_handler(self):
         response = self.fetch('/task?url=%s' % url_escape(self.get_url('/sequence')))
-        self.assertEqual(response.body, b("got response: 123"))
+        self.assertEqual(response.body, b"got response: 123")
 
     def test_exception_handler(self):
         # Make sure we get an error and not a timeout
@@ -372,4 +372,4 @@ def test_exception_handler(self):
 
     def test_yield_exception_handler(self):
         response = self.fetch('/yield_exception')
-        self.assertEqual(response.body, b('ok'))
+        self.assertEqual(response.body, b'ok')