开源软件构建与测试

_service:tar_scm:python-tornado.spec Changed

_service:tar_scm:CVE-2023-28370.patch Deleted

@@ -1,35 +0,0 @@
-From 32ad07c54e607839273b4e1819c347f5c8976b2f Mon Sep 17 00:00:00 2001
-From: Ben Darnell <ben@bendarnell.com>
-Date: Sat, 13 May 2023 20:58:52 -0400
-Subject: PATCH web: Fix an open redirect in StaticFileHandler
-
-Under some configurations the default_filename redirect could be exploited
-to redirect to an attacker-controlled site. This change refuses to redirect
-to URLs that could be misinterpreted.
-
-A test case for the specific vulnerable configuration will follow after the
-patch has been available.
----
- tornado/web.py | 9 +++++++++
- 1 file changed, 9 insertions(+)
-
-diff --git a/tornado/web.py b/tornado/web.py
-index 3b676e3c2..565140493 100644
---- a/tornado/web.py
-+++ b/tornado/web.py
-@@ -2879,6 +2879,15 @@ def validate_absolute_path(self, root: str, absolute_path: str) -> Optionalstr
-             # but there is some prefix to the path that was already
-             # trimmed by the routing
-             if not self.request.path.endswith("/"):
-+                if self.request.path.startswith("//"):
-+                    # A redirect with two initial slashes is a "protocol-relative" URL.
-+                    # This means the next path segment is treated as a hostname instead
-+                    # of a part of the path, making this effectively an open redirect.
-+                    # Reject paths starting with two slashes to prevent this.
-+                    # This is only reachable under certain configurations.
-+                    raise HTTPError(
-+                        403, "cannot redirect path with two initial slashes"
-+                    )
-                 self.redirect(self.request.path + "/", permanent=True)
-                 return None
-             absolute_path = os.path.join(absolute_path, self.default_filename)

_service:tar_scm:tornado-6.1.tar.gz/docs/requirements.txt Deleted

_service:tar_scm:tornado-6.1.tar.gz/PKG-INFO -> _service:tar_scm:tornado-6.3.2.tar.gz/PKG-INFO Changed

@@ -1,68 +1,75 @@
-Metadata-Version: 1.2
+Metadata-Version: 2.1
 Name: tornado
-Version: 6.1
+Version: 6.3.2
 Summary: Tornado is a Python web framework and asynchronous networking library, originally developed at FriendFeed.
 Home-page: http://www.tornadoweb.org/
 Author: Facebook
 Author-email: python-tornado@googlegroups.com
-License: http://www.apache.org/licenses/LICENSE-2.0
-Description: Tornado Web Server
-        ==================
-        
-        .. image:: https://badges.gitter.im/Join%20Chat.svg
-           :alt: Join the chat at https://gitter.im/tornadoweb/tornado
-           :target: https://gitter.im/tornadoweb/tornado?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge
-        
-        `Tornado <http://www.tornadoweb.org>`_ is a Python web framework and
-        asynchronous networking library, originally developed at `FriendFeed
-        <http://friendfeed.com>`_.  By using non-blocking network I/O, Tornado
-        can scale to tens of thousands of open connections, making it ideal for
-        `long polling <http://en.wikipedia.org/wiki/Push_technology#Long_Polling>`_,
-        `WebSockets <http://en.wikipedia.org/wiki/WebSocket>`_, and other
-        applications that require a long-lived connection to each user.
-        
-        Hello, world
-        ------------
-        
-        Here is a simple "Hello, world" example web app for Tornado:
-        
-        .. code-block:: python
-        
-            import tornado.ioloop
-            import tornado.web
-        
-            class MainHandler(tornado.web.RequestHandler):
-                def get(self):
-                    self.write("Hello, world")
-        
-            def make_app():
-                return tornado.web.Application(
-                    (r"/", MainHandler),
-                )
-        
-            if __name__ == "__main__":
-                app = make_app()
-                app.listen(8888)
-                tornado.ioloop.IOLoop.current().start()
-        
-        This example does not use any of Tornado's asynchronous features; for
-        that see this `simple chat room
-        <https://github.com/tornadoweb/tornado/tree/stable/demos/chat>`_.
-        
-        Documentation
-        -------------
-        
-        Documentation and links to additional resources are available at
-        https://www.tornadoweb.org
-        
+License: Apache-2.0
+Project-URL: Source, https://github.com/tornadoweb/tornado
 Platform: UNKNOWN
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.5
-Classifier: Programming Language :: Python :: 3.6
-Classifier: Programming Language :: Python :: 3.7
 Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy
-Requires-Python: >= 3.5
+Requires-Python: >= 3.8
+Description-Content-Type: text/x-rst
+License-File: LICENSE
+
+Tornado Web Server
+==================
+
+.. image:: https://badges.gitter.im/Join%20Chat.svg
+   :alt: Join the chat at https://gitter.im/tornadoweb/tornado
+   :target: https://gitter.im/tornadoweb/tornado?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge
+
+`Tornado <http://www.tornadoweb.org>`_ is a Python web framework and
+asynchronous networking library, originally developed at `FriendFeed
+<http://friendfeed.com>`_.  By using non-blocking network I/O, Tornado
+can scale to tens of thousands of open connections, making it ideal for
+`long polling <http://en.wikipedia.org/wiki/Push_technology#Long_Polling>`_,
+`WebSockets <http://en.wikipedia.org/wiki/WebSocket>`_, and other
+applications that require a long-lived connection to each user.
+
+Hello, world
+------------
+
+Here is a simple "Hello, world" example web app for Tornado:
+
+.. code-block:: python
+
+    import asyncio
+    import tornado
+
+    class MainHandler(tornado.web.RequestHandler):
+        def get(self):
+            self.write("Hello, world")
+
+    def make_app():
+        return tornado.web.Application(
+            (r"/", MainHandler),
+        )
+
+    async def main():
+        app = make_app()
+        app.listen(8888)
+        await asyncio.Event().wait()
+
+    if __name__ == "__main__":
+        asyncio.run(main())
+
+This example does not use any of Tornado's asynchronous features; for
+that see this `simple chat room
+<https://github.com/tornadoweb/tornado/tree/stable/demos/chat>`_.
+
+Documentation
+-------------
+
+Documentation and links to additional resources are available at
+https://www.tornadoweb.org
+
+

_service:tar_scm:tornado-6.1.tar.gz/README.rst -> _service:tar_scm:tornado-6.3.2.tar.gz/README.rst Changed

_service:tar_scm:tornado-6.1.tar.gz/demos/blog/README -> _service:tar_scm:tornado-6.3.2.tar.gz/demos/blog/README Changed

_service:tar_scm:tornado-6.1.tar.gz/demos/blog/blog.py -> _service:tar_scm:tornado-6.3.2.tar.gz/demos/blog/blog.py Changed

@@ -15,17 +15,13 @@
 # under the License.
 
 import aiopg
+import asyncio
 import bcrypt
 import markdown
 import os.path
 import psycopg2
 import re
-import tornado.escape
-import tornado.httpserver
-import tornado.ioloop
-import tornado.locks
-import tornado.options
-import tornado.web
+import tornado
 import unicodedata
 
 from tornado.options import define, options
@@ -68,7 +64,7 @@
             (r"/auth/logout", AuthLogoutHandler),
         
         settings = dict(
-            blog_title=u"Tornado Blog",
+            blog_title="Tornado Blog",
             template_path=os.path.join(os.path.dirname(__file__), "templates"),
             static_path=os.path.join(os.path.dirname(__file__), "static"),
             ui_modules={"Entry": EntryModule},
@@ -127,7 +123,7 @@
     async def prepare(self):
         # get_current_user cannot be a coroutine, so set
         # self.current_user in prepare instead.
-        user_id = self.get_secure_cookie("blogdemo_user")
+        user_id = self.get_signed_cookie("blogdemo_user")
         if user_id:
             self.current_user = await self.queryone(
                 "SELECT * FROM authors WHERE id = %s", int(user_id)
@@ -246,7 +242,7 @@
             self.get_argument("name"),
             tornado.escape.to_unicode(hashed_password),
         )
-        self.set_secure_cookie("blogdemo_user", str(author.id))
+        self.set_signed_cookie("blogdemo_user", str(author.id))
         self.redirect(self.get_argument("next", "/"))
 
 
@@ -273,7 +269,7 @@
             tornado.escape.utf8(author.hashed_password),
         )
         if password_equal:
-            self.set_secure_cookie("blogdemo_user", str(author.id))
+            self.set_signed_cookie("blogdemo_user", str(author.id))
             self.redirect(self.get_argument("next", "/"))
         else:
             self.render("login.html", error="incorrect password")
@@ -313,4 +309,4 @@
 
 
 if __name__ == "__main__":
-    tornado.ioloop.IOLoop.current().run_sync(main)
+    asyncio.run(main())

_service:tar_scm:tornado-6.1.tar.gz/demos/chat/chatdemo.py -> _service:tar_scm:tornado-6.3.2.tar.gz/demos/chat/chatdemo.py Changed

_service:tar_scm:tornado-6.1.tar.gz/demos/facebook/facebook.py -> _service:tar_scm:tornado-6.3.2.tar.gz/demos/facebook/facebook.py Changed

@@ -14,13 +14,9 @@
 # License for the specific language governing permissions and limitations
 # under the License.
 
+import asyncio
 import os.path
-import tornado.auth
-import tornado.escape
-import tornado.httpserver
-import tornado.ioloop
-import tornado.options
-import tornado.web
+import tornado
 
 from tornado.options import define, options
 
@@ -53,7 +49,7 @@
 
 class BaseHandler(tornado.web.RequestHandler):
     def get_current_user(self):
-        user_json = self.get_secure_cookie("fbdemo_user")
+        user_json = self.get_signed_cookie("fbdemo_user")
         if not user_json:
             return None
         return tornado.escape.json_decode(user_json)
@@ -88,7 +84,7 @@
                 client_secret=self.settings"facebook_secret",
                 code=self.get_argument("code"),
             )
-            self.set_secure_cookie("fbdemo_user", tornado.escape.json_encode(user))
+            self.set_signed_cookie("fbdemo_user", tornado.escape.json_encode(user))
             self.redirect(self.get_argument("next", "/"))
             return
         self.authorize_redirect(
@@ -109,15 +105,15 @@
         return self.render_string("modules/post.html", post=post)
 
 
-def main():
+async def main():
     tornado.options.parse_command_line()
     if not (options.facebook_api_key and options.facebook_secret):
         print("--facebook_api_key and --facebook_secret must be set")
         return
     http_server = tornado.httpserver.HTTPServer(Application())
     http_server.listen(options.port)
-    tornado.ioloop.IOLoop.current().start()
+    await asyncio.Event().wait()
 
 
 if __name__ == "__main__":
-    main()
+    asyncio.run(main())

_service:tar_scm:tornado-6.1.tar.gz/demos/file_upload/file_receiver.py -> _service:tar_scm:tornado-6.3.2.tar.gz/demos/file_upload/file_receiver.py Changed

_service:tar_scm:tornado-6.1.tar.gz/demos/file_upload/file_uploader.py -> _service:tar_scm:tornado-6.3.2.tar.gz/demos/file_upload/file_uploader.py Changed

_service:tar_scm:tornado-6.1.tar.gz/demos/helloworld/helloworld.py -> _service:tar_scm:tornado-6.3.2.tar.gz/demos/helloworld/helloworld.py Changed

_service:tar_scm:tornado-6.1.tar.gz/demos/s3server/s3server.py -> _service:tar_scm:tornado-6.3.2.tar.gz/demos/s3server/s3server.py Changed

@@ -30,6 +30,7 @@
 
 """
 
+import asyncio
 import bisect
 import datetime
 import hashlib
@@ -39,7 +40,6 @@
 
 from tornado import escape
 from tornado import httpserver
-from tornado import ioloop
 from tornado import web
 from tornado.util import unicode_type
 from tornado.options import options, define
@@ -54,12 +54,12 @@
 define("bucket_depth", default=0, help="Bucket file system depth limit")
 
 
-def start(port, root_directory, bucket_depth):
+async def start(port, root_directory, bucket_depth):
     """Starts the mock S3 server on the given port at the given path."""
     application = S3Application(root_directory, bucket_depth)
     http_server = httpserver.HTTPServer(application)
     http_server.listen(port)
-    ioloop.IOLoop.current().start()
+    await asyncio.Event().wait()
 
 
 class S3Application(web.Application):
@@ -146,8 +146,8 @@
 
 class BucketHandler(BaseRequestHandler):
     def get(self, bucket_name):
-        prefix = self.get_argument("prefix", u"")
-        marker = self.get_argument("marker", u"")
+        prefix = self.get_argument("prefix", "")
+        marker = self.get_argument("marker", "")
         max_keys = int(self.get_argument("max-keys", 50000))
         path = os.path.abspath(os.path.join(self.application.directory, bucket_name))
         terse = int(self.get_argument("terse", 0))
@@ -265,4 +265,4 @@
 
 if __name__ == "__main__":
     options.parse_command_line()
-    start(options.port, options.root_directory, options.bucket_depth)
+    asyncio.run(start(options.port, options.root_directory, options.bucket_depth))

_service:tar_scm:tornado-6.1.tar.gz/demos/tcpecho/client.py -> _service:tar_scm:tornado-6.3.2.tar.gz/demos/tcpecho/client.py Changed

_service:tar_scm:tornado-6.1.tar.gz/demos/tcpecho/server.py -> _service:tar_scm:tornado-6.3.2.tar.gz/demos/tcpecho/server.py Changed

_service:tar_scm:tornado-6.1.tar.gz/demos/twitter/twitterdemo.py -> _service:tar_scm:tornado-6.3.2.tar.gz/demos/twitter/twitterdemo.py Changed

@@ -17,11 +17,11 @@
      browser.
 """
 
+import asyncio
 import logging
 
 from tornado.auth import TwitterMixin
 from tornado.escape import json_decode, json_encode
-from tornado.ioloop import IOLoop
 from tornado import gen
 from tornado.options import define, options, parse_command_line, parse_config_file
 from tornado.web import Application, RequestHandler, authenticated
@@ -53,7 +53,7 @@
     COOKIE_NAME = "twitterdemo_user"
 
     def get_current_user(self):
-        user_json = self.get_secure_cookie(self.COOKIE_NAME)
+        user_json = self.get_signed_cookie(self.COOKIE_NAME)
         if not user_json:
             return None
         return json_decode(user_json)
@@ -75,7 +75,7 @@
         if self.get_argument("oauth_token", None):
             user = yield self.get_authenticated_user()
             del user"description"
-            self.set_secure_cookie(self.COOKIE_NAME, json_encode(user))
+            self.set_signed_cookie(self.COOKIE_NAME, json_encode(user))
             self.redirect(self.get_argument("next", "/"))
         else:
             yield self.authorize_redirect(callback_uri=self.request.full_url())
@@ -86,7 +86,7 @@
         self.clear_cookie(self.COOKIE_NAME)
 
 
-def main():
+async def main():
     parse_command_line(final=False)
     parse_config_file(options.config_file)
 
@@ -98,8 +98,8 @@
     app.listen(options.port)
 
     logging.info("Listening on http://localhost:%d" % options.port)
-    IOLoop.current().start()
+    await asyncio.Event().wait()
 
 
 if __name__ == "__main__":
-    main()
+    asyncio.run(main())

_service:tar_scm:tornado-6.1.tar.gz/demos/websocket/chatdemo.py -> _service:tar_scm:tornado-6.3.2.tar.gz/demos/websocket/chatdemo.py Changed

_service:tar_scm:tornado-6.1.tar.gz/demos/webspider/webspider.py -> _service:tar_scm:tornado-6.3.2.tar.gz/demos/webspider/webspider.py Changed

_service:tar_scm:tornado-6.1.tar.gz/docs/auth.rst -> _service:tar_scm:tornado-6.3.2.tar.gz/docs/auth.rst Changed

_service:tar_scm:tornado-6.1.tar.gz/docs/caresresolver.rst -> _service:tar_scm:tornado-6.3.2.tar.gz/docs/caresresolver.rst Changed

_service:tar_scm:tornado-6.1.tar.gz/docs/conf.py -> _service:tar_scm:tornado-6.3.2.tar.gz/docs/conf.py Changed

@@ -1,7 +1,8 @@
-# Ensure we get the local copy of tornado instead of what's on the standard path
 import os
+import sphinx.errors
 import sys
 
+# Ensure we get the local copy of tornado instead of what's on the standard path
 sys.path.insert(0, os.path.abspath(".."))
 import tornado
 
@@ -81,7 +82,7 @@
     )
 
 
-intersphinx_mapping = {"python": ("https://docs.python.org/3.6/", None)}
+intersphinx_mapping = {"python": ("https://docs.python.org/3/", None)}
 
 on_rtd = os.environ.get("READTHEDOCS", None) == "True"
 
@@ -93,3 +94,59 @@
 
     html_theme = "sphinx_rtd_theme"
     html_theme_path = sphinx_rtd_theme.get_html_theme_path()
+
+# Suppress warnings about "class reference target not found" for these types.
+# In most cases these types come from type annotations and are for mypy's use.
+missing_references = {
+    # Generic type variables; nothing to link to.
+    "_IOStreamType",
+    "_S",
+    "_T",
+    # Standard library types which are defined in one module and documented
+    # in another. We could probably remap them to their proper location if
+    # there's not an upstream fix in python and/or sphinx.
+    "_asyncio.Future",
+    "_io.BytesIO",
+    "asyncio.AbstractEventLoop.run_forever",
+    "asyncio.events.AbstractEventLoop",
+    "concurrent.futures._base.Executor",
+    "concurrent.futures._base.Future",
+    "futures.Future",
+    "socket.socket",
+    "TextIO",
+    # Other stuff. I'm not sure why some of these are showing up, but
+    # I'm just listing everything here to avoid blocking the upgrade of sphinx.
+    "Future",
+    "httputil.HTTPServerConnectionDelegate",
+    "httputil.HTTPServerRequest",
+    "OutputTransform",
+    "Pattern",
+    "RAISE",
+    "Rule",
+    "socket.AddressFamily",
+    "tornado.concurrent._T",
+    "tornado.gen._T",
+    "tornado.ioloop._S",
+    "tornado.ioloop._T",
+    "tornado.ioloop._Selectable",
+    "tornado.iostream._IOStreamType",
+    "tornado.locks._ReleasingContextManager",
+    "tornado.queues._T",
+    "tornado.options._Mockable",
+    "tornado.web._ArgDefaultMarker",
+    "tornado.web._HandlerDelegate",
+    "tornado.web._RequestHandlerType",
+    "_RequestHandlerType",
+    "traceback",
+    "WSGIAppType",
+    "Yieldable",
+}
+
+
+def missing_reference_handler(app, env, node, contnode):
+    if node"reftarget" in missing_references:
+        raise sphinx.errors.NoUri
+
+
+def setup(app):
+    app.connect("missing-reference", missing_reference_handler)

_service:tar_scm:tornado-6.1.tar.gz/docs/guide/coroutines.rst -> _service:tar_scm:tornado-6.3.2.tar.gz/docs/guide/coroutines.rst Changed

@@ -6,7 +6,7 @@
    from tornado import gen
 
 **Coroutines** are the recommended way to write asynchronous code in
-Tornado. Coroutines use the Python ``await`` or ``yield`` keyword to
+Tornado. Coroutines use the Python ``await`` keyword to
 suspend and resume execution instead of a chain of callbacks
 (cooperative lightweight threads as seen in frameworks like `gevent
 <http://www.gevent.org>`_ are sometimes called coroutines as well, but
@@ -232,11 +232,11 @@
         # This is equivalent to asyncio.ensure_future() (both work in Tornado).
         fetch_future = convert_yielded(self.fetch_next_chunk())
         while True:
-            chunk = yield fetch_future
+            chunk = await fetch_future
             if chunk is None: break
             self.write(chunk)
             fetch_future = convert_yielded(self.fetch_next_chunk())
-            yield self.flush()
+            await self.flush()
 
 .. testoutput::
    :hide:
@@ -281,7 +281,7 @@
 Running in the background
 ^^^^^^^^^^^^^^^^^^^^^^^^^
 
-`.PeriodicCallback` is not normally used with coroutines. Instead, a
+As an alternative to `.PeriodicCallback`, a
 coroutine can contain a ``while True:`` loop and use
 `tornado.gen.sleep`::

_service:tar_scm:tornado-6.1.tar.gz/docs/guide/intro.rst -> _service:tar_scm:tornado-6.3.2.tar.gz/docs/guide/intro.rst Changed

@@ -9,7 +9,7 @@
 `WebSockets <http://en.wikipedia.org/wiki/WebSocket>`_, and other
 applications that require a long-lived connection to each user.
 
-Tornado can be roughly divided into four major components:
+Tornado can be roughly divided into three major components:
 
 * A web framework (including `.RequestHandler` which is subclassed to
   create web applications, and various supporting classes).
@@ -18,11 +18,6 @@
 * An asynchronous networking library including the classes `.IOLoop`
   and `.IOStream`, which serve as the building blocks for the HTTP
   components and can also be used to implement other protocols.
-* A coroutine library (`tornado.gen`) which allows asynchronous
-  code to be written in a more straightforward way than chaining
-  callbacks. This is similar to the native coroutine feature introduced
-  in Python 3.5 (``async def``). Native coroutines are recommended
-  in place of the `tornado.gen` module when available.
 
 The Tornado web framework and HTTP server together offer a full-stack
 alternative to `WSGI <http://www.python.org/dev/peps/pep-3333/>`_.

_service:tar_scm:tornado-6.1.tar.gz/docs/guide/queues.rst -> _service:tar_scm:tornado-6.3.2.tar.gz/docs/guide/queues.rst Changed

_service:tar_scm:tornado-6.1.tar.gz/docs/guide/running.rst -> _service:tar_scm:tornado-6.3.2.tar.gz/docs/guide/running.rst Changed

@@ -8,13 +8,15 @@
 
 .. testcode::
 
-    def main():
+    import asyncio
+
+    async def main():
         app = make_app()
         app.listen(8888)
-        IOLoop.current().start()
+        await asyncio.Event().wait()
 
     if __name__ == '__main__':
-        main()
+        asyncio.run(main())
 
 .. testoutput::
    :hide:
@@ -33,24 +35,28 @@
 multiple Python processes to take full advantage of multi-CPU machines.
 Typically it is best to run one process per CPU.
 
-Tornado includes a built-in multi-process mode to start several
-processes at once (note that multi-process mode does not work on
-Windows). This requires a slight alteration to the standard main
-function:
+The simplest way to do this is to add ``reuse_port=True`` to your ``listen()``
+calls and then simply run multiple copies of your application.
+
+Tornado also has the ability to start multiple processes from a single parent
+process (note that this does not work on Windows). This requires some
+alterations to application startup.
 
 .. testcode::
 
     def main():
-        app = make_app()
-        server = tornado.httpserver.HTTPServer(app)
-        server.bind(8888)
-        server.start(0)  # forks one process per cpu
-        IOLoop.current().start()
+        sockets = bind_sockets(8888)
+        tornado.process.fork_processes(0)
+        async def post_fork_main():
+            server = TCPServer()
+            server.add_sockets(sockets)
+            await asyncio.Event().wait()
+        asyncio.run(post_fork_main())
 
 .. testoutput::
    :hide:
 
-This is the easiest way to start multiple processes and have them all
+This is another way to start multiple processes and have them all
 share the same port, although it has some limitations.  First, each
 child process will have its own ``IOLoop``, so it is important that
 nothing touches the global ``IOLoop`` instance (even indirectly) before the

_service:tar_scm:tornado-6.1.tar.gz/docs/guide/security.rst -> _service:tar_scm:tornado-6.3.2.tar.gz/docs/guide/security.rst Changed

@@ -3,10 +3,9 @@
 
 .. testsetup::
 
-   import tornado.auth
-   import tornado.web
+   import tornado
 
-Cookies and secure cookies
+Cookies and signed cookies
 ~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 You can set cookies in the user's browser with the ``set_cookie``
@@ -28,8 +27,8 @@
 Cookies are not secure and can easily be modified by clients.  If you
 need to set cookies to, e.g., identify the currently logged in user,
 you need to sign your cookies to prevent forgery. Tornado supports
-signed cookies with the `~.RequestHandler.set_secure_cookie` and
-`~.RequestHandler.get_secure_cookie` methods. To use these methods,
+signed cookies with the `~.RequestHandler.set_signed_cookie` and
+`~.RequestHandler.get_signed_cookie` methods. To use these methods,
 you need to specify a secret key named ``cookie_secret`` when you
 create your application. You can pass in application settings as
 keyword arguments to your application:
@@ -46,15 +45,15 @@
 Signed cookies contain the encoded value of the cookie in addition to a
 timestamp and an `HMAC <http://en.wikipedia.org/wiki/HMAC>`_ signature.
 If the cookie is old or if the signature doesn't match,
-``get_secure_cookie`` will return ``None`` just as if the cookie isn't
+``get_signed_cookie`` will return ``None`` just as if the cookie isn't
 set. The secure version of the example above:
 
 .. testcode::
 
     class MainHandler(tornado.web.RequestHandler):
         def get(self):
-            if not self.get_secure_cookie("mycookie"):
-                self.set_secure_cookie("mycookie", "myvalue")
+            if not self.get_signed_cookie("mycookie"):
+                self.set_signed_cookie("mycookie", "myvalue")
                 self.write("Your cookie was not set yet!")
             else:
                 self.write("Your cookie was set!")
@@ -62,15 +61,15 @@
 .. testoutput::
    :hide:
 
-Tornado's secure cookies guarantee integrity but not confidentiality.
+Tornado's signed cookies guarantee integrity but not confidentiality.
 That is, the cookie cannot be modified but its contents can be seen by the
 user.  The ``cookie_secret`` is a symmetric key and must be kept secret --
 anyone who obtains the value of this key could produce their own signed
 cookies.
 
-By default, Tornado's secure cookies expire after 30 days.  To change this,
-use the ``expires_days`` keyword argument to ``set_secure_cookie`` *and* the
-``max_age_days`` argument to ``get_secure_cookie``.  These two values are
+By default, Tornado's signed cookies expire after 30 days.  To change this,
+use the ``expires_days`` keyword argument to ``set_signed_cookie`` *and* the
+``max_age_days`` argument to ``get_signed_cookie``.  These two values are
 passed separately so that you may e.g. have a cookie that is valid for 30 days
 for most purposes, but for certain sensitive actions (such as changing billing
 information) you use a smaller ``max_age_days`` when reading the cookie.
@@ -82,7 +81,7 @@
 but all other keys in the dict are allowed for cookie signature validation,
 if the correct key version is set in the cookie.
 To implement cookie updates, the current signing key version can be
-queried via `~.RequestHandler.get_secure_cookie_key_version`.
+queried via `~.RequestHandler.get_signed_cookie_key_version`.
 
 .. _user-authentication:
 
@@ -104,7 +103,7 @@
 
     class BaseHandler(tornado.web.RequestHandler):
         def get_current_user(self):
-            return self.get_secure_cookie("user")
+            return self.get_signed_cookie("user")
 
     class MainHandler(BaseHandler):
         def get(self):
@@ -122,7 +121,7 @@
                        '</form></body></html>')
 
         def post(self):
-            self.set_secure_cookie("user", self.get_argument("name"))
+            self.set_signed_cookie("user", self.get_argument("name"))
             self.redirect("/")
 
     application = tornado.web.Application(
@@ -194,7 +193,7 @@
                 user = await self.get_authenticated_user(
                     redirect_uri='http://your.site.com/auth/google',
                     code=self.get_argument('code'))
-                # Save the user with e.g. set_secure_cookie
+                # Save the user with e.g. set_signed_cookie
             else:
                 await self.authorize_redirect(
                     redirect_uri='http://your.site.com/auth/google',
@@ -215,10 +214,7 @@
 
 `Cross-site request
 forgery <http://en.wikipedia.org/wiki/Cross-site_request_forgery>`_, or
-XSRF, is a common problem for personalized web applications. See the
-`Wikipedia
-article <http://en.wikipedia.org/wiki/Cross-site_request_forgery>`_ for
-more information on how XSRF works.
+XSRF, is a common problem for personalized web applications.
 
 The generally accepted solution to prevent XSRF is to cookie every user
 with an unpredictable value and include that value as an additional

_service:tar_scm:tornado-6.1.tar.gz/docs/guide/structure.rst -> _service:tar_scm:tornado-6.3.2.tar.gz/docs/guide/structure.rst Changed

@@ -2,7 +2,7 @@
 
 .. testsetup::
 
-   import tornado.web
+   import tornado
 
 Structure of a Tornado web application
 ======================================
@@ -16,8 +16,8 @@
 
 .. testcode::
 
-    import tornado.ioloop
-    import tornado.web
+    import asyncio
+    import tornado
 
     class MainHandler(tornado.web.RequestHandler):
         def get(self):
@@ -28,14 +28,36 @@
             (r"/", MainHandler),
         )
 
-    if __name__ == "__main__":
+    async def main():
         app = make_app()
         app.listen(8888)
-        tornado.ioloop.IOLoop.current().start()
+        shutdown_event = asyncio.Event()
+        await shutdown_event.wait()
+
+    if __name__ == "__main__":
+        asyncio.run(main())
 
 .. testoutput::
    :hide:
 
+The ``main`` coroutine
+~~~~~~~~~~~~~~~~~~~~~~
+
+Beginning with Tornado 6.2 and Python 3.10, the recommended pattern for starting
+a Tornado application is to create a ``main`` coroutine to be run with
+`asyncio.run`. (In older versions, it was common to do initialization in a
+regular function and then start the event loop with
+``IOLoop.current().start()``. However, this pattern produces deprecation
+warnings starting in Python 3.10 and will break in some future version of
+Python.)
+
+When the ``main`` function returns, the program exits, so most of the time for a
+web server ``main`` should run forever. Waiting on an `asyncio.Event` whose
+``set()`` method is never called is a convenient way to make an asynchronus
+function run forever. (and if you wish to have ``main`` exit early as a part of
+a graceful shutdown procedure, you can call ``shutdown_event.set()`` to make it
+exit).
+
 The ``Application`` object
 ~~~~~~~~~~~~~~~~~~~~~~~~~~
 
@@ -154,7 +176,7 @@
 `.stream_request_body` class decorator.
 
 In the demos directory,
-`file_receiver.py <https://github.com/tornadoweb/tornado/tree/master/demos/file_upload/>`_
+`file_receiver.py <https://github.com/tornadoweb/tornado/tree/stable/demos/file_upload/>`_
 shows both methods of receiving file uploads.
 
 Due to the quirks of the HTML form encoding (e.g. the ambiguity around

_service:tar_scm:tornado-6.1.tar.gz/docs/guide/templates.rst -> _service:tar_scm:tornado-6.3.2.tar.gz/docs/guide/templates.rst Changed

_service:tar_scm:tornado-6.1.tar.gz/docs/httpclient.rst -> _service:tar_scm:tornado-6.3.2.tar.gz/docs/httpclient.rst Changed

@@ -57,10 +57,20 @@
 
    ``libcurl``-based HTTP client.
 
+   This implementation supports the following arguments, which can be passed
+   to ``configure()`` to control the global singleton, or to the constructor
+   when ``force_instance=True``.
+
+   ``max_clients`` is the number of concurrent requests that can be in progress;
+   when this limit is reached additional requests will be queued.
+
+   ``defaults`` is a dict of parameters that will be used as defaults on all
+   `.HTTPRequest` objects submitted to this client.
+
 Example Code
 ~~~~~~~~~~~~
 
-* `A simple webspider <https://github.com/tornadoweb/tornado/blob/master/demos/webspider/webspider.py>`_
+* `A simple webspider <https://github.com/tornadoweb/tornado/blob/stable/demos/webspider/webspider.py>`_
   shows how to fetch URLs concurrently.
-* `The file uploader demo <https://github.com/tornadoweb/tornado/tree/master/demos/file_upload/>`_
+* `The file uploader demo <https://github.com/tornadoweb/tornado/tree/stable/demos/file_upload/>`_
   uses either HTTP POST or HTTP PUT to upload files to a server.

_service:tar_scm:tornado-6.1.tar.gz/docs/index.rst -> _service:tar_scm:tornado-6.3.2.tar.gz/docs/index.rst Changed

@@ -31,8 +31,8 @@
 
 Here is a simple "Hello, world" example web app for Tornado::
 
-    import tornado.ioloop
-    import tornado.web
+    import asyncio
+    import tornado
 
     class MainHandler(tornado.web.RequestHandler):
         def get(self):
@@ -43,10 +43,13 @@
             (r"/", MainHandler),
         )
 
-    if __name__ == "__main__":
+    async def main():
         app = make_app()
         app.listen(8888)
-        tornado.ioloop.IOLoop.current().start()
+        await asyncio.Event().wait()
+
+    if __name__ == "__main__":
+        asyncio.run(main())
 
 This example does not use any of Tornado's asynchronous features; for
 that see this `simple chat room
@@ -96,15 +99,11 @@
 source tarball or clone the `git repository
 <https://github.com/tornadoweb/tornado>`_ as well.
 
-**Prerequisites**: Tornado 6.0 requires Python 3.5.2 or newer (See
-`Tornado 5.1 <https://www.tornadoweb.org/en/branch5.1/>`_ if
-compatibility with Python 2.7 is required). The following optional
-packages may be useful:
+**Prerequisites**: Tornado 6.3 requires Python 3.8 or newer. The following
+optional packages may be useful:
 
 * `pycurl <http://pycurl.io/>`_ is used by the optional
   ``tornado.curl_httpclient``.  Libcurl version 7.22 or higher is required.
-* `Twisted <https://www.twistedmatrix.com/>`_ may be used with the classes in
-  `tornado.platform.twisted`.
 * `pycares <https://pypi.org/project/pycares/>`_ is an alternative
   non-blocking DNS resolver that can be used when threads are not
   appropriate.

_service:tar_scm:tornado-6.1.tar.gz/docs/releases.rst -> _service:tar_scm:tornado-6.3.2.tar.gz/docs/releases.rst Changed

_service:tar_scm:tornado-6.1.tar.gz/docs/releases/v4.5.0.rst -> _service:tar_scm:tornado-6.3.2.tar.gz/docs/releases/v4.5.0.rst Changed

_service:tar_scm:tornado-6.3.2.tar.gz/docs/releases/v6.2.0.rst Added

@@ -0,0 +1,130 @@
+What's new in Tornado 6.2.0
+===========================
+
+Jul 3, 2022
+-----------
+
+Deprecation notice
+~~~~~~~~~~~~~~~~~~
+
+- April 2023 update: Python 3.12 reversed some of the changes described below.
+  In Tornado 6.3, `.AsyncTestCase`, `.AsyncHTTPTestCase`, and the behavior
+  of the `.IOLoop` constructor related to the ``make_current`` parameter
+  are no longer deprecated. 
+- Python 3.10 has begun the process of significant changes to the APIs for
+  managing the event loop. Calls to methods such as `asyncio.get_event_loop` may
+  now raise `DeprecationWarning` if no event loop is running. This has
+  significant impact on the patterns for initializing applications, and in
+  particular invalidates patterns that have long been the norm in Tornado's
+  documentation and actual usage. In the future (with some as-yet-unspecified
+  future version of Python), the old APIs will be removed. The new recommended
+  pattern is to start the event loop with `asyncio.run`. More detailed migration
+  guides will be coming in the future.
+
+  - The `.IOLoop` constructor is deprecated unless the ``make_current=False``
+    argument is used. Use `.IOLoop.current` when the loop is already running
+    instead.
+  - `.AsyncTestCase` (and `.AsyncHTTPTestCase`) are deprecated. Use
+    `unittest.IsolatedAsyncioTestCase` instead.
+  - Multi-process `.TCPServer.bind`/`.TCPServer.start` is deprecated. See
+    `.TCPServer` docs for supported alternatives.
+  - `.AnyThreadEventLoopPolicy` is deprecated. This class controls the creation of
+    the "current" event loop so it will be removed when that concept is no longer
+    supported.
+  - `.IOLoop.make_current` and `.IOLoop.clear_current` are deprecated. In the
+    future the concept of a "current" event loop as distinct from one that is
+    currently running will be removed.
+
+- ``TwistedResolver`` and ``CaresResolver`` are deprecated and will be
+  removed in Tornado 7.0.
+
+General changes
+~~~~~~~~~~~~~~~
+
+- The minimum supported Python version is now 3.7.
+- Wheels are now published with the Python stable ABI (``abi3``) for
+  compatibility across versions of Python.
+- SSL certificate verification and hostname checks are now enabled by default in
+  more places (primarily in client-side usage of `.SSLIOStream`).
+- Various improvements to type hints throughout the package.
+- CI has moved from Travis and Appveyor to Github Actions.  
+
+`tornado.gen`
+~~~~~~~~~~~~~
+
+- Fixed a bug in which ``WaitIterator.current_index`` could be incorrect.
+- ``tornado.gen.TimeoutError`` is now an alias for `asyncio.TimeoutError`.
+
+`tornado.http1connection`
+~~~~~~~~~~~~~~~~~~~~~~~~~
+
+- ``max_body_size`` may now be set to zero to disallow a non-empty body.
+- ``Content-Encoding: gzip`` is now recognized case-insensitively.
+
+`tornado.httpclient`
+~~~~~~~~~~~~~~~~~~~~
+
+- ``curl_httpclient`` now supports non-ASCII (ISO-8859-1) header values, same as
+  ``simple_httpclient``.
+
+`tornado.ioloop`
+~~~~~~~~~~~~~~~~
+
+- `.PeriodicCallback` now understands coroutines and will not start multiple
+  copies if a previous invocation runs too long.
+- `.PeriodicCallback` now accepts `datetime.timedelta` objects in addition to
+  numbers of milliseconds.
+- Avoid logging "Event loop is closed" during shutdown-related race conditions.
+- Tornado no longer calls `logging.basicConfig` when starting an IOLoop; this
+  has been unnecessary since Python 3.2 added a logger of last resort.
+- The `.IOLoop` constructor now accepts an ``asyncio_loop`` keyword argument to
+  initialize with a specfied asyncio event loop.
+- It is now possible to construct an `.IOLoop` on one thread (with
+  ``make_current=False``) and start it on a different thread.
+
+`tornado.iostream`
+~~~~~~~~~~~~~~~~~~
+
+- `.SSLIOStream` now supports reading more than 2GB at a time.
+- ``IOStream.write`` now supports typed `memoryview` objects.
+
+`tornado.locale`
+~~~~~~~~~~~~~~~~
+
+- `.load_gettext_translations` no longer logs errors when language directories
+  exist but do not contain the expected file.
+
+`tornado.netutil`
+~~~~~~~~~~~~~~~~~
+
+- `.is_valid_ip` no longer raises exceptions when the input is too long.
+- The default resolver now uses the same methods (and thread pool) as `asyncio`.
+
+`tornado.tcpserver`
+~~~~~~~~~~~~~~~~~~~
+
+- `.TCPServer.listen` now supports more arguments to pass through to
+  `.netutil.bind_sockets`.
+
+`tornado.testing`
+~~~~~~~~~~~~~~~~~
+
+- `.bind_unused_port` now takes an optional ``address`` argument.
+- Wrapped test methods now include the ``__wrapped__`` attribute.
+  
+`tornado.web`
+~~~~~~~~~~~~~
+
+- When using a custom `.StaticFileHandler` subclass, the ``reset()`` method is
+  now called on this subclass instead of the base class.
+- Improved handling of the ``Accept-Language`` header.
+- `.Application.listen` now supports more arguments to pass through to
+  `.netutil.bind_sockets`.
+
+`tornado.websocket`
+~~~~~~~~~~~~~~~~~~~
+
+- `.WebSocketClientConnection.write_message` now accepts `dict` arguments for
+  consistency with `.WebSocketHandler.write_message`.
+- `.WebSocketClientConnection.write_message` now raises an exception as
+  documented if the connection is already closed.

_service:tar_scm:tornado-6.3.2.tar.gz/docs/releases/v6.3.0.rst Added

@@ -0,0 +1,101 @@
+What's new in Tornado 6.3.0
+===========================
+
+Apr 17, 2023
+------------
+
+Highlights
+~~~~~~~~~~
+
+- The new `.Application` setting ``xsrf_cookie_name`` can now be used to
+  take advantage of the ``__Host`` cookie prefix for improved security.
+  To use it, add ``{"xsrf_cookie_name": "__Host-xsrf", "xsrf_cookie_kwargs": 
+  {"secure": True}}`` to your `.Application` settings. Note that this feature
+  currently only works when HTTPS is used.
+- `.WSGIContainer` now supports running the application in a ``ThreadPoolExecutor`` so
+  the event loop is no longer blocked.
+- `.AsyncTestCase` and `.AsyncHTTPTestCase`, which were deprecated in Tornado 6.2,
+  are no longer deprecated.
+- WebSockets are now much faster at receiving large messages split into many
+  fragments.
+
+General changes
+~~~~~~~~~~~~~~~
+
+- Python 3.7 is no longer supported; the minimum supported Python version is 3.8.
+  Python 3.12 is now supported.
+- To avoid spurious deprecation warnings, users of Python 3.10 should upgrade
+  to at least version 3.10.9, and users of Python 3.11 should upgrade to at least
+  version 3.11.1. 
+- Tornado submodules are now imported automatically on demand. This means it is
+  now possible to use a single ``import tornado`` statement and refer to objects
+  in submodules such as `tornado.web.RequestHandler`.
+
+Deprecation notices
+~~~~~~~~~~~~~~~~~~~
+
+- In Tornado 7.0, `tornado.testing.ExpectLog` will match ``WARNING``
+  and above regardless of the current logging configuration, unless the
+  ``level`` argument is used.
+- `.RequestHandler.get_secure_cookie` is now a deprecated alias for
+  `.RequestHandler.get_signed_cookie`. `.RequestHandler.set_secure_cookie`
+  is now a deprecated alias for `.RequestHandler.set_signed_cookie`.
+- `.RequestHandler.clear_all_cookies` is deprecated. No direct replacement
+  is provided; `.RequestHandler.clear_cookie` should be used on individual
+  cookies.
+- Calling the `.IOLoop` constructor without a ``make_current`` argument, which was
+  deprecated in Tornado 6.2, is no longer deprecated.
+- `.AsyncTestCase` and `.AsyncHTTPTestCase`, which were deprecated in Tornado 6.2,
+  are no longer deprecated.
+- `.AsyncTestCase.get_new_ioloop` is deprecated. 
+
+``tornado.auth``
+~~~~~~~~~~~~~~~~
+
+- New method `.GoogleOAuth2Mixin.get_google_oauth_settings` can now be overridden
+  to get credentials from a source other than the `.Application` settings.
+
+``tornado.gen``
+~~~~~~~~~~~~~~~
+
+- `contextvars` now work properly when a ``@gen.coroutine`` calls a native coroutine.
+
+``tornado.options``
+~~~~~~~~~~~~~~~~~~~
+
+- `~.OptionParser.parse_config_file` now recognizes single comma-separated strings (in addition to
+  lists of strings) for options with ``multiple=True``.
+
+``tornado.web``
+~~~~~~~~~~~~~~~
+
+- New `.Application` setting ``xsrf_cookie_name`` can be used to change the
+  name of the XSRF cookie. This is most useful to take advantage of the
+  ``__Host-`` cookie prefix. 
+- `.RequestHandler.get_secure_cookie` and `.RequestHandler.set_secure_cookie`
+  (and related methods and attributes) have been renamed to
+  `~.RequestHandler.get_signed_cookie` and `~.RequestHandler.set_signed_cookie`.
+  This makes it more explicit what kind of security is provided, and avoids
+  confusion with the ``Secure`` cookie attribute and ``__Secure-`` cookie prefix.
+  The old names remain supported as deprecated aliases.
+- `.RequestHandler.clear_cookie` now accepts all keyword arguments accepted by
+  `~.RequestHandler.set_cookie`. In some cases clearing a cookie requires certain
+  arguments to be passed the same way in which it was set. 
+- `.RequestHandler.clear_all_cookies` now accepts additional keyword arguments
+  for the same reason as ``clear_cookie``. However, since the requirements
+  for additional arguments mean that it cannot reliably clear all cookies,
+  this method is now deprecated.
+
+
+``tornado.websocket``
+~~~~~~~~~~~~~~~~~~~~~
+
+- It is now much faster (no longer quadratic) to receive large messages that
+  have been split into many fragments.
+- `.websocket_connect` now accepts a ``resolver`` parameter.
+
+``tornado.wsgi``
+~~~~~~~~~~~~~~~~
+
+- `.WSGIContainer` now accepts an ``executor`` parameter which can be used
+  to run the WSGI application on a thread pool. 
\ No newline at end of file

_service:tar_scm:tornado-6.3.2.tar.gz/docs/releases/v6.3.1.rst Added

_service:tar_scm:tornado-6.3.2.tar.gz/docs/releases/v6.3.2.rst Added

_service:tar_scm:tornado-6.1.tar.gz/docs/twisted.rst -> _service:tar_scm:tornado-6.3.2.tar.gz/docs/twisted.rst Changed

@@ -1,10 +1,60 @@
 ``tornado.platform.twisted`` --- Bridges between Twisted and Tornado
-========================================================================
+====================================================================
 
-.. automodule:: tornado.platform.twisted
+.. module:: tornado.platform.twisted
 
-   Twisted DNS resolver
-   --------------------
+.. deprecated:: 6.0
+
+   This module is no longer recommended for new code. Instead of using
+   direct integration between Tornado and Twisted, new applications should
+   rely on the integration with ``asyncio`` provided by both packages.
+
+Importing this module has the side effect of registering Twisted's ``Deferred``
+class with Tornado's ``@gen.coroutine`` so that ``Deferred`` objects can be
+used with ``yield`` in coroutines using this decorator (importing this module has
+no effect on native coroutines using ``async def``). 
+
+.. function:: install()
+
+    Install ``AsyncioSelectorReactor`` as the default Twisted reactor.
+
+    .. deprecated:: 5.1
+
+       This function is provided for backwards compatibility; code
+       that does not require compatibility with older versions of
+       Tornado should use
+       ``twisted.internet.asyncioreactor.install()`` directly.
+
+    .. versionchanged:: 6.0.3
+
+       In Tornado 5.x and before, this function installed a reactor
+       based on the Tornado ``IOLoop``. When that reactor
+       implementation was removed in Tornado 6.0.0, this function was
+       removed as well. It was restored in Tornado 6.0.3 using the
+       ``asyncio`` reactor instead.
+
+Twisted DNS resolver
+--------------------
+
+.. class:: TwistedResolver
+
+    Twisted-based asynchronous resolver.
+
+    This is a non-blocking and non-threaded resolver.  It is
+    recommended only when threads cannot be used, since it has
+    limitations compared to the standard ``getaddrinfo``-based
+    `~tornado.netutil.Resolver` and
+    `~tornado.netutil.DefaultExecutorResolver`.  Specifically, it returns at
+    most one result, and arguments other than ``host`` and ``family``
+    are ignored.  It may fail to resolve when ``family`` is not
+    ``socket.AF_UNSPEC``.
+
+    Requires Twisted 12.1 or newer.
+
+    .. versionchanged:: 5.0
+       The ``io_loop`` argument (deprecated since version 4.1) has been removed.
+
+    .. deprecated:: 6.2
+       This class is deprecated and will be removed in Tornado 7.0. Use the default
+       thread-based resolver instead.
 
-   .. autoclass:: TwistedResolver
-      :members:

_service:tar_scm:tornado-6.1.tar.gz/docs/util.rst -> _service:tar_scm:tornado-6.3.2.tar.gz/docs/util.rst Changed

_service:tar_scm:tornado-6.1.tar.gz/docs/web.rst -> _service:tar_scm:tornado-6.3.2.tar.gz/docs/web.rst Changed

@@ -117,9 +117,27 @@
    .. automethod:: RequestHandler.set_cookie
    .. automethod:: RequestHandler.clear_cookie
    .. automethod:: RequestHandler.clear_all_cookies
-   .. automethod:: RequestHandler.get_secure_cookie
-   .. automethod:: RequestHandler.get_secure_cookie_key_version
-   .. automethod:: RequestHandler.set_secure_cookie
+   .. automethod:: RequestHandler.get_signed_cookie
+   .. automethod:: RequestHandler.get_signed_cookie_key_version
+   .. automethod:: RequestHandler.set_signed_cookie
+   .. method:: RequestHandler.get_secure_cookie
+
+      Deprecated alias for ``get_signed_cookie``.
+
+      .. deprecated:: 6.3
+
+   .. method:: RequestHandler.get_secure_cookie_key_version
+
+      Deprecated alias for ``get_signed_cookie_key_version``.
+
+      .. deprecated:: 6.3
+
+   .. method:: RequestHandler.set_secure_cookie
+
+      Deprecated alias for ``set_signed_cookie``.
+
+      .. deprecated:: 6.3
+
    .. automethod:: RequestHandler.create_signed_value
    .. autodata:: MIN_SUPPORTED_SIGNED_VALUE_VERSION
    .. autodata:: MAX_SUPPORTED_SIGNED_VALUE_VERSION
@@ -217,9 +235,9 @@
 
          Authentication and security settings:
 
-         * ``cookie_secret``: Used by `RequestHandler.get_secure_cookie`
-           and `.set_secure_cookie` to sign cookies.
-         * ``key_version``: Used by requestHandler `.set_secure_cookie`
+         * ``cookie_secret``: Used by `RequestHandler.get_signed_cookie`
+           and `.set_signed_cookie` to sign cookies.
+         * ``key_version``: Used by requestHandler `.set_signed_cookie`
            to sign cookies with a specific key when ``cookie_secret``
            is a key dictionary.
          * ``login_url``: The `authenticated` decorator will redirect
@@ -235,12 +253,21 @@
          * ``xsrf_cookie_kwargs``: May be set to a dictionary of
            additional arguments to be passed to `.RequestHandler.set_cookie`
            for the XSRF cookie.
+         * ``xsrf_cookie_name``: Controls the name used for the XSRF
+           cookie (default ``_xsrf``). The intended use is to take
+           advantage of `cookie prefixes`_. Note that cookie prefixes
+           interact with other cookie flags, so they must be combined
+           with ``xsrf_cookie_kwargs``, such as
+           ``{"xsrf_cookie_name": "__Host-xsrf", "xsrf_cookie_kwargs":
+           {"secure": True}}``
          * ``twitter_consumer_key``, ``twitter_consumer_secret``,
            ``friendfeed_consumer_key``, ``friendfeed_consumer_secret``,
            ``google_consumer_key``, ``google_consumer_secret``,
            ``facebook_api_key``, ``facebook_secret``:  Used in the
            `tornado.auth` module to authenticate to various APIs.
 
+         .. _cookie prefixes: https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Set-Cookie#cookie_prefixes
+
          Template settings:
 
          * ``autoescape``: Controls automatic escaping for templates.

_service:tar_scm:tornado-6.1.tar.gz/docs/websocket.rst -> _service:tar_scm:tornado-6.3.2.tar.gz/docs/websocket.rst Changed

_service:tar_scm:tornado-6.3.2.tar.gz/pyproject.toml Added

@@ -0,0 +1,30 @@
+build-system
+requires = "setuptools", "wheel"
+build-backend = "setuptools.build_meta"
+
+tool.cibuildwheel
+build = "cp389* cp310* cp311* cp312*"
+test-command = "python -m tornado.test"
+
+tool.cibuildwheel.macos
+archs = "x86_64 universal2"
+# The arm portion of a universal wheel is a cross-compile and cannot
+# be tested on an x86 host. This must be configured explicitly to silence
+# a warning.
+test-skip = "*_universal2:arm64"
+
+tool.cibuildwheel.windows
+# TODO: figure out what's going on with these occasional log messages.
+test-command = "python -m tornado.test --fail-if-logs=false"
+
+tool.cibuildwheel.linux
+# Build wheels for the native platform (i.e. x86) as well as an emulated
+# build for aarch64.
+archs = "auto aarch64"
+
+tool.cibuildwheel.overrides
+# The emulated arm build is quite slow, so only run a portion of the test
+# suite. websocket_test is the most platform-dependent part of the tests
+# because it uses the C speedups module.
+select = "*linux_aarch64"
+test-command = "python -m tornado.test tornado.test.websocket_test"

_service:tar_scm:tornado-6.1.tar.gz/setup.cfg -> _service:tar_scm:tornado-6.3.2.tar.gz/setup.cfg Changed

_service:tar_scm:tornado-6.1.tar.gz/setup.py -> _service:tar_scm:tornado-6.3.2.tar.gz/setup.py Changed

@@ -17,98 +17,12 @@
 
 import os
 import platform
-import sys
-import warnings
+import setuptools
 
 try:
-    # Use setuptools if available, for install_requires (among other things).
-    import setuptools
-    from setuptools import setup
+    import wheel.bdist_wheel
 except ImportError:
-    setuptools = None
-    from distutils.core import setup
-
-from distutils.core import Extension
-
-# The following code is copied from
-# https://github.com/mongodb/mongo-python-driver/blob/master/setup.py
-# to support installing without the extension on platforms where
-# no compiler is available.
-from distutils.command.build_ext import build_ext
-
-
-class custom_build_ext(build_ext):
-    """Allow C extension building to fail.
-
-    The C extension speeds up websocket masking, but is not essential.
-    """
-
-    warning_message = """
-********************************************************************
-WARNING: %s could not
-be compiled. No C extensions are essential for Tornado to run,
-although they do result in significant speed improvements for
-websockets.
-%s
-
-Here are some hints for popular operating systems:
-
-If you are seeing this message on Linux you probably need to
-install GCC and/or the Python development package for your
-version of Python.
-
-Debian and Ubuntu users should issue the following command:
-
-    $ sudo apt-get install build-essential python-dev
-
-RedHat and CentOS users should issue the following command:
-
-    $ sudo yum install gcc python-devel
-
-Fedora users should issue the following command:
-
-    $ sudo dnf install gcc python-devel
-
-MacOS users should run:
-
-    $ xcode-select --install
-
-********************************************************************
-"""
-
-    def run(self):
-        try:
-            build_ext.run(self)
-        except Exception:
-            e = sys.exc_info()1
-            sys.stdout.write("%s\n" % str(e))
-            warnings.warn(
-                self.warning_message
-                % (
-                    "Extension modules",
-                    "There was an issue with "
-                    "your platform configuration"
-                    " - see above.",
-                )
-            )
-
-    def build_extension(self, ext):
-        name = ext.name
-        try:
-            build_ext.build_extension(self, ext)
-        except Exception:
-            e = sys.exc_info()1
-            sys.stdout.write("%s\n" % str(e))
-            warnings.warn(
-                self.warning_message
-                % (
-                    "The %s extension " "module" % (name,),
-                    "The output above "
-                    "this warning shows how "
-                    "the compilation "
-                    "failed.",
-                )
-            )
+    wheel = None
 
 
 kwargs = {}
@@ -120,6 +34,7 @@
 
 with open("README.rst") as f:
     kwargs"long_description" = f.read()
+    kwargs"long_description_content_type" = "text/x-rst"
 
 if (
     platform.python_implementation() == "CPython"
@@ -128,22 +43,36 @@
     # This extension builds and works on pypy as well, although pypy's jit
     # produces equivalent performance.
     kwargs"ext_modules" = 
-        Extension("tornado.speedups", sources="tornado/speedups.c")
+        setuptools.Extension(
+            "tornado.speedups",
+            sources="tornado/speedups.c",
+            # Unless the user has specified that the extension is mandatory,
+            # fall back to the pure-python implementation on any build failure.
+            optional=os.environ.get("TORNADO_EXTENSION") != "1",
+            # Use the stable ABI so our wheels are compatible across python
+            # versions.
+            py_limited_api=True,
+            define_macros=("Py_LIMITED_API", "0x03080000"),
+        )
     
 
-    if os.environ.get("TORNADO_EXTENSION") != "1":
-        # Unless the user has specified that the extension is mandatory,
-        # fall back to the pure-python implementation on any build failure.
-        kwargs"cmdclass" = {"build_ext": custom_build_ext}
+if wheel is not None:
+    # From https://github.com/joerick/python-abi3-package-sample/blob/main/setup.py
+    class bdist_wheel_abi3(wheel.bdist_wheel.bdist_wheel):
+        def get_tag(self):
+            python, abi, plat = super().get_tag()
 
+            if python.startswith("cp"):
+                return "cp38", "abi3", plat
+            return python, abi, plat
 
-if setuptools is not None:
-    python_requires = ">= 3.5"
-    kwargs"python_requires" = python_requires
+    kwargs"cmdclass" = {"bdist_wheel": bdist_wheel_abi3}
 
-setup(
+
+setuptools.setup(
     name="tornado",
     version=version,
+    python_requires=">= 3.8",
     packages="tornado", "tornado.test", "tornado.platform",
     package_data={
         # data files need to be listed both here (which determines what gets
@@ -172,7 +101,10 @@
     author="Facebook",
     author_email="python-tornado@googlegroups.com",
     url="http://www.tornadoweb.org/",
-    license="http://www.apache.org/licenses/LICENSE-2.0",
+    project_urls={
+        "Source": "https://github.com/tornadoweb/tornado",
+    },
+    license="Apache-2.0",
     description=(
         "Tornado is a Python web framework and asynchronous networking library,"
         " originally developed at FriendFeed."
@@ -180,11 +112,10 @@
     classifiers=
         "License :: OSI Approved :: Apache Software License",
         "Programming Language :: Python :: 3",
-        "Programming Language :: Python :: 3.5",
-        "Programming Language :: Python :: 3.6",
-        "Programming Language :: Python :: 3.7",
         "Programming Language :: Python :: 3.8",
         "Programming Language :: Python :: 3.9",
+        "Programming Language :: Python :: 3.10",
+        "Programming Language :: Python :: 3.11",
         "Programming Language :: Python :: Implementation :: CPython",
         "Programming Language :: Python :: Implementation :: PyPy",
     ,

_service:tar_scm:tornado-6.1.tar.gz/tornado.egg-info/PKG-INFO -> _service:tar_scm:tornado-6.3.2.tar.gz/tornado.egg-info/PKG-INFO Changed

@@ -1,68 +1,75 @@
-Metadata-Version: 1.2
+Metadata-Version: 2.1
 Name: tornado
-Version: 6.1
+Version: 6.3.2
 Summary: Tornado is a Python web framework and asynchronous networking library, originally developed at FriendFeed.
 Home-page: http://www.tornadoweb.org/
 Author: Facebook
 Author-email: python-tornado@googlegroups.com
-License: http://www.apache.org/licenses/LICENSE-2.0
-Description: Tornado Web Server
-        ==================
-        
-        .. image:: https://badges.gitter.im/Join%20Chat.svg
-           :alt: Join the chat at https://gitter.im/tornadoweb/tornado
-           :target: https://gitter.im/tornadoweb/tornado?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge
-        
-        `Tornado <http://www.tornadoweb.org>`_ is a Python web framework and
-        asynchronous networking library, originally developed at `FriendFeed
-        <http://friendfeed.com>`_.  By using non-blocking network I/O, Tornado
-        can scale to tens of thousands of open connections, making it ideal for
-        `long polling <http://en.wikipedia.org/wiki/Push_technology#Long_Polling>`_,
-        `WebSockets <http://en.wikipedia.org/wiki/WebSocket>`_, and other
-        applications that require a long-lived connection to each user.
-        
-        Hello, world
-        ------------
-        
-        Here is a simple "Hello, world" example web app for Tornado:
-        
-        .. code-block:: python
-        
-            import tornado.ioloop
-            import tornado.web
-        
-            class MainHandler(tornado.web.RequestHandler):
-                def get(self):
-                    self.write("Hello, world")
-        
-            def make_app():
-                return tornado.web.Application(
-                    (r"/", MainHandler),
-                )
-        
-            if __name__ == "__main__":
-                app = make_app()
-                app.listen(8888)
-                tornado.ioloop.IOLoop.current().start()
-        
-        This example does not use any of Tornado's asynchronous features; for
-        that see this `simple chat room
-        <https://github.com/tornadoweb/tornado/tree/stable/demos/chat>`_.
-        
-        Documentation
-        -------------
-        
-        Documentation and links to additional resources are available at
-        https://www.tornadoweb.org
-        
+License: Apache-2.0
+Project-URL: Source, https://github.com/tornadoweb/tornado
 Platform: UNKNOWN
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.5
-Classifier: Programming Language :: Python :: 3.6
-Classifier: Programming Language :: Python :: 3.7
 Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy
-Requires-Python: >= 3.5
+Requires-Python: >= 3.8
+Description-Content-Type: text/x-rst
+License-File: LICENSE
+
+Tornado Web Server
+==================
+
+.. image:: https://badges.gitter.im/Join%20Chat.svg
+   :alt: Join the chat at https://gitter.im/tornadoweb/tornado
+   :target: https://gitter.im/tornadoweb/tornado?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge
+
+`Tornado <http://www.tornadoweb.org>`_ is a Python web framework and
+asynchronous networking library, originally developed at `FriendFeed
+<http://friendfeed.com>`_.  By using non-blocking network I/O, Tornado
+can scale to tens of thousands of open connections, making it ideal for
+`long polling <http://en.wikipedia.org/wiki/Push_technology#Long_Polling>`_,
+`WebSockets <http://en.wikipedia.org/wiki/WebSocket>`_, and other
+applications that require a long-lived connection to each user.
+
+Hello, world
+------------
+
+Here is a simple "Hello, world" example web app for Tornado:
+
+.. code-block:: python
+
+    import asyncio
+    import tornado
+
+    class MainHandler(tornado.web.RequestHandler):
+        def get(self):
+            self.write("Hello, world")
+
+    def make_app():
+        return tornado.web.Application(
+            (r"/", MainHandler),
+        )
+
+    async def main():
+        app = make_app()
+        app.listen(8888)
+        await asyncio.Event().wait()
+
+    if __name__ == "__main__":
+        asyncio.run(main())
+
+This example does not use any of Tornado's asynchronous features; for
+that see this `simple chat room
+<https://github.com/tornadoweb/tornado/tree/stable/demos/chat>`_.
+
+Documentation
+-------------
+
+Documentation and links to additional resources are available at
+https://www.tornadoweb.org
+
+

_service:tar_scm:tornado-6.1.tar.gz/tornado.egg-info/SOURCES.txt -> _service:tar_scm:tornado-6.3.2.tar.gz/tornado.egg-info/SOURCES.txt Changed

_service:tar_scm:tornado-6.1.tar.gz/tornado/__init__.py -> _service:tar_scm:tornado-6.3.2.tar.gz/tornado/__init__.py Changed

@@ -22,5 +22,46 @@
 # is zero for an official release, positive for a development branch,
 # or negative for a release candidate or beta (after the base version
 # number has been incremented)
-version = "6.1"
-version_info = (6, 1, 0, 0)
+version = "6.3.2"
+version_info = (6, 3, 2, 0)
+
+import importlib
+import typing
+
+__all__ = 
+    "auth",
+    "autoreload",
+    "concurrent",
+    "curl_httpclient",
+    "escape",
+    "gen",
+    "http1connection",
+    "httpclient",
+    "httpserver",
+    "httputil",
+    "ioloop",
+    "iostream",
+    "locale",
+    "locks",
+    "log",
+    "netutil",
+    "options",
+    "platform",
+    "process",
+    "queues",
+    "routing",
+    "simple_httpclient",
+    "tcpclient",
+    "tcpserver",
+    "template",
+    "testing",
+    "util",
+    "web",
+
+
+
+# Copied from https://peps.python.org/pep-0562/
+def __getattr__(name: str) -> typing.Any:
+    if name in __all__:
+        return importlib.import_module("." + name, __name__)
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")

_service:tar_scm:tornado-6.1.tar.gz/tornado/_locale_data.py -> _service:tar_scm:tornado-6.3.2.tar.gz/tornado/_locale_data.py Changed

@@ -15,66 +15,66 @@
 """Data used by the tornado.locale module."""
 
 LOCALE_NAMES = {
-    "af_ZA": {"name_en": u"Afrikaans", "name": u"Afrikaans"},
-    "am_ET": {"name_en": u"Amharic", "name": u"አማርኛ"},
-    "ar_AR": {"name_en": u"Arabic", "name": u"العربية"},
-    "bg_BG": {"name_en": u"Bulgarian", "name": u"Български"},
-    "bn_IN": {"name_en": u"Bengali", "name": u"বাংলা"},
-    "bs_BA": {"name_en": u"Bosnian", "name": u"Bosanski"},
-    "ca_ES": {"name_en": u"Catalan", "name": u"Català"},
-    "cs_CZ": {"name_en": u"Czech", "name": u"Čeština"},
-    "cy_GB": {"name_en": u"Welsh", "name": u"Cymraeg"},
-    "da_DK": {"name_en": u"Danish", "name": u"Dansk"},
-    "de_DE": {"name_en": u"German", "name": u"Deutsch"},
-    "el_GR": {"name_en": u"Greek", "name": u"Ελληνικά"},
-    "en_GB": {"name_en": u"English (UK)", "name": u"English (UK)"},
-    "en_US": {"name_en": u"English (US)", "name": u"English (US)"},
-    "es_ES": {"name_en": u"Spanish (Spain)", "name": u"Español (España)"},
-    "es_LA": {"name_en": u"Spanish", "name": u"Español"},
-    "et_EE": {"name_en": u"Estonian", "name": u"Eesti"},
-    "eu_ES": {"name_en": u"Basque", "name": u"Euskara"},
-    "fa_IR": {"name_en": u"Persian", "name": u"فارسی"},
-    "fi_FI": {"name_en": u"Finnish", "name": u"Suomi"},
-    "fr_CA": {"name_en": u"French (Canada)", "name": u"Français (Canada)"},
-    "fr_FR": {"name_en": u"French", "name": u"Français"},
-    "ga_IE": {"name_en": u"Irish", "name": u"Gaeilge"},
-    "gl_ES": {"name_en": u"Galician", "name": u"Galego"},
-    "he_IL": {"name_en": u"Hebrew", "name": u"עברית"},
-    "hi_IN": {"name_en": u"Hindi", "name": u"हिन्दी"},
-    "hr_HR": {"name_en": u"Croatian", "name": u"Hrvatski"},
-    "hu_HU": {"name_en": u"Hungarian", "name": u"Magyar"},
-    "id_ID": {"name_en": u"Indonesian", "name": u"Bahasa Indonesia"},
-    "is_IS": {"name_en": u"Icelandic", "name": u"Íslenska"},
-    "it_IT": {"name_en": u"Italian", "name": u"Italiano"},
-    "ja_JP": {"name_en": u"Japanese", "name": u"日本語"},
-    "ko_KR": {"name_en": u"Korean", "name": u"한국어"},
-    "lt_LT": {"name_en": u"Lithuanian", "name": u"Lietuvių"},
-    "lv_LV": {"name_en": u"Latvian", "name": u"Latviešu"},
-    "mk_MK": {"name_en": u"Macedonian", "name": u"Македонски"},
-    "ml_IN": {"name_en": u"Malayalam", "name": u"മലയാളം"},
-    "ms_MY": {"name_en": u"Malay", "name": u"Bahasa Melayu"},
-    "nb_NO": {"name_en": u"Norwegian (bokmal)", "name": u"Norsk (bokmål)"},
-    "nl_NL": {"name_en": u"Dutch", "name": u"Nederlands"},
-    "nn_NO": {"name_en": u"Norwegian (nynorsk)", "name": u"Norsk (nynorsk)"},
-    "pa_IN": {"name_en": u"Punjabi", "name": u"ਪੰਜਾਬੀ"},
-    "pl_PL": {"name_en": u"Polish", "name": u"Polski"},
-    "pt_BR": {"name_en": u"Portuguese (Brazil)", "name": u"Português (Brasil)"},
-    "pt_PT": {"name_en": u"Portuguese (Portugal)", "name": u"Português (Portugal)"},
-    "ro_RO": {"name_en": u"Romanian", "name": u"Română"},
-    "ru_RU": {"name_en": u"Russian", "name": u"Русский"},
-    "sk_SK": {"name_en": u"Slovak", "name": u"Slovenčina"},
-    "sl_SI": {"name_en": u"Slovenian", "name": u"Slovenščina"},
-    "sq_AL": {"name_en": u"Albanian", "name": u"Shqip"},
-    "sr_RS": {"name_en": u"Serbian", "name": u"Српски"},
-    "sv_SE": {"name_en": u"Swedish", "name": u"Svenska"},
-    "sw_KE": {"name_en": u"Swahili", "name": u"Kiswahili"},
-    "ta_IN": {"name_en": u"Tamil", "name": u"தமிழ்"},
-    "te_IN": {"name_en": u"Telugu", "name": u"తెలుగు"},
-    "th_TH": {"name_en": u"Thai", "name": u"ภาษาไทย"},
-    "tl_PH": {"name_en": u"Filipino", "name": u"Filipino"},
-    "tr_TR": {"name_en": u"Turkish", "name": u"Türkçe"},
-    "uk_UA": {"name_en": u"Ukraini ", "name": u"Українська"},
-    "vi_VN": {"name_en": u"Vietnamese", "name": u"Tiếng Việt"},
-    "zh_CN": {"name_en": u"Chinese (Simplified)", "name": u"中文(简体)"},
-    "zh_TW": {"name_en": u"Chinese (Traditional)", "name": u"中文(繁體)"},
+    "af_ZA": {"name_en": "Afrikaans", "name": "Afrikaans"},
+    "am_ET": {"name_en": "Amharic", "name": "አማርኛ"},
+    "ar_AR": {"name_en": "Arabic", "name": "العربية"},
+    "bg_BG": {"name_en": "Bulgarian", "name": "Български"},
+    "bn_IN": {"name_en": "Bengali", "name": "বাংলা"},
+    "bs_BA": {"name_en": "Bosnian", "name": "Bosanski"},
+    "ca_ES": {"name_en": "Catalan", "name": "Català"},
+    "cs_CZ": {"name_en": "Czech", "name": "Čeština"},
+    "cy_GB": {"name_en": "Welsh", "name": "Cymraeg"},
+    "da_DK": {"name_en": "Danish", "name": "Dansk"},
+    "de_DE": {"name_en": "German", "name": "Deutsch"},
+    "el_GR": {"name_en": "Greek", "name": "Ελληνικά"},
+    "en_GB": {"name_en": "English (UK)", "name": "English (UK)"},
+    "en_US": {"name_en": "English (US)", "name": "English (US)"},
+    "es_ES": {"name_en": "Spanish (Spain)", "name": "Español (España)"},
+    "es_LA": {"name_en": "Spanish", "name": "Español"},
+    "et_EE": {"name_en": "Estonian", "name": "Eesti"},
+    "eu_ES": {"name_en": "Basque", "name": "Euskara"},
+    "fa_IR": {"name_en": "Persian", "name": "فارسی"},
+    "fi_FI": {"name_en": "Finnish", "name": "Suomi"},
+    "fr_CA": {"name_en": "French (Canada)", "name": "Français (Canada)"},
+    "fr_FR": {"name_en": "French", "name": "Français"},
+    "ga_IE": {"name_en": "Irish", "name": "Gaeilge"},
+    "gl_ES": {"name_en": "Galician", "name": "Galego"},
+    "he_IL": {"name_en": "Hebrew", "name": "עברית"},
+    "hi_IN": {"name_en": "Hindi", "name": "हिन्दी"},
+    "hr_HR": {"name_en": "Croatian", "name": "Hrvatski"},
+    "hu_HU": {"name_en": "Hungarian", "name": "Magyar"},
+    "id_ID": {"name_en": "Indonesian", "name": "Bahasa Indonesia"},
+    "is_IS": {"name_en": "Icelandic", "name": "Íslenska"},
+    "it_IT": {"name_en": "Italian", "name": "Italiano"},
+    "ja_JP": {"name_en": "Japanese", "name": "日本語"},
+    "ko_KR": {"name_en": "Korean", "name": "한국어"},
+    "lt_LT": {"name_en": "Lithuanian", "name": "Lietuvių"},
+    "lv_LV": {"name_en": "Latvian", "name": "Latviešu"},
+    "mk_MK": {"name_en": "Macedonian", "name": "Македонски"},
+    "ml_IN": {"name_en": "Malayalam", "name": "മലയാളം"},
+    "ms_MY": {"name_en": "Malay", "name": "Bahasa Melayu"},
+    "nb_NO": {"name_en": "Norwegian (bokmal)", "name": "Norsk (bokmål)"},
+    "nl_NL": {"name_en": "Dutch", "name": "Nederlands"},
+    "nn_NO": {"name_en": "Norwegian (nynorsk)", "name": "Norsk (nynorsk)"},
+    "pa_IN": {"name_en": "Punjabi", "name": "ਪੰਜਾਬੀ"},
+    "pl_PL": {"name_en": "Polish", "name": "Polski"},
+    "pt_BR": {"name_en": "Portuguese (Brazil)", "name": "Português (Brasil)"},
+    "pt_PT": {"name_en": "Portuguese (Portugal)", "name": "Português (Portugal)"},
+    "ro_RO": {"name_en": "Romanian", "name": "Română"},
+    "ru_RU": {"name_en": "Russian", "name": "Русский"},
+    "sk_SK": {"name_en": "Slovak", "name": "Slovenčina"},
+    "sl_SI": {"name_en": "Slovenian", "name": "Slovenščina"},
+    "sq_AL": {"name_en": "Albanian", "name": "Shqip"},
+    "sr_RS": {"name_en": "Serbian", "name": "Српски"},
+    "sv_SE": {"name_en": "Swedish", "name": "Svenska"},
+    "sw_KE": {"name_en": "Swahili", "name": "Kiswahili"},
+    "ta_IN": {"name_en": "Tamil", "name": "தமிழ்"},
+    "te_IN": {"name_en": "Telugu", "name": "తెలుగు"},
+    "th_TH": {"name_en": "Thai", "name": "ภาษาไทย"},
+    "tl_PH": {"name_en": "Filipino", "name": "Filipino"},
+    "tr_TR": {"name_en": "Turkish", "name": "Türkçe"},
+    "uk_UA": {"name_en": "Ukraini ", "name": "Українська"},
+    "vi_VN": {"name_en": "Vietnamese", "name": "Tiếng Việt"},
+    "zh_CN": {"name_en": "Chinese (Simplified)", "name": "中文(简体)"},
+    "zh_TW": {"name_en": "Chinese (Traditional)", "name": "中文(繁體)"},
 }

_service:tar_scm:tornado-6.1.tar.gz/tornado/auth.py -> _service:tar_scm:tornado-6.3.2.tar.gz/tornado/auth.py Changed

@@ -42,7 +42,7 @@
                 user = await self.get_authenticated_user(
                     redirect_uri='http://your.site.com/auth/google',
                     code=self.get_argument('code'))
-                # Save the user with e.g. set_secure_cookie
+                # Save the user with e.g. set_signed_cookie
             else:
                 self.authorize_redirect(
                     redirect_uri='http://your.site.com/auth/google',
@@ -136,7 +136,7 @@
         args = dict(
             (k, v-1) for k, v in handler.request.arguments.items()
         )  # type: Dictstr, Unionstr, bytes
-        args"openid.mode" = u"check_authentication"
+        args"openid.mode" = "check_authentication"
         url = self._OPENID_ENDPOINT  # type: ignore
         if http_client is None:
             http_client = self.get_auth_http_client()
@@ -211,14 +211,14 @@
         for key in handler.request.arguments:
             if (
                 key.startswith("openid.ns.")
-                and handler.get_argument(key) == u"http://openid.net/srv/ax/1.0"
+                and handler.get_argument(key) == "http://openid.net/srv/ax/1.0"
             ):
                 ax_ns = key10:
                 break
 
         def get_ax_arg(uri: str) -> str:
             if not ax_ns:
-                return u""
+                return ""
             prefix = "openid." + ax_ns + ".type."
             ax_name = None
             for name in handler.request.arguments.keys():
@@ -227,8 +227,8 @@
                     ax_name = "openid." + ax_ns + ".value." + part
                     break
             if not ax_name:
-                return u""
-            return handler.get_argument(ax_name, u"")
+                return ""
+            return handler.get_argument(ax_name, "")
 
         email = get_ax_arg("http://axschema.org/contact/email")
         name = get_ax_arg("http://axschema.org/namePerson")
@@ -247,7 +247,7 @@
         if name:
             user"name" = name
         elif name_parts:
-            user"name" = u" ".join(name_parts)
+            user"name" = " ".join(name_parts)
         elif email:
             user"name" = email.split("@")0
         if email:
@@ -694,7 +694,7 @@
             async def get(self):
                 if self.get_argument("oauth_token", None):
                     user = await self.get_authenticated_user()
-                    # Save the user using e.g. set_secure_cookie()
+                    # Save the user using e.g. set_signed_cookie()
                 else:
                     await self.authorize_redirect()
 
@@ -839,11 +839,10 @@
 
     * Go to the Google Dev Console at http://console.developers.google.com
     * Select a project, or create a new one.
-    * In the sidebar on the left, select APIs & Auth.
-    * In the list of APIs, find the Google+ API service and set it to ON.
     * In the sidebar on the left, select Credentials.
-    * In the OAuth section of the page, select Create New Client ID.
-    * Set the Redirect URI to point to your auth handler
+    * Click CREATE CREDENTIALS and click OAuth client ID.
+    * Under Application type, select Web application.
+    * Name OAuth 2.0 client and click Create.
     * Copy the "Client secret" and "Client ID" to the application settings as
       ``{"google_oauth": {"key": CLIENT_ID, "secret": CLIENT_SECRET}}``
 
@@ -856,8 +855,28 @@
     _OAUTH_NO_CALLBACKS = False
     _OAUTH_SETTINGS_KEY = "google_oauth"
 
+    def get_google_oauth_settings(self) -> Dictstr, str:
+        """Return the Google OAuth 2.0 credentials that you created with
+        Google Cloud
+        Platform(https://console.cloud.google.com/apis/credentials). The dict
+        format is::
+
+            {
+                "key": "your_client_id", "secret": "your_client_secret"
+            }
+
+        If your credentials are stored differently (e.g. in a db) you can
+        override this method for custom provision.
+        """
+        handler = cast(RequestHandler, self)
+        return handler.settingsself._OAUTH_SETTINGS_KEY
+
     async def get_authenticated_user(
-        self, redirect_uri: str, code: str
+        self,
+        redirect_uri: str,
+        code: str,
+        client_id: Optionalstr = None,
+        client_secret: Optionalstr = None,
     ) -> Dictstr, Any:
         """Handles the login for the Google user, returning an access token.
 
@@ -884,11 +903,11 @@
                             "https://www.googleapis.com/oauth2/v1/userinfo",
                             access_token=access"access_token")
                         # Save the user and access token with
-                        # e.g. set_secure_cookie.
+                        # e.g. set_signed_cookie.
                     else:
                         self.authorize_redirect(
                             redirect_uri='http://your.site.com/auth/google',
-                            client_id=self.settings'google_oauth''key',
+                            client_id=self.get_google_oauth_settings()'key',
                             scope='profile', 'email',
                             response_type='code',
                             extra_params={'approval_prompt': 'auto'})
@@ -900,14 +919,20 @@
 
            The ``callback`` argument was removed. Use the returned awaitable object instead.
         """  # noqa: E501
-        handler = cast(RequestHandler, self)
+
+        if client_id is None or client_secret is None:
+            settings = self.get_google_oauth_settings()
+            if client_id is None:
+                client_id = settings"key"
+            if client_secret is None:
+                client_secret = settings"secret"
         http = self.get_auth_http_client()
         body = urllib.parse.urlencode(
             {
                 "redirect_uri": redirect_uri,
                 "code": code,
-                "client_id": handler.settingsself._OAUTH_SETTINGS_KEY"key",
-                "client_secret": handler.settingsself._OAUTH_SETTINGS_KEY"secret",
+                "client_id": client_id,
+                "client_secret": client_secret,
                 "grant_type": "authorization_code",
             }
         )
@@ -952,7 +977,7 @@
                           client_id=self.settings"facebook_api_key",
                           client_secret=self.settings"facebook_secret",
                           code=self.get_argument("code"))
-                      # Save the user with e.g. set_secure_cookie
+                      # Save the user with e.g. set_signed_cookie
                   else:
                       self.authorize_redirect(
                           redirect_uri='/auth/facebookgraph/',

_service:tar_scm:tornado-6.1.tar.gz/tornado/autoreload.py -> _service:tar_scm:tornado-6.3.2.tar.gz/tornado/autoreload.py Changed

@@ -76,7 +76,6 @@
         del sys.path0
 
 import functools
-import logging
 import os
 import pkgutil  # type: ignore
 import sys
@@ -207,7 +206,7 @@
     _reload_attempted = True
     for fn in _reload_hooks:
         fn()
-    if hasattr(signal, "setitimer"):
+    if sys.platform != "win32":
         # Clear the alarm signal set by
         # ioloop.set_blocking_log_threshold so it doesn't fire
         # after the exec.
@@ -325,10 +324,8 @@
                 del __package__
                 exec_in(f.read(), globals(), globals())
     except SystemExit as e:
-        logging.basicConfig()
         gen_log.info("Script exited with status %s", e.code)
     except Exception as e:
-        logging.basicConfig()
         gen_log.warning("Script exited with uncaught exception", exc_info=True)
         # If an exception occurred at import time, the file with the error
         # never made it into sys.modules and so we won't know to watch it.
@@ -340,9 +337,9 @@
             # SyntaxErrors are special:  their innermost stack frame is fake
             # so extract_tb won't see it and we have to get the filename
             # from the exception object.
-            watch(e.filename)
+            if e.filename is not None:
+                watch(e.filename)
     else:
-        logging.basicConfig()
         gen_log.info("Script exited normally")
     # restore sys.argv so subsequent executions will include autoreload
     sys.argv = original_argv

_service:tar_scm:tornado-6.1.tar.gz/tornado/concurrent.py -> _service:tar_scm:tornado-6.3.2.tar.gz/tornado/concurrent.py Changed

_service:tar_scm:tornado-6.1.tar.gz/tornado/curl_httpclient.py -> _service:tar_scm:tornado-6.3.2.tar.gz/tornado/curl_httpclient.py Changed

@@ -36,11 +36,11 @@
 )
 from tornado.log import app_log
 
-from typing import Dict, Any, Callable, Union, Tuple, Optional
+from typing import Dict, Any, Callable, Union, Optional
 import typing
 
 if typing.TYPE_CHECKING:
-    from typing import Deque  # noqa: F401
+    from typing import Deque, Tuple  # noqa: F401
 
 curl_log = logging.getLogger("tornado.curl_httpclient")
 
@@ -228,7 +228,7 @@
                     "callback": callback,
                     "queue_start_time": queue_start_time,
                     "curl_start_time": time.time(),
-                    "curl_start_ioloop_time": self.io_loop.current().time(),
+                    "curl_start_ioloop_time": self.io_loop.current().time(),  # type: ignore
                 }
                 try:
                     self._curl_setup_request(
@@ -350,7 +350,8 @@
         curl.setopt(
             pycurl.HTTPHEADER,
             
-                "%s: %s" % (native_str(k), native_str(v))
+                b"%s: %s"
+                % (native_str(k).encode("ASCII"), native_str(v).encode("ISO8859-1"))
                 for k, v in request.headers.get_all()
             ,
         )
@@ -369,7 +370,7 @@
                 return len(b)
 
         else:
-            write_function = buffer.write
+            write_function = buffer.write  # type: ignore
         curl.setopt(pycurl.WRITEFUNCTION, write_function)
         curl.setopt(pycurl.FOLLOWLOCATION, request.follow_redirects)
         curl.setopt(pycurl.MAXREDIRS, request.max_redirects)

_service:tar_scm:tornado-6.1.tar.gz/tornado/escape.py -> _service:tar_scm:tornado-6.3.2.tar.gz/tornado/escape.py Changed

_service:tar_scm:tornado-6.1.tar.gz/tornado/gen.py -> _service:tar_scm:tornado-6.3.2.tar.gz/tornado/gen.py Changed

@@ -400,7 +400,7 @@
         self._running_future = Future()
 
         if self._finished:
-            self._return_result(self._finished.popleft())
+            return self._return_result(self._finished.popleft())
 
         return self._running_future
 
@@ -410,7 +410,7 @@
         else:
             self._finished.append(done)
 
-    def _return_result(self, done: Future) -> None:
+    def _return_result(self, done: Future) -> Future:
         """Called set the returned future's state that of the future
         we yielded, and set the current future for the iterator.
         """
@@ -418,9 +418,13 @@
             raise Exception("no future is running")
         chain_future(done, self._running_future)
 
+        res = self._running_future
+        self._running_future = None
         self.current_future = done
         self.current_index = self._unfinished.pop(done)
 
+        return res
+
     def __aiter__(self) -> typing.AsyncIterator:
         return self
 
@@ -602,6 +606,9 @@
     .. versionchanged:: 6.0.3
        ``asyncio.CancelledError`` is now always considered "quiet".
 
+    .. versionchanged:: 6.2
+       ``tornado.util.TimeoutError`` is now an alias to ``asyncio.TimeoutError``.
+
     """
     # It's tempting to optimize this by cancelling the input future on timeout
     # instead of creating a new one, but A) we can't know if we are the only
@@ -736,7 +743,7 @@
         self.running = False
         self.finished = False
         self.io_loop = IOLoop.current()
-        if self.handle_yield(first_yielded):
+        if self.ctx_run(self.handle_yield, first_yielded):
             gen = result_future = first_yielded = None  # type: ignore
             self.ctx_run(self.run)
 
@@ -756,21 +763,25 @@
                     return
                 self.future = None
                 try:
-                    exc_info = None
-
                     try:
                         value = future.result()
-                    except Exception:
-                        exc_info = sys.exc_info()
-                    future = None
+                    except Exception as e:
+                        # Save the exception for later. It's important that
+                        # gen.throw() not be called inside this try/except block
+                        # because that makes sys.exc_info behave unexpectedly.
+                        exc: OptionalException = e
+                    else:
+                        exc = None
+                    finally:
+                        future = None
 
-                    if exc_info is not None:
+                    if exc is not None:
                         try:
-                            yielded = self.gen.throw(*exc_info)  # type: ignore
+                            yielded = self.gen.throw(exc)
                         finally:
-                            # Break up a reference to itself
-                            # for faster GC on CPython.
-                            exc_info = None
+                            # Break up a circular reference for faster GC on
+                            # CPython.
+                            del exc
                     else:
                         yielded = self.gen.send(value)

_service:tar_scm:tornado-6.1.tar.gz/tornado/http1connection.py -> _service:tar_scm:tornado-6.3.2.tar.gz/tornado/http1connection.py Changed

@@ -69,8 +69,7 @@
 
 
 class HTTP1ConnectionParameters(object):
-    """Parameters for `.HTTP1Connection` and `.HTTP1ServerConnection`.
-    """
+    """Parameters for `.HTTP1Connection` and `.HTTP1ServerConnection`."""
 
     def __init__(
         self,
@@ -132,7 +131,11 @@
         self.no_keep_alive = params.no_keep_alive
         # The body limits can be altered by the delegate, so save them
         # here instead of just referencing self.params later.
-        self._max_body_size = self.params.max_body_size or self.stream.max_buffer_size
+        self._max_body_size = (
+            self.params.max_body_size
+            if self.params.max_body_size is not None
+            else self.stream.max_buffer_size
+        )
         self._body_timeout = self.params.body_timeout
         # _write_finished is set to True when finish() has been called,
         # i.e. there will be no more data sent.  Data may still be in the
@@ -703,8 +706,7 @@
 
 
 class _GzipMessageDelegate(httputil.HTTPMessageDelegate):
-    """Wraps an `HTTPMessageDelegate` to decode ``Content-Encoding: gzip``.
-    """
+    """Wraps an `HTTPMessageDelegate` to decode ``Content-Encoding: gzip``."""
 
     def __init__(self, delegate: httputil.HTTPMessageDelegate, chunk_size: int) -> None:
         self._delegate = delegate
@@ -716,7 +718,7 @@
         start_line: Unionhttputil.RequestStartLine, httputil.ResponseStartLine,
         headers: httputil.HTTPHeaders,
     ) -> OptionalAwaitableNone:
-        if headers.get("Content-Encoding") == "gzip":
+        if headers.get("Content-Encoding", "").lower() == "gzip":
             self._decompressor = GzipDecompressor()
             # Downstream delegates will only see uncompressed data,
             # so rename the content-encoding header.

_service:tar_scm:tornado-6.1.tar.gz/tornado/httpserver.py -> _service:tar_scm:tornado-6.3.2.tar.gz/tornado/httpserver.py Changed

@@ -84,41 +84,53 @@
     `HTTPServer` initialization follows one of three patterns (the
     initialization methods are defined on `tornado.tcpserver.TCPServer`):
 
-    1. `~tornado.tcpserver.TCPServer.listen`: simple single-process::
+    1. `~tornado.tcpserver.TCPServer.listen`: single-process::
 
-            server = HTTPServer(app)
-            server.listen(8888)
-            IOLoop.current().start()
+            async def main():
+                server = HTTPServer()
+                server.listen(8888)
+                await asyncio.Event.wait()
+
+            asyncio.run(main())
 
        In many cases, `tornado.web.Application.listen` can be used to avoid
        the need to explicitly create the `HTTPServer`.
 
-    2. `~tornado.tcpserver.TCPServer.bind`/`~tornado.tcpserver.TCPServer.start`:
-       simple multi-process::
+       While this example does not create multiple processes on its own, when
+       the ``reuse_port=True`` argument is passed to ``listen()`` you can run
+       the program multiple times to create a multi-process service.
 
-            server = HTTPServer(app)
-            server.bind(8888)
-            server.start(0)  # Forks multiple sub-processes
-            IOLoop.current().start()
+    2. `~tornado.tcpserver.TCPServer.add_sockets`: multi-process::
 
-       When using this interface, an `.IOLoop` must *not* be passed
-       to the `HTTPServer` constructor.  `~.TCPServer.start` will always start
-       the server on the default singleton `.IOLoop`.
+            sockets = bind_sockets(8888)
+            tornado.process.fork_processes(0)
+            async def post_fork_main():
+                server = HTTPServer()
+                server.add_sockets(sockets)
+                await asyncio.Event().wait()
+            asyncio.run(post_fork_main())
 
-    3. `~tornado.tcpserver.TCPServer.add_sockets`: advanced multi-process::
+       The ``add_sockets`` interface is more complicated, but it can be used with
+       `tornado.process.fork_processes` to run a multi-process service with all
+       worker processes forked from a single parent.  ``add_sockets`` can also be
+       used in single-process servers if you want to create your listening
+       sockets in some way other than `~tornado.netutil.bind_sockets`.
 
-            sockets = tornado.netutil.bind_sockets(8888)
-            tornado.process.fork_processes(0)
-            server = HTTPServer(app)
-            server.add_sockets(sockets)
+       Note that when using this pattern, nothing that touches the event loop
+       can be run before ``fork_processes``.
+
+    3. `~tornado.tcpserver.TCPServer.bind`/`~tornado.tcpserver.TCPServer.start`:
+       simple **deprecated** multi-process::
+
+            server = HTTPServer()
+            server.bind(8888)
+            server.start(0)  # Forks multiple sub-processes
             IOLoop.current().start()
 
-       The `~.TCPServer.add_sockets` interface is more complicated,
-       but it can be used with `tornado.process.fork_processes` to
-       give you more flexibility in when the fork happens.
-       `~.TCPServer.add_sockets` can also be used in single-process
-       servers if you want to create your listening sockets in some
-       way other than `tornado.netutil.bind_sockets`.
+       This pattern is deprecated because it requires interfaces in the
+       `asyncio` module that have been deprecated since Python 3.10. Support for
+       creating multiple processes in the ``start`` method will be removed in a
+       future version of Tornado.
 
     .. versionchanged:: 4.0
        Added ``decompress_request``, ``chunk_size``, ``max_header_size``,

_service:tar_scm:tornado-6.1.tar.gz/tornado/httputil.py -> _service:tar_scm:tornado-6.3.2.tar.gz/tornado/httputil.py Changed

_service:tar_scm:tornado-6.1.tar.gz/tornado/ioloop.py -> _service:tar_scm:tornado-6.3.2.tar.gz/tornado/ioloop.py Changed

@@ -15,18 +15,11 @@
 
 """An I/O event loop for non-blocking sockets.
 
-In Tornado 6.0, `.IOLoop` is a wrapper around the `asyncio` event
-loop, with a slightly different interface for historical reasons.
-Applications can use either the `.IOLoop` interface or the underlying
-`asyncio` event loop directly (unless compatibility with older
-versions of Tornado is desired, in which case `.IOLoop` must be used).
-
-Typical applications will use a single `IOLoop` object, accessed via
-`IOLoop.current` class method. The `IOLoop.start` method (or
-equivalently, `asyncio.AbstractEventLoop.run_forever`) should usually
-be called at the end of the ``main()`` function. Atypical applications
-may use more than one `IOLoop`, such as one `IOLoop` per thread, or
-per `unittest` case.
+In Tornado 6.0, `.IOLoop` is a wrapper around the `asyncio` event loop, with a
+slightly different interface. The `.IOLoop` interface is now provided primarily
+for backwards compatibility; new code should generally use the `asyncio` event
+loop interface directly. The `IOLoop.current` class method provides the
+`IOLoop` instance corresponding to the running `asyncio` event loop.
 
 """
 
@@ -34,13 +27,14 @@
 import concurrent.futures
 import datetime
 import functools
-import logging
 import numbers
 import os
 import sys
 import time
 import math
 import random
+import warnings
+from inspect import isawaitable
 
 from tornado.concurrent import (
     Future,
@@ -78,18 +72,18 @@
 class IOLoop(Configurable):
     """An I/O event loop.
 
-    As of Tornado 6.0, `IOLoop` is a wrapper around the `asyncio` event
-    loop.
+    As of Tornado 6.0, `IOLoop` is a wrapper around the `asyncio` event loop.
 
     Example usage for a simple TCP server:
 
     .. testcode::
 
+        import asyncio
         import errno
         import functools
         import socket
 
-        import tornado.ioloop
+        import tornado
         from tornado.iostream import IOStream
 
         async def handle_connection(connection, address):
@@ -107,7 +101,7 @@
                 io_loop = tornado.ioloop.IOLoop.current()
                 io_loop.spawn_callback(handle_connection, connection, address)
 
-        if __name__ == '__main__':
+        async def main():
             sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM, 0)
             sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
             sock.setblocking(0)
@@ -117,28 +111,28 @@
             io_loop = tornado.ioloop.IOLoop.current()
             callback = functools.partial(connection_ready, sock)
             io_loop.add_handler(sock.fileno(), callback, io_loop.READ)
-            io_loop.start()
+            await asyncio.Event().wait()
+
+        if __name__ == "__main__":
+            asyncio.run(main())
 
     .. testoutput::
        :hide:
 
-    By default, a newly-constructed `IOLoop` becomes the thread's current
-    `IOLoop`, unless there already is a current `IOLoop`. This behavior
-    can be controlled with the ``make_current`` argument to the `IOLoop`
-    constructor: if ``make_current=True``, the new `IOLoop` will always
-    try to become current and it raises an error if there is already a
-    current instance. If ``make_current=False``, the new `IOLoop` will
-    not try to become current.
-
-    In general, an `IOLoop` cannot survive a fork or be shared across
-    processes in any way. When multiple processes are being used, each
-    process should create its own `IOLoop`, which also implies that
-    any objects which depend on the `IOLoop` (such as
-    `.AsyncHTTPClient`) must also be created in the child processes.
-    As a guideline, anything that starts processes (including the
-    `tornado.process` and `multiprocessing` modules) should do so as
-    early as possible, ideally the first thing the application does
-    after loading its configuration in ``main()``.
+    Most applications should not attempt to construct an `IOLoop` directly,
+    and instead initialize the `asyncio` event loop and use `IOLoop.current()`.
+    In some cases, such as in test frameworks when initializing an `IOLoop`
+    to be run in a secondary thread, it may be appropriate to construct
+    an `IOLoop` with ``IOLoop(make_current=False)``.
+
+    In general, an `IOLoop` cannot survive a fork or be shared across processes
+    in any way. When multiple processes are being used, each process should
+    create its own `IOLoop`, which also implies that any objects which depend on
+    the `IOLoop` (such as `.AsyncHTTPClient`) must also be created in the child
+    processes. As a guideline, anything that starts processes (including the
+    `tornado.process` and `multiprocessing` modules) should do so as early as
+    possible, ideally the first thing the application does after loading its
+    configuration, and *before* any calls to `.IOLoop.start` or `asyncio.run`.
 
     .. versionchanged:: 4.2
        Added the ``make_current`` keyword argument to the `IOLoop`
@@ -146,10 +140,14 @@
 
     .. versionchanged:: 5.0
 
-       Uses the `asyncio` event loop by default. The
-       ``IOLoop.configure`` method cannot be used on Python 3 except
-       to redundantly specify the `asyncio` event loop.
+       Uses the `asyncio` event loop by default. The ``IOLoop.configure`` method
+       cannot be used on Python 3 except to redundantly specify the `asyncio`
+       event loop.
 
+    .. versionchanged:: 6.3
+       ``make_current=True`` is now the default when creating an IOLoop -
+       previously the default was to make the event loop current if there wasn't
+       already a current one.
     """
 
     # These constants were originally based on constants from the epoll module.
@@ -165,15 +163,12 @@
     def configure(
         cls, impl: "UnionNone, str, TypeConfigurable", **kwargs: Any
     ) -> None:
-        if asyncio is not None:
-            from tornado.platform.asyncio import BaseAsyncIOLoop
-
-            if isinstance(impl, str):
-                impl = import_object(impl)
-            if isinstance(impl, type) and not issubclass(impl, BaseAsyncIOLoop):
-                raise RuntimeError(
-                    "only AsyncIOLoop is allowed when asyncio is available"
-                )
+        from tornado.platform.asyncio import BaseAsyncIOLoop
+
+        if isinstance(impl, str):
+            impl = import_object(impl)
+        if isinstance(impl, type) and not issubclass(impl, BaseAsyncIOLoop):
+            raise RuntimeError("only AsyncIOLoop is allowed when asyncio is available")
         super(IOLoop, cls).configure(impl, **kwargs)
 
     @staticmethod
@@ -258,20 +253,27 @@
            an alias for this method). ``instance=False`` is deprecated,
            since even if we do not create an `IOLoop`, this method
            may initialize the asyncio loop.
+
+        .. deprecated:: 6.2
+           It is deprecated to call ``IOLoop.current()`` when no `asyncio`
+           event loop is running.
         """
         try:
             loop = asyncio.get_event_loop()
-        except (RuntimeError, AssertionError):
+        except RuntimeError:
             if not instance:
                 return None
-            raise
+            # Create a new asyncio event loop for this thread.
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+
         try:
             return IOLoop._ioloop_for_asyncioloop
         except KeyError:
             if instance:
                 from tornado.platform.asyncio import AsyncIOMainLoop
 
-                current = AsyncIOMainLoop(make_current=True)  # type: OptionalIOLoop
+                current = AsyncIOMainLoop()  # type: OptionalIOLoop
             else:
                 current = None
         return current
@@ -291,7 +293,19 @@
 
         .. versionchanged:: 5.0
            This method also sets the current `asyncio` event loop.
+
+        .. deprecated:: 6.2
+           Setting and clearing the current event loop through Tornado is
+           deprecated. Use ``asyncio.set_event_loop`` instead if you need this.
         """
+        warnings.warn(
+            "make_current is deprecated; start the event loop first",

_service:tar_scm:tornado-6.1.tar.gz/tornado/iostream.py -> _service:tar_scm:tornado-6.3.2.tar.gz/tornado/iostream.py Changed

@@ -111,8 +111,7 @@
 
 
 class StreamBufferFullError(Exception):
-    """Exception raised by `IOStream` methods when the buffer is full.
-    """
+    """Exception raised by `IOStream` methods when the buffer is full."""
 
 
 class _StreamBuffer(object):
@@ -196,11 +195,9 @@
                 pos += size
                 size = 0
             else:
-                # Amortized O(1) shrink for Python 2
                 pos += size
-                if len(b) <= 2 * pos:
-                    del typing.cast(bytearray, b):pos
-                    pos = 0
+                del typing.cast(bytearray, b):pos
+                pos = 0
                 size = 0
 
         assert size == 0
@@ -255,7 +252,6 @@
         self.max_write_buffer_size = max_write_buffer_size
         self.error = None  # type: OptionalBaseException
         self._read_buffer = bytearray()
-        self._read_buffer_pos = 0
         self._read_buffer_size = 0
         self._user_read_buffer = False
         self._after_user_read_buffer = None  # type: Optionalbytearray
@@ -452,21 +448,17 @@
         available_bytes = self._read_buffer_size
         n = len(buf)
         if available_bytes >= n:
-            end = self._read_buffer_pos + n
-            buf: = memoryview(self._read_buffer)self._read_buffer_pos : end
-            del self._read_buffer:end
+            buf: = memoryview(self._read_buffer):n
+            del self._read_buffer:n
             self._after_user_read_buffer = self._read_buffer
         elif available_bytes > 0:
-            buf:available_bytes = memoryview(self._read_buffer)
-                self._read_buffer_pos :
-            
+            buf:available_bytes = memoryview(self._read_buffer):
 
         # Set up the supplied buffer as our temporary read buffer.
         # The original (if it had any data remaining) has been
         # saved for later.
         self._user_read_buffer = True
         self._read_buffer = buf
-        self._read_buffer_pos = 0
         self._read_buffer_size = available_bytes
         self._read_bytes = n
         self._read_partial = partial
@@ -498,7 +490,7 @@
         """
         future = self._start_read()
         if self.closed():
-            self._finish_read(self._read_buffer_size, False)
+            self._finish_read(self._read_buffer_size)
             return future
         self._read_until_close = True
         try:
@@ -530,6 +522,9 @@
         """
         self._check_closed()
         if data:
+            if isinstance(data, memoryview):
+                # Make sure that ``len(data) == data.nbytes``
+                data = memoryview(data).cast("B")
             if (
                 self.max_write_buffer_size is not None
                 and len(self._write_buffer) + len(data) > self.max_write_buffer_size
@@ -593,7 +588,7 @@
                         self.error = exc_info1
             if self._read_until_close:
                 self._read_until_close = False
-                self._finish_read(self._read_buffer_size, False)
+                self._finish_read(self._read_buffer_size)
             elif self._read_future is not None:
                 # resolve reads that are pending and ready to complete
                 try:
@@ -810,11 +805,10 @@
         self._read_future = Future()
         return self._read_future
 
-    def _finish_read(self, size: int, streaming: bool) -> None:
+    def _finish_read(self, size: int) -> None:
         if self._user_read_buffer:
             self._read_buffer = self._after_user_read_buffer or bytearray()
             self._after_user_read_buffer = None
-            self._read_buffer_pos = 0
             self._read_buffer_size = len(self._read_buffer)
             self._user_read_buffer = False
             result = size  # type: Unionint, bytes
@@ -902,7 +896,7 @@
         """
         self._read_bytes = self._read_delimiter = self._read_regex = None
         self._read_partial = False
-        self._finish_read(pos, False)
+        self._finish_read(pos)
 
     def _find_read_pos(self) -> Optionalint:
         """Attempts to find a position in the read buffer that satisfies
@@ -927,20 +921,17 @@
             # since large merges are relatively expensive and get undone in
             # _consume().
             if self._read_buffer:
-                loc = self._read_buffer.find(
-                    self._read_delimiter, self._read_buffer_pos
-                )
+                loc = self._read_buffer.find(self._read_delimiter)
                 if loc != -1:
-                    loc -= self._read_buffer_pos
                     delimiter_len = len(self._read_delimiter)
                     self._check_max_bytes(self._read_delimiter, loc + delimiter_len)
                     return loc + delimiter_len
                 self._check_max_bytes(self._read_delimiter, self._read_buffer_size)
         elif self._read_regex is not None:
             if self._read_buffer:
-                m = self._read_regex.search(self._read_buffer, self._read_buffer_pos)
+                m = self._read_regex.search(self._read_buffer)
                 if m is not None:
-                    loc = m.end() - self._read_buffer_pos
+                    loc = m.end()
                     self._check_max_bytes(self._read_regex, loc)
                     return loc
                 self._check_max_bytes(self._read_regex, self._read_buffer_size)
@@ -997,19 +988,9 @@
             return b""
         assert loc <= self._read_buffer_size
         # Slice the bytearray buffer into bytes, without intermediate copying
-        b = (
-            memoryview(self._read_buffer)
-                self._read_buffer_pos : self._read_buffer_pos + loc
-            
-        ).tobytes()
-        self._read_buffer_pos += loc
+        b = (memoryview(self._read_buffer):loc).tobytes()
         self._read_buffer_size -= loc
-        # Amortized O(1) shrink
-        # (this heuristic is implemented natively in Python 3.4+
-        #  but is replicated here for Python 2)
-        if self._read_buffer_pos > self._read_buffer_size:
-            del self._read_buffer: self._read_buffer_pos
-            self._read_buffer_pos = 0
+        del self._read_buffer:loc
         return b
 
     def _check_closed(self) -> None:
@@ -1088,9 +1069,8 @@
 
     .. testcode::
 
-        import tornado.ioloop
-        import tornado.iostream
         import socket
+        import tornado
 
         async def main():
             s = socket.socket(socket.AF_INET, socket.SOCK_STREAM, 0)
@@ -1108,11 +1088,7 @@
             stream.close()
 
         if __name__ == '__main__':
-            tornado.ioloop.IOLoop.current().run_sync(main)
-            s = socket.socket(socket.AF_INET, socket.SOCK_STREAM, 0)
-            stream = tornado.iostream.IOStream(s)
-            stream.connect(("friendfeed.com", 80), send_request)
-            tornado.ioloop.IOLoop.current().start()
+            asyncio.run(main())
 
     .. testoutput::
        :hide:
@@ -1528,6 +1504,7 @@
             self._ssl_options,
             server_hostname=self._server_hostname,
             do_handshake_on_connect=False,
+            server_side=False,
         )
         self._add_io_state(old_state)
 
@@ -1564,6 +1541,11 @@
         return future
 
     def write_to_fd(self, data: memoryview) -> int:
+        # clip buffer size at 1GB since SSL sockets only support upto 2GB
+        # this change in behaviour is transparent, since the function is
+        # already expected to (possibly) write less than the provided buffer
+        if len(data) >> 30:
+            data = memoryview(data): 1 << 30
         try:
             return self.socket.send(data)  # type: ignore
         except ssl.SSLError as e:
@@ -1588,6 +1570,11 @@
                 # to read (attempting to read may or may not raise an exception
                 # depending on the SSL version)

_service:tar_scm:tornado-6.1.tar.gz/tornado/locale.py -> _service:tar_scm:tornado-6.3.2.tar.gz/tornado/locale.py Changed

@@ -41,6 +41,7 @@
 import csv
 import datetime
 import gettext
+import glob
 import os
 import re
 
@@ -198,13 +199,12 @@
     global _supported_locales
     global _use_gettext
     _translations = {}
-    for lang in os.listdir(directory):
-        if lang.startswith("."):
-            continue  # skip .svn, etc
-        if os.path.isfile(os.path.join(directory, lang)):
-            continue
+
+    for filename in glob.glob(
+        os.path.join(directory, "*", "LC_MESSAGES", domain + ".mo")
+    ):
+        lang = os.path.basename(os.path.dirname(os.path.dirname(filename)))
         try:
-            os.stat(os.path.join(directory, lang, "LC_MESSAGES", domain + ".mo"))
             _translationslang = gettext.translation(
                 domain, directory, languages=lang
             )
@@ -268,7 +268,7 @@
 
     def __init__(self, code: str) -> None:
         self.code = code
-        self.name = LOCALE_NAMES.get(code, {}).get("name", u"Unknown")
+        self.name = LOCALE_NAMES.get(code, {}).get("name", "Unknown")
         self.rtl = False
         for prefix in "fa", "ar", "he":
             if self.code.startswith(prefix):
@@ -406,7 +406,7 @@
             str_time = "%d:%02d" % (local_date.hour, local_date.minute)
         elif self.code == "zh_CN":
             str_time = "%s%d:%02d" % (
-                (u"\u4e0a\u5348", u"\u4e0b\u5348")local_date.hour >= 12,
+                ("\u4e0a\u5348", "\u4e0b\u5348")local_date.hour >= 12,
                 local_date.hour % 12 or 12,
                 local_date.minute,
             )
@@ -458,7 +458,7 @@
             return ""
         if len(parts) == 1:
             return parts0
-        comma = u" \u0648 " if self.code.startswith("fa") else u", "
+        comma = " \u0648 " if self.code.startswith("fa") else ", "
         return _("%(commas)s and %(last)s") % {
             "commas": comma.join(parts:-1),
             "last": partslen(parts) - 1,

_service:tar_scm:tornado-6.1.tar.gz/tornado/locks.py -> _service:tar_scm:tornado-6.3.2.tar.gz/tornado/locks.py Changed

@@ -60,8 +60,8 @@
 
     .. testcode::
 
+        import asyncio
         from tornado import gen
-        from tornado.ioloop import IOLoop
         from tornado.locks import Condition
 
         condition = Condition()
@@ -80,7 +80,7 @@
             # Wait for waiter() and notifier() in parallel
             await gen.multi(waiter(), notifier())
 
-        IOLoop.current().run_sync(runner)
+        asyncio.run(runner())
 
     .. testoutput::
 
@@ -110,10 +110,6 @@
        next iteration of the `.IOLoop`.
     """
 
-    def __init__(self) -> None:
-        super().__init__()
-        self.io_loop = ioloop.IOLoop.current()
-
     def __repr__(self) -> str:
         result = "<%s" % (self.__class__.__name__,)
         if self._waiters:
@@ -169,8 +165,8 @@
 
     .. testcode::
 
+        import asyncio
         from tornado import gen
-        from tornado.ioloop import IOLoop
         from tornado.locks import Event
 
         event = Event()
@@ -189,7 +185,7 @@
         async def runner():
             await gen.multi(waiter(), setter())
 
-        IOLoop.current().run_sync(runner)
+        asyncio.run(runner())
 
     .. testoutput::
 
@@ -262,10 +258,10 @@
 class _ReleasingContextManager(object):
     """Releases a Lock or Semaphore at the end of a "with" statement.
 
-        with (yield semaphore.acquire()):
-            pass
+    with (yield semaphore.acquire()):
+        pass
 
-        # Now semaphore.release() has been called.
+    # Now semaphore.release() has been called.
     """
 
     def __init__(self, obj: Any) -> None:
@@ -302,8 +298,7 @@
        from tornado.ioloop import IOLoop
        from tornado.concurrent import Future
 
-       # Ensure reliable doctest output: resolve Futures one at a time.
-       futures_q = deque(Future() for _ in range(3))
+       inited = False
 
        async def simulator(futures):
            for f in futures:
@@ -312,15 +307,21 @@
                await gen.sleep(0)
                f.set_result(None)
 
-       IOLoop.current().add_callback(simulator, list(futures_q))
-
        def use_some_resource():
+           global inited
+           global futures_q
+           if not inited:
+               inited = True
+               # Ensure reliable doctest output: resolve Futures one at a time.
+               futures_q = deque(Future() for _ in range(3))
+               IOLoop.current().add_callback(simulator, list(futures_q))
+
            return futures_q.popleft()
 
     .. testcode:: semaphore
 
+        import asyncio
         from tornado import gen
-        from tornado.ioloop import IOLoop
         from tornado.locks import Semaphore
 
         sem = Semaphore(2)
@@ -338,7 +339,7 @@
             # Join all workers.
             await gen.multi(worker(i) for i in range(3))
 
-        IOLoop.current().run_sync(runner)
+        asyncio.run(runner())
 
     .. testoutput:: semaphore

_service:tar_scm:tornado-6.1.tar.gz/tornado/log.py -> _service:tar_scm:tornado-6.3.2.tar.gz/tornado/log.py Changed

_service:tar_scm:tornado-6.1.tar.gz/tornado/netutil.py -> _service:tar_scm:tornado-6.3.2.tar.gz/tornado/netutil.py Changed

@@ -15,6 +15,7 @@
 
 """Miscellaneous network utility code."""
 
+import asyncio
 import concurrent.futures
 import errno
 import os
@@ -30,7 +31,7 @@
 from typing import List, Callable, Any, Type, Dict, Union, Tuple, Awaitable, Optional
 
 # Note that the naming of ssl.Purpose is confusing; the purpose
-# of a context is to authentiate the opposite side of the connection.
+# of a context is to authenticate the opposite side of the connection.
 _client_ssl_defaults = ssl.create_default_context(ssl.Purpose.SERVER_AUTH)
 _server_ssl_defaults = ssl.create_default_context(ssl.Purpose.CLIENT_AUTH)
 if hasattr(ssl, "OP_NO_COMPRESSION"):
@@ -43,10 +44,10 @@
 # module-import time, the import lock is already held by the main thread,
 # leading to deadlock. Avoid it by caching the idna encoder on the main
 # thread now.
-u"foo".encode("idna")
+"foo".encode("idna")
 
 # For undiagnosed reasons, 'latin1' codec may also need to be preloaded.
-u"foo".encode("latin1")
+"foo".encode("latin1")
 
 # Default backlog used when calling sock.listen()
 _DEFAULT_BACKLOG = 128
@@ -114,7 +115,7 @@
             sys.platform == "darwin"
             and address == "localhost"
             and af == socket.AF_INET6
-            and sockaddr3 != 0
+            and sockaddr3 != 0  # type: ignore
         ):
             # Mac OS X includes a link-local address fe80::1%lo0 in the
             # getaddrinfo results for 'localhost'.  However, the firewall
@@ -301,6 +302,12 @@
         if e.args0 == socket.EAI_NONAME:
             return False
         raise
+    except UnicodeError:
+        # `socket.getaddrinfo` will raise a UnicodeError from the
+        # `idna` decoder if the input is longer than 63 characters,
+        # even for socket.AI_NUMERICHOST.  See
+        # https://bugs.python.org/issue32958 for discussion
+        return False
     return True
 
 
@@ -316,16 +323,21 @@
 
     The implementations of this interface included with Tornado are
 
-    * `tornado.netutil.DefaultExecutorResolver`
+    * `tornado.netutil.DefaultLoopResolver`
+    * `tornado.netutil.DefaultExecutorResolver` (deprecated)
     * `tornado.netutil.BlockingResolver` (deprecated)
     * `tornado.netutil.ThreadedResolver` (deprecated)
     * `tornado.netutil.OverrideResolver`
-    * `tornado.platform.twisted.TwistedResolver`
-    * `tornado.platform.caresresolver.CaresResolver`
+    * `tornado.platform.twisted.TwistedResolver` (deprecated)
+    * `tornado.platform.caresresolver.CaresResolver` (deprecated)
 
     .. versionchanged:: 5.0
        The default implementation has changed from `BlockingResolver` to
        `DefaultExecutorResolver`.
+
+    .. versionchanged:: 6.2
+       The default implementation has changed from `DefaultExecutorResolver` to
+       `DefaultLoopResolver`.
     """
 
     @classmethod
@@ -334,7 +346,7 @@
 
     @classmethod
     def configurable_default(cls) -> Type"Resolver":
-        return DefaultExecutorResolver
+        return DefaultLoopResolver
 
     def resolve(
         self, host: str, port: int, family: socket.AddressFamily = socket.AF_UNSPEC
@@ -390,6 +402,10 @@
     """Resolver implementation using `.IOLoop.run_in_executor`.
 
     .. versionadded:: 5.0
+
+    .. deprecated:: 6.2
+
+       Use `DefaultLoopResolver` instead.
     """
 
     async def resolve(
@@ -401,6 +417,25 @@
         return result
 
 
+class DefaultLoopResolver(Resolver):
+    """Resolver implementation using `asyncio.loop.getaddrinfo`."""
+
+    async def resolve(
+        self, host: str, port: int, family: socket.AddressFamily = socket.AF_UNSPEC
+    ) -> ListTupleint, Any:
+        # On Solaris, getaddrinfo fails if the given port is not found
+        # in /etc/services and no socket type is given, so we must pass
+        # one here.  The socket type used here doesn't seem to actually
+        # matter (we discard the one we get back in the results),
+        # so the addresses we return should still be usable with SOCK_DGRAM.
+        return 
+            (fam, address)
+            for fam, _, _, _, address in await asyncio.get_running_loop().getaddrinfo(
+                host, port, family=family, type=socket.SOCK_STREAM
+            )
+        
+
+
 class ExecutorResolver(Resolver):
     """Resolver implementation using a `concurrent.futures.Executor`.
 
@@ -415,8 +450,8 @@
        The ``io_loop`` argument (deprecated since version 4.1) has been removed.
 
     .. deprecated:: 5.0
-       The default `Resolver` now uses `.IOLoop.run_in_executor`; use that instead
-       of this class.
+       The default `Resolver` now uses `asyncio.loop.getaddrinfo`;
+       use that instead of this class.
     """
 
     def initialize(
@@ -424,7 +459,6 @@
         executor: Optionalconcurrent.futures.Executor = None,
         close_executor: bool = True,
     ) -> None:
-        self.io_loop = IOLoop.current()
         if executor is not None:
             self.executor = executor
             self.close_executor = close_executor
@@ -553,7 +587,8 @@
 
 
 def ssl_options_to_context(
-    ssl_options: UnionDictstr, Any, ssl.SSLContext
+    ssl_options: UnionDictstr, Any, ssl.SSLContext,
+    server_side: Optionalbool = None,
 ) -> ssl.SSLContext:
     """Try to convert an ``ssl_options`` dictionary to an
     `~ssl.SSLContext` object.
@@ -564,19 +599,34 @@
     `~ssl.SSLContext` equivalent, and may be used when a component which
     accepts both forms needs to upgrade to the `~ssl.SSLContext` version
     to use features like SNI or NPN.
+
+    .. versionchanged:: 6.2
+
+       Added server_side argument. Omitting this argument will
+       result in a DeprecationWarning on Python 3.10.
+
     """
     if isinstance(ssl_options, ssl.SSLContext):
         return ssl_options
     assert isinstance(ssl_options, dict)
     assert all(k in _SSL_CONTEXT_KEYWORDS for k in ssl_options), ssl_options
-    # Can't use create_default_context since this interface doesn't
-    # tell us client vs server.
-    context = ssl.SSLContext(ssl_options.get("ssl_version", ssl.PROTOCOL_SSLv23))
+    # TODO: Now that we have the server_side argument, can we switch to
+    # create_default_context or would that change behavior?
+    default_version = ssl.PROTOCOL_TLS
+    if server_side:
+        default_version = ssl.PROTOCOL_TLS_SERVER
+    elif server_side is not None:
+        default_version = ssl.PROTOCOL_TLS_CLIENT
+    context = ssl.SSLContext(ssl_options.get("ssl_version", default_version))
     if "certfile" in ssl_options:
         context.load_cert_chain(
             ssl_options"certfile", ssl_options.get("keyfile", None)
         )
     if "cert_reqs" in ssl_options:
+        if ssl_options"cert_reqs" == ssl.CERT_NONE:
+            # This may have been set automatically by PROTOCOL_TLS_CLIENT but is
+            # incompatible with CERT_NONE so we must manually clear it.
+            context.check_hostname = False
         context.verify_mode = ssl_options"cert_reqs"
     if "ca_certs" in ssl_options:
         context.load_verify_locations(ssl_options"ca_certs")
@@ -595,6 +645,7 @@
     socket: socket.socket,
     ssl_options: UnionDictstr, Any, ssl.SSLContext,
     server_hostname: Optionalstr = None,
+    server_side: Optionalbool = None,
     **kwargs: Any
 ) -> ssl.SSLSocket:
     """Returns an ``ssl.SSLSocket`` wrapping the given socket.
@@ -604,14 +655,23 @@
     keyword arguments are passed to ``wrap_socket`` (either the

_service:tar_scm:tornado-6.1.tar.gz/tornado/options.py -> _service:tar_scm:tornado-6.3.2.tar.gz/tornado/options.py Changed

@@ -56,7 +56,7 @@
 either `parse_command_line` or `parse_config_file`::
 
     import myapp.db, myapp.server
-    import tornado.options
+    import tornado
 
     if __name__ == '__main__':
         tornado.options.parse_command_line()
@@ -86,6 +86,12 @@
        options.logging = None
        parse_command_line()
 
+.. note::
+
+   `parse_command_line` or `parse_config_file` function should called after
+   logging configuration and user-defined command line flags using the
+   ``callback`` option definition, or these configurations will not take effect.
+
 .. versionchanged:: 4.3
    Dashes and underscores are fully interchangeable in option names;
    options can be defined, set, and read with any mix of the two.
@@ -266,17 +272,22 @@
                 % (normalized, self._optionsnormalized.file_name)
             )
         frame = sys._getframe(0)
-        options_file = frame.f_code.co_filename
-
-        # Can be called directly, or through top level define() fn, in which
-        # case, step up above that frame to look for real caller.
-        if (
-            frame.f_back.f_code.co_filename == options_file
-            and frame.f_back.f_code.co_name == "define"
-        ):
-            frame = frame.f_back
-
-        file_name = frame.f_back.f_code.co_filename
+        if frame is not None:
+            options_file = frame.f_code.co_filename
+
+            # Can be called directly, or through top level define() fn, in which
+            # case, step up above that frame to look for real caller.
+            if (
+                frame.f_back is not None
+                and frame.f_back.f_code.co_filename == options_file
+                and frame.f_back.f_code.co_name == "define"
+            ):
+                frame = frame.f_back
+
+            assert frame.f_back is not None
+            file_name = frame.f_back.f_code.co_filename
+        else:
+            file_name = "<unknown>"
         if file_name == options_file:
             file_name = ""
         if type is None:
@@ -416,7 +427,9 @@
                             % (option.name, option.type.__name__)
                         )
 
-                if type(configname) == str and option.type != str:
+                if type(configname) == str and (
+                    option.type != str or option.multiple
+                ):
                     option.parse(configname)
                 else:
                     option.set(configname)
@@ -651,7 +664,9 @@
                 num = float(m.group(1))
                 units = m.group(2) or "seconds"
                 units = self._TIMEDELTA_ABBREV_DICT.get(units, units)
-                sum += datetime.timedelta(**{units: num})
+                # This line confuses mypy when setup.py sets python_version=3.6
+                # https://github.com/python/mypy/issues/9676
+                sum += datetime.timedelta(**{units: num})  # type: ignore
                 start = m.end()
             return sum
         except Exception:

_service:tar_scm:tornado-6.1.tar.gz/tornado/platform/asyncio.py -> _service:tar_scm:tornado-6.3.2.tar.gz/tornado/platform/asyncio.py Changed

@@ -32,13 +32,14 @@
 import sys
 import threading
 import typing
+import warnings
 from tornado.gen import convert_yielded
 from tornado.ioloop import IOLoop, _Selectable
 
-from typing import Any, TypeVar, Awaitable, Callable, Union, Optional, List, Tuple, Dict
+from typing import Any, TypeVar, Awaitable, Callable, Union, Optional, List, Dict
 
 if typing.TYPE_CHECKING:
-    from typing import Set  # noqa: F401
+    from typing import Set, Tuple  # noqa: F401
     from typing_extensions import Protocol
 
     class _HasFileno(Protocol):
@@ -108,20 +109,22 @@
         # TODO(bdarnell): consider making self.asyncio_loop a weakref
         # for AsyncIOMainLoop and make _ioloop_for_asyncio a
         # WeakKeyDictionary.
-        for loop in list(IOLoop._ioloop_for_asyncio):
+        for loop in IOLoop._ioloop_for_asyncio.copy():
             if loop.is_closed():
-                del IOLoop._ioloop_for_asyncioloop
-        IOLoop._ioloop_for_asyncioasyncio_loop = self
-
-        self._thread_identity = 0
+                try:
+                    del IOLoop._ioloop_for_asyncioloop
+                except KeyError:
+                    pass
+
+        # Make sure we don't already have an IOLoop for this asyncio loop
+        existing_loop = IOLoop._ioloop_for_asyncio.setdefault(asyncio_loop, self)
+        if existing_loop is not self:
+            raise RuntimeError(
+                f"IOLoop {existing_loop} already associated with asyncio loop {asyncio_loop}"
+            )
 
         super().initialize(**kwargs)
 
-        def assign_thread_identity() -> None:
-            self._thread_identity = threading.get_ident()
-
-        self.add_callback(assign_thread_identity)
-
     def close(self, all_fds: bool = False) -> None:
         self.closing = True
         for fd in list(self.handlers):
@@ -189,22 +192,13 @@
         handler_func(fileobj, events)
 
     def start(self) -> None:
-        try:
-            old_loop = asyncio.get_event_loop()
-        except (RuntimeError, AssertionError):
-            old_loop = None  # type: ignore
-        try:
-            self._setup_logging()
-            asyncio.set_event_loop(self.asyncio_loop)
-            self.asyncio_loop.run_forever()
-        finally:
-            asyncio.set_event_loop(old_loop)
+        self.asyncio_loop.run_forever()
 
     def stop(self) -> None:
         self.asyncio_loop.stop()
 
     def call_at(
-        self, when: float, callback: Callable..., None, *args: Any, **kwargs: Any
+        self, when: float, callback: Callable, *args: Any, **kwargs: Any
     ) -> object:
         # asyncio.call_at supports *args but not **kwargs, so bind them here.
         # We do not synchronize self.time and asyncio_loop.time, so
@@ -219,10 +213,14 @@
         timeout.cancel()  # type: ignore
 
     def add_callback(self, callback: Callable, *args: Any, **kwargs: Any) -> None:
-        if threading.get_ident() == self._thread_identity:
-            call_soon = self.asyncio_loop.call_soon
-        else:
+        try:
+            if asyncio.get_running_loop() is self.asyncio_loop:
+                call_soon = self.asyncio_loop.call_soon
+            else:
+                call_soon = self.asyncio_loop.call_soon_threadsafe
+        except RuntimeError:
             call_soon = self.asyncio_loop.call_soon_threadsafe
+
         try:
             call_soon(self._run_callback, functools.partial(callback, *args, **kwargs))
         except RuntimeError:
@@ -252,7 +250,7 @@
         self,
         executor: Optionalconcurrent.futures.Executor,
         func: Callable..., _T,
-        *args: Any
+        *args: Any,
     ) -> Awaitable_T:
         return self.asyncio_loop.run_in_executor(executor, func, *args)
 
@@ -278,7 +276,7 @@
     def initialize(self, **kwargs: Any) -> None:  # type: ignore
         super().initialize(asyncio.get_event_loop(), **kwargs)
 
-    def make_current(self) -> None:
+    def _make_current(self) -> None:
         # AsyncIOMainLoop already refers to the current asyncio loop so
         # nothing to do here.
         pass
@@ -293,6 +291,12 @@
     Each ``AsyncIOLoop`` creates a new ``asyncio.EventLoop``; this object
     can be accessed with the ``asyncio_loop`` attribute.
 
+    .. versionchanged:: 6.2
+
+       Support explicit ``asyncio_loop`` argument
+       for specifying the asyncio loop to attach to,
+       rather than always creating a new one with the default policy.
+
     .. versionchanged:: 5.0
 
        When an ``AsyncIOLoop`` becomes the current `.IOLoop`, it also sets
@@ -306,21 +310,24 @@
 
     def initialize(self, **kwargs: Any) -> None:  # type: ignore
         self.is_current = False
-        loop = asyncio.new_event_loop()
+        loop = None
+        if "asyncio_loop" not in kwargs:
+            kwargs"asyncio_loop" = loop = asyncio.new_event_loop()
         try:
-            super().initialize(loop, **kwargs)
+            super().initialize(**kwargs)
         except Exception:
             # If initialize() does not succeed (taking ownership of the loop),
             # we have to close it.
-            loop.close()
+            if loop is not None:
+                loop.close()
             raise
 
     def close(self, all_fds: bool = False) -> None:
         if self.is_current:
-            self.clear_current()
+            self._clear_current()
         super().close(all_fds=all_fds)
 
-    def make_current(self) -> None:
+    def _make_current(self) -> None:
         if not self.is_current:
             try:
                 self.old_asyncio = asyncio.get_event_loop()
@@ -387,8 +394,26 @@
 
     .. versionadded:: 5.0
 
+    .. deprecated:: 6.2
+
+        ``AnyThreadEventLoopPolicy`` affects the implicit creation
+        of an event loop, which is deprecated in Python 3.10 and
+        will be removed in a future version of Python. At that time
+        ``AnyThreadEventLoopPolicy`` will no longer be useful.
+        If you are relying on it, use `asyncio.new_event_loop`
+        or `asyncio.run` explicitly in any non-main threads that
+        need event loops.
     """
 
+    def __init__(self) -> None:
+        super().__init__()
+        warnings.warn(
+            "AnyThreadEventLoopPolicy is deprecated, use asyncio.run "
+            "or asyncio.new_event_loop instead",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+
     def get_event_loop(self) -> asyncio.AbstractEventLoop:
         try:
             return super().get_event_loop()
@@ -463,7 +488,9 @@
         )  # type: OptionalTupleList_FileDescriptorLike, List_FileDescriptorLike
         self._closing_selector = False
         self._thread = threading.Thread(
-            name="Tornado selector", daemon=True, target=self._run_select,
+            name="Tornado selector",
+            daemon=True,
+            target=self._run_select,
         )
         self._thread.start()
         # Start the select loop once the loop is started.
@@ -570,7 +597,21 @@
                         raise
                 else:
                     raise
-            self._real_loop.call_soon_threadsafe(self._handle_select, rs, ws)
+
+            try:
+                self._real_loop.call_soon_threadsafe(self._handle_select, rs, ws)

_service:tar_scm:tornado-6.1.tar.gz/tornado/platform/caresresolver.py -> _service:tar_scm:tornado-6.3.2.tar.gz/tornado/platform/caresresolver.py Changed

@@ -15,17 +15,22 @@
 class CaresResolver(Resolver):
     """Name resolver based on the c-ares library.
 
-    This is a non-blocking and non-threaded resolver.  It may not produce
-    the same results as the system resolver, but can be used for non-blocking
+    This is a non-blocking and non-threaded resolver.  It may not produce the
+    same results as the system resolver, but can be used for non-blocking
     resolution when threads cannot be used.
 
-    c-ares fails to resolve some names when ``family`` is ``AF_UNSPEC``,
-    so it is only recommended for use in ``AF_INET`` (i.e. IPv4).  This is
-    the default for ``tornado.simple_httpclient``, but other libraries
-    may default to ``AF_UNSPEC``.
+    ``pycares`` will not return a mix of ``AF_INET`` and ``AF_INET6`` when
+    ``family`` is ``AF_UNSPEC``, so it is only recommended for use in
+    ``AF_INET`` (i.e. IPv4).  This is the default for
+    ``tornado.simple_httpclient``, but other libraries may default to
+    ``AF_UNSPEC``.
 
     .. versionchanged:: 5.0
        The ``io_loop`` argument (deprecated since version 4.1) has been removed.
+
+    .. deprecated:: 6.2
+       This class is deprecated and will be removed in Tornado 7.0. Use the default
+       thread-based resolver instead.
     """
 
     def initialize(self) -> None:

_service:tar_scm:tornado-6.1.tar.gz/tornado/platform/twisted.py -> _service:tar_scm:tornado-6.3.2.tar.gz/tornado/platform/twisted.py Changed

_service:tar_scm:tornado-6.1.tar.gz/tornado/queues.py -> _service:tar_scm:tornado-6.3.2.tar.gz/tornado/queues.py Changed

@@ -85,7 +85,7 @@
 
     .. testcode::
 
-        from tornado import gen
+        import asyncio
         from tornado.ioloop import IOLoop
         from tornado.queues import Queue
 
@@ -95,7 +95,7 @@
             async for item in q:
                 try:
                     print('Doing work on %s' % item)
-                    await gen.sleep(0.01)
+                    await asyncio.sleep(0.01)
                 finally:
                     q.task_done()
 
@@ -111,7 +111,7 @@
             await q.join()       # Wait for consumer to finish all tasks.
             print('Done')
 
-        IOLoop.current().run_sync(main)
+        asyncio.run(main())
 
     .. testoutput::
 
@@ -353,16 +353,20 @@
 
     .. testcode::
 
+        import asyncio
         from tornado.queues import PriorityQueue
 
-        q = PriorityQueue()
-        q.put((1, 'medium-priority item'))
-        q.put((0, 'high-priority item'))
-        q.put((10, 'low-priority item'))
+        async def main():
+            q = PriorityQueue()
+            q.put((1, 'medium-priority item'))
+            q.put((0, 'high-priority item'))
+            q.put((10, 'low-priority item'))
+
+            print(await q.get())
+            print(await q.get())
+            print(await q.get())
 
-        print(q.get_nowait())
-        print(q.get_nowait())
-        print(q.get_nowait())
+        asyncio.run(main())
 
     .. testoutput::
 
@@ -377,7 +381,7 @@
     def _put(self, item: _T) -> None:
         heapq.heappush(self._queue, item)
 
-    def _get(self) -> _T:
+    def _get(self) -> _T:  # type: ignoretype-var
         return heapq.heappop(self._queue)
 
 
@@ -386,16 +390,20 @@
 
     .. testcode::
 
+        import asyncio
         from tornado.queues import LifoQueue
 
-        q = LifoQueue()
-        q.put(3)
-        q.put(2)
-        q.put(1)
+        async def main():
+            q = LifoQueue()
+            q.put(3)
+            q.put(2)
+            q.put(1)
+
+            print(await q.get())
+            print(await q.get())
+            print(await q.get())
 
-        print(q.get_nowait())
-        print(q.get_nowait())
-        print(q.get_nowait())
+        asyncio.run(main())
 
     .. testoutput::
 
@@ -410,5 +418,5 @@
     def _put(self, item: _T) -> None:
         self._queue.append(item)
 
-    def _get(self) -> _T:
+    def _get(self) -> _T:  # type: ignoretype-var
         return self._queue.pop()

_service:tar_scm:tornado-6.1.tar.gz/tornado/simple_httpclient.py -> _service:tar_scm:tornado-6.3.2.tar.gz/tornado/simple_httpclient.py Changed

@@ -84,6 +84,35 @@
     supported.  In particular, proxies are not supported, connections
     are not reused, and callers cannot select the network interface to be
     used.
+
+    This implementation supports the following arguments, which can be passed
+    to ``configure()`` to control the global singleton, or to the constructor
+    when ``force_instance=True``.
+
+    ``max_clients`` is the number of concurrent requests that can be
+    in progress; when this limit is reached additional requests will be
+    queued. Note that time spent waiting in this queue still counts
+    against the ``request_timeout``.
+
+    ``defaults`` is a dict of parameters that will be used as defaults on all
+    `.HTTPRequest` objects submitted to this client.
+
+    ``hostname_mapping`` is a dictionary mapping hostnames to IP addresses.
+    It can be used to make local DNS changes when modifying system-wide
+    settings like ``/etc/hosts`` is not possible or desirable (e.g. in
+    unittests). ``resolver`` is similar, but using the `.Resolver` interface
+    instead of a simple mapping.
+
+    ``max_buffer_size`` (default 100MB) is the number of bytes
+    that can be read into memory at once. ``max_body_size``
+    (defaults to ``max_buffer_size``) is the largest response body
+    that the client will accept.  Without a
+    ``streaming_callback``, the smaller of these two limits
+    applies; with a ``streaming_callback`` only ``max_body_size``
+    does.
+
+    .. versionchanged:: 4.2
+        Added the ``max_body_size`` argument.
     """
 
     def initialize(  # type: ignore
@@ -96,38 +125,6 @@
         max_header_size: Optionalint = None,
         max_body_size: Optionalint = None,
     ) -> None:
-        """Creates a AsyncHTTPClient.
-
-        Only a single AsyncHTTPClient instance exists per IOLoop
-        in order to provide limitations on the number of pending connections.
-        ``force_instance=True`` may be used to suppress this behavior.
-
-        Note that because of this implicit reuse, unless ``force_instance``
-        is used, only the first call to the constructor actually uses
-        its arguments. It is recommended to use the ``configure`` method
-        instead of the constructor to ensure that arguments take effect.
-
-        ``max_clients`` is the number of concurrent requests that can be
-        in progress; when this limit is reached additional requests will be
-        queued. Note that time spent waiting in this queue still counts
-        against the ``request_timeout``.
-
-        ``hostname_mapping`` is a dictionary mapping hostnames to IP addresses.
-        It can be used to make local DNS changes when modifying system-wide
-        settings like ``/etc/hosts`` is not possible or desirable (e.g. in
-        unittests).
-
-        ``max_buffer_size`` (default 100MB) is the number of bytes
-        that can be read into memory at once. ``max_body_size``
-        (defaults to ``max_buffer_size``) is the largest response body
-        that the client will accept.  Without a
-        ``streaming_callback``, the smaller of these two limits
-        applies; with a ``streaming_callback`` only ``max_body_size``
-        does.
-
-        .. versionchanged:: 4.2
-           Added the ``max_body_size`` argument.
-        """
         super().initialize(defaults=defaults)
         self.max_clients = max_clients
         self.queue = (
@@ -325,11 +322,16 @@
                         % (self.request.network_interface,)
                     )
 
-            timeout = (
-                min(self.request.connect_timeout, self.request.request_timeout)
-                or self.request.connect_timeout
-                or self.request.request_timeout
-            )  # min but skip zero
+            if self.request.connect_timeout and self.request.request_timeout:
+                timeout = min(
+                    self.request.connect_timeout, self.request.request_timeout
+                )
+            elif self.request.connect_timeout:
+                timeout = self.request.connect_timeout
+            elif self.request.request_timeout:
+                timeout = self.request.request_timeout
+            else:
+                timeout = 0
             if timeout:
                 self._timeout = self.io_loop.add_timeout(
                     self.start_time + timeout,
@@ -545,7 +547,7 @@
         value: OptionalBaseException,
         tb: OptionalTracebackType,
     ) -> bool:
-        if self.final_callback:
+        if self.final_callback is not None:
             self._remove_timeout()
             if isinstance(value, StreamClosedError):
                 if value.real_error is None:
@@ -626,10 +628,12 @@
         original_request = getattr(self.request, "original_request", self.request)
         if self._should_follow_redirect():
             assert isinstance(self.request, _RequestProxy)
+            assert self.headers is not None
             new_request = copy.copy(self.request.request)
             new_request.url = urllib.parse.urljoin(
                 self.request.url, self.headers"Location"
             )
+            assert self.request.max_redirects is not None
             new_request.max_redirects = self.request.max_redirects - 1
             del new_request.headers"Host"
             # https://tools.ietf.org/html/rfc7231#section-6.4
@@ -645,7 +649,7 @@
                 self.code in (301, 302) and self.request.method == "POST"
             ):
                 new_request.method = "GET"
-                new_request.body = None
+                new_request.body = None  # type: ignore
                 for h in 
                     "Content-Length",
                     "Content-Type",
@@ -656,10 +660,11 @@
                         del self.request.headersh
                     except KeyError:
                         pass
-            new_request.original_request = original_request
+            new_request.original_request = original_request  # type: ignore
             final_callback = self.final_callback
-            self.final_callback = None
+            self.final_callback = None  # type: ignore
             self._release()
+            assert self.client is not None
             fut = self.client.fetch(new_request, raise_error=False)
             fut.add_done_callback(lambda f: final_callback(f.result()))
             self._on_end_request()

_service:tar_scm:tornado-6.1.tar.gz/tornado/tcpclient.py -> _service:tar_scm:tornado-6.3.2.tar.gz/tornado/tcpclient.py Changed

_service:tar_scm:tornado-6.1.tar.gz/tornado/tcpserver.py -> _service:tar_scm:tornado-6.3.2.tar.gz/tornado/tcpserver.py Changed

@@ -24,7 +24,12 @@
 from tornado.log import app_log
 from tornado.ioloop import IOLoop
 from tornado.iostream import IOStream, SSLIOStream
-from tornado.netutil import bind_sockets, add_accept_handler, ssl_wrap_socket
+from tornado.netutil import (
+    bind_sockets,
+    add_accept_handler,
+    ssl_wrap_socket,
+    _DEFAULT_BACKLOG,
+)
 from tornado import process
 from tornado.util import errno_from_exception
 
@@ -43,14 +48,13 @@
 
       from tornado.tcpserver import TCPServer
       from tornado.iostream import StreamClosedError
-      from tornado import gen
 
       class EchoServer(TCPServer):
           async def handle_stream(self, stream, address):
               while True:
                   try:
-                      data = await stream.read_until(b"\n")
-                      await stream.write(data)
+                      data = await stream.read_until(b"\n") await
+                      stream.write(data)
                   except StreamClosedError:
                       break
 
@@ -66,37 +70,49 @@
 
     `TCPServer` initialization follows one of three patterns:
 
-    1. `listen`: simple single-process::
+    1. `listen`: single-process::
 
-            server = TCPServer()
-            server.listen(8888)
-            IOLoop.current().start()
+            async def main():
+                server = TCPServer()
+                server.listen(8888)
+                await asyncio.Event.wait()
 
-    2. `bind`/`start`: simple multi-process::
-
-            server = TCPServer()
-            server.bind(8888)
-            server.start(0)  # Forks multiple sub-processes
-            IOLoop.current().start()
+            asyncio.run(main())
 
-       When using this interface, an `.IOLoop` must *not* be passed
-       to the `TCPServer` constructor.  `start` will always start
-       the server on the default singleton `.IOLoop`.
+       While this example does not create multiple processes on its own, when
+       the ``reuse_port=True`` argument is passed to ``listen()`` you can run
+       the program multiple times to create a multi-process service.
 
-    3. `add_sockets`: advanced multi-process::
+    2. `add_sockets`: multi-process::
 
             sockets = bind_sockets(8888)
             tornado.process.fork_processes(0)
+            async def post_fork_main():
+                server = TCPServer()
+                server.add_sockets(sockets)
+                await asyncio.Event().wait()
+            asyncio.run(post_fork_main())
+
+       The `add_sockets` interface is more complicated, but it can be used with
+       `tornado.process.fork_processes` to run a multi-process service with all
+       worker processes forked from a single parent.  `add_sockets` can also be
+       used in single-process servers if you want to create your listening
+       sockets in some way other than `~tornado.netutil.bind_sockets`.
+
+       Note that when using this pattern, nothing that touches the event loop
+       can be run before ``fork_processes``.
+
+    3. `bind`/`start`: simple **deprecated** multi-process::
+
             server = TCPServer()
-            server.add_sockets(sockets)
+            server.bind(8888)
+            server.start(0)  # Forks multiple sub-processes
             IOLoop.current().start()
 
-       The `add_sockets` interface is more complicated, but it can be
-       used with `tornado.process.fork_processes` to give you more
-       flexibility in when the fork happens.  `add_sockets` can
-       also be used in single-process servers if you want to create
-       your listening sockets in some way other than
-       `~tornado.netutil.bind_sockets`.
+       This pattern is deprecated because it requires interfaces in the
+       `asyncio` module that have been deprecated since Python 3.10. Support for
+       creating multiple processes in the ``start`` method will be removed in a
+       future version of Tornado.
 
     .. versionadded:: 3.1
        The ``max_buffer_size`` argument.
@@ -140,15 +156,38 @@
                     'keyfile "%s" does not exist' % self.ssl_options"keyfile"
                 )
 
-    def listen(self, port: int, address: str = "") -> None:
+    def listen(
+        self,
+        port: int,
+        address: Optionalstr = None,
+        family: socket.AddressFamily = socket.AF_UNSPEC,
+        backlog: int = _DEFAULT_BACKLOG,
+        flags: Optionalint = None,
+        reuse_port: bool = False,
+    ) -> None:
         """Starts accepting connections on the given port.
 
         This method may be called more than once to listen on multiple ports.
         `listen` takes effect immediately; it is not necessary to call
-        `TCPServer.start` afterwards.  It is, however, necessary to start
-        the `.IOLoop`.
+        `TCPServer.start` afterwards.  It is, however, necessary to start the
+        event loop if it is not already running.
+
+        All arguments have the same meaning as in
+        `tornado.netutil.bind_sockets`.
+
+        .. versionchanged:: 6.2
+
+           Added ``family``, ``backlog``, ``flags``, and ``reuse_port``
+           arguments to match `tornado.netutil.bind_sockets`.
         """
-        sockets = bind_sockets(port, address=address)
+        sockets = bind_sockets(
+            port,
+            address=address,
+            family=family,
+            backlog=backlog,
+            flags=flags,
+            reuse_port=reuse_port,
+        )
         self.add_sockets(sockets)
 
     def add_sockets(self, sockets: Iterablesocket.socket) -> None:
@@ -175,34 +214,47 @@
         port: int,
         address: Optionalstr = None,
         family: socket.AddressFamily = socket.AF_UNSPEC,
-        backlog: int = 128,
+        backlog: int = _DEFAULT_BACKLOG,
+        flags: Optionalint = None,
         reuse_port: bool = False,
     ) -> None:
         """Binds this server to the given port on the given address.
 
-        To start the server, call `start`. If you want to run this server
-        in a single process, you can call `listen` as a shortcut to the
-        sequence of `bind` and `start` calls.
+        To start the server, call `start`. If you want to run this server in a
+        single process, you can call `listen` as a shortcut to the sequence of
+        `bind` and `start` calls.
 
         Address may be either an IP address or hostname.  If it's a hostname,
-        the server will listen on all IP addresses associated with the
-        name.  Address may be an empty string or None to listen on all
-        available interfaces.  Family may be set to either `socket.AF_INET`
-        or `socket.AF_INET6` to restrict to IPv4 or IPv6 addresses, otherwise
-        both will be used if available.
+        the server will listen on all IP addresses associated with the name.
+        Address may be an empty string or None to listen on all available
+        interfaces.  Family may be set to either `socket.AF_INET` or
+        `socket.AF_INET6` to restrict to IPv4 or IPv6 addresses, otherwise both
+        will be used if available.
 
-        The ``backlog`` argument has the same meaning as for
-        `socket.listen <socket.socket.listen>`. The ``reuse_port`` argument
-        has the same meaning as for `.bind_sockets`.
+        The ``backlog`` argument has the same meaning as for `socket.listen
+        <socket.socket.listen>`. The ``reuse_port`` argument has the same
+        meaning as for `.bind_sockets`.
 
-        This method may be called multiple times prior to `start` to listen
-        on multiple ports or interfaces.
+        This method may be called multiple times prior to `start` to listen on
+        multiple ports or interfaces.
 
         .. versionchanged:: 4.4
            Added the ``reuse_port`` argument.
+
+        .. versionchanged:: 6.2
+           Added the ``flags`` argument to match `.bind_sockets`.
+
+        .. deprecated:: 6.2
+           Use either ``listen()`` or ``add_sockets()`` instead of ``bind()``
+           and ``start()``.
         """
         sockets = bind_sockets(
-            port, address=address, family=family, backlog=backlog, reuse_port=reuse_port
+            port,

_service:tar_scm:tornado-6.1.tar.gz/tornado/template.py -> _service:tar_scm:tornado-6.3.2.tar.gz/tornado/template.py Changed

_service:tar_scm:tornado-6.3.2.tar.gz/tornado/test/__init__.py Added

_service:tar_scm:tornado-6.1.tar.gz/tornado/test/asyncio_test.py -> _service:tar_scm:tornado-6.3.2.tar.gz/tornado/test/asyncio_test.py Changed

@@ -12,6 +12,7 @@
 
 import asyncio
 import unittest
+import warnings
 
 from concurrent.futures import ThreadPoolExecutor
 from tornado import gen
@@ -25,13 +26,16 @@
 
 
 class AsyncIOLoopTest(AsyncTestCase):
-    def get_new_ioloop(self):
-        io_loop = AsyncIOLoop()
-        return io_loop
+    @property
+    def asyncio_loop(self):
+        return self.io_loop.asyncio_loop  # type: ignore
 
     def test_asyncio_callback(self):
         # Basic test that the asyncio loop is set up correctly.
-        asyncio.get_event_loop().call_soon(self.stop)
+        async def add_callback():
+            asyncio.get_event_loop().call_soon(self.stop)
+
+        self.asyncio_loop.run_until_complete(add_callback())
         self.wait()
 
     @gen_test
@@ -89,21 +93,15 @@
         # Asyncio only supports coroutines that yield asyncio-compatible
         # Futures (which our Future is since 5.0).
         self.assertEqual(
-            asyncio.get_event_loop().run_until_complete(
-                native_coroutine_without_adapter()
-            ),
+            self.asyncio_loop.run_until_complete(native_coroutine_without_adapter()),
             42,
         )
         self.assertEqual(
-            asyncio.get_event_loop().run_until_complete(
-                native_coroutine_with_adapter()
-            ),
+            self.asyncio_loop.run_until_complete(native_coroutine_with_adapter()),
             42,
         )
         self.assertEqual(
-            asyncio.get_event_loop().run_until_complete(
-                native_coroutine_with_adapter2()
-            ),
+            self.asyncio_loop.run_until_complete(native_coroutine_with_adapter2()),
             42,
         )
 
@@ -111,22 +109,30 @@
 class LeakTest(unittest.TestCase):
     def setUp(self):
         # Trigger a cleanup of the mapping so we start with a clean slate.
-        AsyncIOLoop().close()
+        AsyncIOLoop(make_current=False).close()
         # If we don't clean up after ourselves other tests may fail on
         # py34.
         self.orig_policy = asyncio.get_event_loop_policy()
         asyncio.set_event_loop_policy(asyncio.DefaultEventLoopPolicy())
 
     def tearDown(self):
-        asyncio.get_event_loop().close()
+        try:
+            loop = asyncio.get_event_loop_policy().get_event_loop()
+        except Exception:
+            # We may not have a current event loop at this point.
+            pass
+        else:
+            loop.close()
         asyncio.set_event_loop_policy(self.orig_policy)
 
     def test_ioloop_close_leak(self):
         orig_count = len(IOLoop._ioloop_for_asyncio)
         for i in range(10):
             # Create and close an AsyncIOLoop using Tornado interfaces.
-            loop = AsyncIOLoop()
-            loop.close()
+            with warnings.catch_warnings():
+                warnings.simplefilter("ignore", DeprecationWarning)
+                loop = AsyncIOLoop()
+                loop.close()
         new_count = len(IOLoop._ioloop_for_asyncio) - orig_count
         self.assertEqual(new_count, 0)
 
@@ -170,21 +176,34 @@
         future = self.executor.submit(get_and_close_event_loop)
         return future.result()
 
-    def run_policy_test(self, accessor, expected_type):
-        # With the default policy, non-main threads don't get an event
-        # loop.
-        self.assertRaises(
-            (RuntimeError, AssertionError), self.executor.submit(accessor).result
-        )
-        # Set the policy and we can get a loop.
-        asyncio.set_event_loop_policy(AnyThreadEventLoopPolicy())
-        self.assertIsInstance(self.executor.submit(accessor).result(), expected_type)
-        # Clean up to silence leak warnings. Always use asyncio since
-        # IOLoop doesn't (currently) close the underlying loop.
-        self.executor.submit(lambda: asyncio.get_event_loop().close()).result()  # type: ignore
-
     def test_asyncio_accessor(self):
-        self.run_policy_test(asyncio.get_event_loop, asyncio.AbstractEventLoop)
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore", DeprecationWarning)
+            # With the default policy, non-main threads don't get an event
+            # loop.
+            self.assertRaises(
+                RuntimeError, self.executor.submit(asyncio.get_event_loop).result
+            )
+            # Set the policy and we can get a loop.
+            asyncio.set_event_loop_policy(AnyThreadEventLoopPolicy())
+            self.assertIsInstance(
+                self.executor.submit(asyncio.get_event_loop).result(),
+                asyncio.AbstractEventLoop,
+            )
+            # Clean up to silence leak warnings. Always use asyncio since
+            # IOLoop doesn't (currently) close the underlying loop.
+            self.executor.submit(lambda: asyncio.get_event_loop().close()).result()  # type: ignore
 
     def test_tornado_accessor(self):
-        self.run_policy_test(IOLoop.current, IOLoop)
+        # Tornado's IOLoop.current() API can create a loop for any thread,
+        # regardless of this event loop policy.
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore", DeprecationWarning)
+            self.assertIsInstance(self.executor.submit(IOLoop.current).result(), IOLoop)
+            # Clean up to silence leak warnings. Always use asyncio since
+            # IOLoop doesn't (currently) close the underlying loop.
+            self.executor.submit(lambda: asyncio.get_event_loop().close()).result()  # type: ignore
+
+            asyncio.set_event_loop_policy(AnyThreadEventLoopPolicy())
+            self.assertIsInstance(self.executor.submit(IOLoop.current).result(), IOLoop)
+            self.executor.submit(lambda: asyncio.get_event_loop().close()).result()  # type: ignore

_service:tar_scm:tornado-6.1.tar.gz/tornado/test/auth_test.py -> _service:tar_scm:tornado-6.3.2.tar.gz/tornado/test/auth_test.py Changed

@@ -502,14 +502,14 @@
         self.assertEqual(
             parsed,
             {
-                u"access_token": {
-                    u"key": u"hjkl",
-                    u"screen_name": u"foo",
-                    u"secret": u"vbnm",
+                "access_token": {
+                    "key": "hjkl",
+                    "screen_name": "foo",
+                    "secret": "vbnm",
                 },
-                u"name": u"Foo",
-                u"screen_name": u"foo",
-                u"username": u"foo",
+                "name": "Foo",
+                "screen_name": "foo",
+                "username": "foo",
             },
         )
 
@@ -601,9 +601,9 @@
         response = self.fetch("/client/login")
         self.assertDictEqual(
             {
-                u"name": u"Foo",
-                u"email": u"foo@example.com",
-                u"access_token": u"fake-access-token",
+                "name": "Foo",
+                "email": "foo@example.com",
+                "access_token": "fake-access-token",
             },
             json_decode(response.body),
         )

_service:tar_scm:tornado-6.1.tar.gz/tornado/test/concurrent_test.py -> _service:tar_scm:tornado-6.3.2.tar.gz/tornado/test/concurrent_test.py Changed

_service:tar_scm:tornado-6.1.tar.gz/tornado/test/escape_test.py -> _service:tar_scm:tornado-6.3.2.tar.gz/tornado/test/escape_test.py Changed

@@ -1,6 +1,6 @@
 import unittest
 
-import tornado.escape
+import tornado
 from tornado.escape import (
     utf8,
     xhtml_escape,
@@ -22,174 +22,174 @@
     (
         "hello http://world.com/!",
         {},
-        u'hello <a href="http://world.com/">http://world.com/</a>!',
+        'hello <a href="http://world.com/">http://world.com/</a>!',
     ),
     (
         "hello http://world.com/with?param=true&stuff=yes",
         {},
-        u'hello <a href="http://world.com/with?param=true&amp;stuff=yes">http://world.com/with?param=true&amp;stuff=yes</a>',  # noqa: E501
+        'hello <a href="http://world.com/with?param=true&amp;stuff=yes">http://world.com/with?param=true&amp;stuff=yes</a>',  # noqa: E501
     ),
     # an opened paren followed by many chars killed Gruber's regex
     (
         "http://url.com/w(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
         {},
-        u'<a href="http://url.com/w">http://url.com/w</a>(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',  # noqa: E501
+        '<a href="http://url.com/w">http://url.com/w</a>(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',  # noqa: E501
     ),
     # as did too many dots at the end
     (
         "http://url.com/withmany.......................................",
         {},
-        u'<a href="http://url.com/withmany">http://url.com/withmany</a>.......................................',  # noqa: E501
+        '<a href="http://url.com/withmany">http://url.com/withmany</a>.......................................',  # noqa: E501
     ),
     (
         "http://url.com/withmany((((((((((((((((((((((((((((((((((a)",
         {},
-        u'<a href="http://url.com/withmany">http://url.com/withmany</a>((((((((((((((((((((((((((((((((((a)',  # noqa: E501
+        '<a href="http://url.com/withmany">http://url.com/withmany</a>((((((((((((((((((((((((((((((((((a)',  # noqa: E501
     ),
     # some examples from http://daringfireball.net/2009/11/liberal_regex_for_matching_urls
     # plus a fex extras (such as multiple parentheses).
     (
         "http://foo.com/blah_blah",
         {},
-        u'<a href="http://foo.com/blah_blah">http://foo.com/blah_blah</a>',
+        '<a href="http://foo.com/blah_blah">http://foo.com/blah_blah</a>',
     ),
     (
         "http://foo.com/blah_blah/",
         {},
-        u'<a href="http://foo.com/blah_blah/">http://foo.com/blah_blah/</a>',
+        '<a href="http://foo.com/blah_blah/">http://foo.com/blah_blah/</a>',
     ),
     (
         "(Something like http://foo.com/blah_blah)",
         {},
-        u'(Something like <a href="http://foo.com/blah_blah">http://foo.com/blah_blah</a>)',
+        '(Something like <a href="http://foo.com/blah_blah">http://foo.com/blah_blah</a>)',
     ),
     (
         "http://foo.com/blah_blah_(wikipedia)",
         {},
-        u'<a href="http://foo.com/blah_blah_(wikipedia)">http://foo.com/blah_blah_(wikipedia)</a>',
+        '<a href="http://foo.com/blah_blah_(wikipedia)">http://foo.com/blah_blah_(wikipedia)</a>',
     ),
     (
         "http://foo.com/blah_(blah)_(wikipedia)_blah",
         {},
-        u'<a href="http://foo.com/blah_(blah)_(wikipedia)_blah">http://foo.com/blah_(blah)_(wikipedia)_blah</a>',  # noqa: E501
+        '<a href="http://foo.com/blah_(blah)_(wikipedia)_blah">http://foo.com/blah_(blah)_(wikipedia)_blah</a>',  # noqa: E501
     ),
     (
         "(Something like http://foo.com/blah_blah_(wikipedia))",
         {},
-        u'(Something like <a href="http://foo.com/blah_blah_(wikipedia)">http://foo.com/blah_blah_(wikipedia)</a>)',  # noqa: E501
+        '(Something like <a href="http://foo.com/blah_blah_(wikipedia)">http://foo.com/blah_blah_(wikipedia)</a>)',  # noqa: E501
     ),
     (
         "http://foo.com/blah_blah.",
         {},
-        u'<a href="http://foo.com/blah_blah">http://foo.com/blah_blah</a>.',
+        '<a href="http://foo.com/blah_blah">http://foo.com/blah_blah</a>.',
     ),
     (
         "http://foo.com/blah_blah/.",
         {},
-        u'<a href="http://foo.com/blah_blah/">http://foo.com/blah_blah/</a>.',
+        '<a href="http://foo.com/blah_blah/">http://foo.com/blah_blah/</a>.',
     ),
     (
         "<http://foo.com/blah_blah>",
         {},
-        u'&lt;<a href="http://foo.com/blah_blah">http://foo.com/blah_blah</a>&gt;',
+        '&lt;<a href="http://foo.com/blah_blah">http://foo.com/blah_blah</a>&gt;',
     ),
     (
         "<http://foo.com/blah_blah/>",
         {},
-        u'&lt;<a href="http://foo.com/blah_blah/">http://foo.com/blah_blah/</a>&gt;',
+        '&lt;<a href="http://foo.com/blah_blah/">http://foo.com/blah_blah/</a>&gt;',
     ),
     (
         "http://foo.com/blah_blah,",
         {},
-        u'<a href="http://foo.com/blah_blah">http://foo.com/blah_blah</a>,',
+        '<a href="http://foo.com/blah_blah">http://foo.com/blah_blah</a>,',
     ),
     (
         "http://www.example.com/wpstyle/?p=364.",
         {},
-        u'<a href="http://www.example.com/wpstyle/?p=364">http://www.example.com/wpstyle/?p=364</a>.',  # noqa: E501
+        '<a href="http://www.example.com/wpstyle/?p=364">http://www.example.com/wpstyle/?p=364</a>.',  # noqa: E501
     ),
     (
         "rdar://1234",
         {"permitted_protocols": "http", "rdar"},
-        u'<a href="rdar://1234">rdar://1234</a>',
+        '<a href="rdar://1234">rdar://1234</a>',
     ),
     (
         "rdar:/1234",
         {"permitted_protocols": "rdar"},
-        u'<a href="rdar:/1234">rdar:/1234</a>',
+        '<a href="rdar:/1234">rdar:/1234</a>',
     ),
     (
         "http://userid:password@example.com:8080",
         {},
-        u'<a href="http://userid:password@example.com:8080">http://userid:password@example.com:8080</a>',  # noqa: E501
+        '<a href="http://userid:password@example.com:8080">http://userid:password@example.com:8080</a>',  # noqa: E501
     ),
     (
         "http://userid@example.com",
         {},
-        u'<a href="http://userid@example.com">http://userid@example.com</a>',
+        '<a href="http://userid@example.com">http://userid@example.com</a>',
     ),
     (
         "http://userid@example.com:8080",
         {},
-        u'<a href="http://userid@example.com:8080">http://userid@example.com:8080</a>',
+        '<a href="http://userid@example.com:8080">http://userid@example.com:8080</a>',
     ),
     (
         "http://userid:password@example.com",
         {},
-        u'<a href="http://userid:password@example.com">http://userid:password@example.com</a>',
+        '<a href="http://userid:password@example.com">http://userid:password@example.com</a>',
     ),
     (
         "message://%3c330e7f8409726r6a4ba78dkf1fd71420c1bf6ff@mail.gmail.com%3e",
         {"permitted_protocols": "http", "message"},
-        u'<a href="message://%3c330e7f8409726r6a4ba78dkf1fd71420c1bf6ff@mail.gmail.com%3e">'
-        u"message://%3c330e7f8409726r6a4ba78dkf1fd71420c1bf6ff@mail.gmail.com%3e</a>",
+        '<a href="message://%3c330e7f8409726r6a4ba78dkf1fd71420c1bf6ff@mail.gmail.com%3e">'
+        "message://%3c330e7f8409726r6a4ba78dkf1fd71420c1bf6ff@mail.gmail.com%3e</a>",
     ),
     (
-        u"http://\u27a1.ws/\u4a39",
+        "http://\u27a1.ws/\u4a39",
         {},
-        u'<a href="http://\u27a1.ws/\u4a39">http://\u27a1.ws/\u4a39</a>',
+        '<a href="http://\u27a1.ws/\u4a39">http://\u27a1.ws/\u4a39</a>',
     ),
     (
         "<tag>http://example.com</tag>",
         {},
-        u'&lt;tag&gt;<a href="http://example.com">http://example.com</a>&lt;/tag&gt;',
+        '&lt;tag&gt;<a href="http://example.com">http://example.com</a>&lt;/tag&gt;',
     ),
     (
         "Just a www.example.com link.",
         {},
-        u'Just a <a href="http://www.example.com">www.example.com</a> link.',
+        'Just a <a href="http://www.example.com">www.example.com</a> link.',
     ),
     (
         "Just a www.example.com link.",
         {"require_protocol": True},
-        u"Just a www.example.com link.",
+        "Just a www.example.com link.",
     ),
     (
         "A http://reallylong.com/link/that/exceedsthelenglimit.html",
         {"require_protocol": True, "shorten": True},
-        u'A <a href="http://reallylong.com/link/that/exceedsthelenglimit.html"'
-        u' title="http://reallylong.com/link/that/exceedsthelenglimit.html">http://reallylong.com/link...</a>',  # noqa: E501
+        'A <a href="http://reallylong.com/link/that/exceedsthelenglimit.html"'
+        ' title="http://reallylong.com/link/that/exceedsthelenglimit.html">http://reallylong.com/link...</a>',  # noqa: E501
     ),
     (
         "A http://reallylongdomainnamethatwillbetoolong.com/hi!",
         {"shorten": True},
-        u'A <a href="http://reallylongdomainnamethatwillbetoolong.com/hi"'
-        u' title="http://reallylongdomainnamethatwillbetoolong.com/hi">http://reallylongdomainnametha...</a>!',  # noqa: E501
+        'A <a href="http://reallylongdomainnamethatwillbetoolong.com/hi"'
+        ' title="http://reallylongdomainnamethatwillbetoolong.com/hi">http://reallylongdomainnametha...</a>!',  # noqa: E501
     ),

_service:tar_scm:tornado-6.1.tar.gz/tornado/test/gen_test.py -> _service:tar_scm:tornado-6.3.2.tar.gz/tornado/test/gen_test.py Changed

_service:tar_scm:tornado-6.1.tar.gz/tornado/test/http1connection_test.py -> _service:tar_scm:tornado-6.3.2.tar.gz/tornado/test/http1connection_test.py Changed

_service:tar_scm:tornado-6.1.tar.gz/tornado/test/httpclient_test.py -> _service:tar_scm:tornado-6.3.2.tar.gz/tornado/test/httpclient_test.py Changed

@@ -139,18 +139,23 @@
 
 
 class InvalidGzipHandler(RequestHandler):
-    def get(self):
+    def get(self) -> None:
         # set Content-Encoding manually to avoid automatic gzip encoding
         self.set_header("Content-Type", "text/plain")
         self.set_header("Content-Encoding", "gzip")
         # Triggering the potential bug seems to depend on input length.
         # This length is taken from the bad-response example reported in
         # https://github.com/tornadoweb/tornado/pull/2875 (uncompressed).
-        body = "".join("Hello World {}\n".format(i) for i in range(9000)):149051
-        body = gzip.compress(body.encode(), compresslevel=6) + b"\00"
+        text = "".join("Hello World {}\n".format(i) for i in range(9000)):149051
+        body = gzip.compress(text.encode(), compresslevel=6) + b"\00"
         self.write(body)
 
 
+class HeaderEncodingHandler(RequestHandler):
+    def get(self):
+        self.finish(self.request.headers"Foo".encode("ISO8859-1"))
+
+
 # These tests end up getting run redundantly: once here with the default
 # HTTPClient implementation, and then again in each implementation's own
 # test suite.
@@ -175,6 +180,7 @@
                 url("/patch", PatchHandler),
                 url("/set_header", SetHeaderHandler),
                 url("/invalid_gzip", InvalidGzipHandler),
+                url("/header-encoding", HeaderEncodingHandler),
             ,
             gzip=True,
         )
@@ -285,7 +291,7 @@
 
         # The standard mandates NFC. Give it a decomposed username
         # and ensure it is normalized to composed form.
-        username = unicodedata.normalize("NFD", u"josé")
+        username = unicodedata.normalize("NFD", "josé")
         self.assertEqual(
             self.fetch("/auth", auth_username=username, auth_password="səcrət").body,
             b"Basic am9zw6k6c8mZY3LJmXQ=",
@@ -374,7 +380,7 @@
         self.assertEqual(b"Basic " + base64.b64encode(b"me:secret"), response.body)
 
     def test_body_encoding(self):
-        unicode_body = u"\xe9"
+        unicode_body = "\xe9"
         byte_body = binascii.a2b_hex(b"e9")
 
         # unicode string in body gets converted to utf8
@@ -404,7 +410,7 @@
             method="POST",
             body=byte_body,
             headers={"Content-Type": "application/blah"},
-            user_agent=u"foo",
+            user_agent="foo",
         )
         self.assertEqual(response.headers"Content-Length", "1")
         self.assertEqual(response.body, byte_body)
@@ -474,7 +480,7 @@
             streaming_callback=streaming_callback,
         )
         self.assertEqual(len(first_line), 1, first_line)
-        self.assertRegexpMatches(first_line0, "HTTP/0-9\\.0-9 200.*\r\n")
+        self.assertRegex(first_line0, "HTTP/0-9\\.0-9 200.*\r\n")
         self.assertEqual(chunks, b"asdf", b"qwer")
 
     @gen_test
@@ -493,7 +499,7 @@
         # in a plain dictionary or an HTTPHeaders object.
         # Keys must always be the native str type.
         # All combinations should have the same results on the wire.
-        for value in u"MyUserAgent", b"MyUserAgent":
+        for value in "MyUserAgent", b"MyUserAgent":
             for container in dict, HTTPHeaders:
                 headers = container()
                 headers"User-Agent" = value
@@ -537,6 +543,16 @@
             finally:
                 self.io_loop.remove_handler(sock.fileno())
 
+    @gen_test
+    def test_header_encoding(self):
+        response = yield self.http_client.fetch(
+            self.get_url("/header-encoding"),
+            headers={
+                "Foo": "b\xe4r",
+            },
+        )
+        self.assertEqual(response.body, "b\xe4r".encode("ISO8859-1"))
+
     def test_304_with_content_length(self):
         # According to the spec 304 responses SHOULD NOT include
         # Content-Length or other entity headers, but some servers do it
@@ -665,7 +681,7 @@
         # Non-ascii headers are sent as latin1.
         response = self.fetch("/set_header?k=foo&v=%E9")
         response.rethrow()
-        self.assertEqual(response.headers"Foo", native_str(u"\u00e9"))
+        self.assertEqual(response.headers"Foo", native_str("\u00e9"))
 
     def test_response_times(self):
         # A few simple sanity checks of the response time fields to
@@ -674,6 +690,7 @@
         start_time = time.time()
         response = self.fetch("/hello")
         response.rethrow()
+        assert response.request_time is not None
         self.assertGreaterEqual(response.request_time, 0)
         self.assertLess(response.request_time, 1.0)
         # A very crude check to make sure that start_time is based on
@@ -754,7 +771,7 @@
 
 class SyncHTTPClientTest(unittest.TestCase):
     def setUp(self):
-        self.server_ioloop = IOLoop()
+        self.server_ioloop = IOLoop(make_current=False)
         event = threading.Event()
 
         @gen.coroutine

_service:tar_scm:tornado-6.1.tar.gz/tornado/test/httpserver_test.py -> _service:tar_scm:tornado-6.3.2.tar.gz/tornado/test/httpserver_test.py Changed

@@ -181,7 +181,9 @@
 
 class SSLContextTest(BaseSSLTest, SSLTestMixin):
     def get_ssl_options(self):
-        context = ssl_options_to_context(AsyncHTTPSTestCase.get_ssl_options(self))
+        context = ssl_options_to_context(
+            AsyncHTTPSTestCase.get_ssl_options(self), server_side=True
+        )
         assert isinstance(context, ssl.SSLContext)
         return context
 
@@ -279,23 +281,23 @@
                 
                     b"Content-Disposition: form-data; name=argument",
                     b"",
-                    u"\u00e1".encode("utf-8"),
+                    "\u00e1".encode("utf-8"),
                     b"--1234567890",
-                    u'Content-Disposition: form-data; name="files"; filename="\u00f3"'.encode(
+                    'Content-Disposition: form-data; name="files"; filename="\u00f3"'.encode(
                         "utf8"
                     ),
                     b"",
-                    u"\u00fa".encode("utf-8"),
+                    "\u00fa".encode("utf-8"),
                     b"--1234567890--",
                     b"",
                 
             ),
         )
         data = json_decode(response)
-        self.assertEqual(u"\u00e9", data"header")
-        self.assertEqual(u"\u00e1", data"argument")
-        self.assertEqual(u"\u00f3", data"filename")
-        self.assertEqual(u"\u00fa", data"filebody")
+        self.assertEqual("\u00e9", data"header")
+        self.assertEqual("\u00e1", data"argument")
+        self.assertEqual("\u00f3", data"filename")
+        self.assertEqual("\u00fa", data"filebody")
 
     def test_newlines(self):
         # We support both CRLF and bare LF as line separators.
@@ -410,17 +412,17 @@
     def test_query_string_encoding(self):
         response = self.fetch("/echo?foo=%C3%A9")
         data = json_decode(response.body)
-        self.assertEqual(data, {u"foo": u"\u00e9"})
+        self.assertEqual(data, {"foo": "\u00e9"})
 
     def test_empty_query_string(self):
         response = self.fetch("/echo?foo=&foo=")
         data = json_decode(response.body)
-        self.assertEqual(data, {u"foo": u"", u""})
+        self.assertEqual(data, {"foo": "", ""})
 
     def test_empty_post_parameters(self):
         response = self.fetch("/echo", method="POST", body="foo=&bar=")
         data = json_decode(response.body)
-        self.assertEqual(data, {u"foo": u"", u"bar": u""})
+        self.assertEqual(data, {"foo": "", "bar": ""})
 
     def test_types(self):
         headers = {"Cookie": "foo=bar"}
@@ -530,7 +532,7 @@
         start_line, headers, response = self.io_loop.run_sync(
             lambda: read_stream_body(self.stream)
         )
-        self.assertEqual(json_decode(response), {u"foo": u"bar"})
+        self.assertEqual(json_decode(response), {"foo": "bar"})
 
     def test_chunked_request_uppercase(self):
         # As per RFC 2616 section 3.6, "Transfer-Encoding" header's value is
@@ -554,7 +556,7 @@
         start_line, headers, response = self.io_loop.run_sync(
             lambda: read_stream_body(self.stream)
         )
-        self.assertEqual(json_decode(response), {u"foo": u"bar"})
+        self.assertEqual(json_decode(response), {"foo": "bar"})
 
     @gen_test
     def test_invalid_content_length(self):
@@ -752,7 +754,7 @@
     def test_unix_socket_bad_request(self):
         # Unix sockets don't have remote addresses so they just return an
         # empty string.
-        with ExpectLog(gen_log, "Malformed HTTP message from"):
+        with ExpectLog(gen_log, "Malformed HTTP message from", level=logging.INFO):
             self.stream.write(b"garbage\r\n\r\n")
             response = yield self.stream.read_until_close()
         self.assertEqual(response, b"HTTP/1.1 400 Bad Request\r\n\r\n")
@@ -989,7 +991,7 @@
 
     def test_uncompressed(self):
         response = self.fetch("/", method="POST", body="foo=bar")
-        self.assertEqual(json_decode(response.body), {u"foo": u"bar"})
+        self.assertEqual(json_decode(response.body), {"foo": "bar"})
 
 
 class GzipTest(GzipBaseTest, AsyncHTTPTestCase):
@@ -998,7 +1000,22 @@
 
     def test_gzip(self):
         response = self.post_gzip("foo=bar")
-        self.assertEqual(json_decode(response.body), {u"foo": u"bar"})
+        self.assertEqual(json_decode(response.body), {"foo": "bar"})
+
+    def test_gzip_case_insensitive(self):
+        # https://datatracker.ietf.org/doc/html/rfc7231#section-3.1.2.1
+        bytesio = BytesIO()
+        gzip_file = gzip.GzipFile(mode="w", fileobj=bytesio)
+        gzip_file.write(utf8("foo=bar"))
+        gzip_file.close()
+        compressed_body = bytesio.getvalue()
+        response = self.fetch(
+            "/",
+            method="POST",
+            body=compressed_body,
+            headers={"Content-Encoding": "GZIP"},
+        )
+        self.assertEqual(json_decode(response.body), {"foo": "bar"})
 
 
 class GzipUnsupportedTest(GzipBaseTest, AsyncHTTPTestCase):

_service:tar_scm:tornado-6.1.tar.gz/tornado/test/httputil_test.py -> _service:tar_scm:tornado-6.3.2.tar.gz/tornado/test/httputil_test.py Changed

@@ -167,7 +167,7 @@
         args, files = form_data_args()
         parse_multipart_form_data(b"1234", data, args, files)
         file = files"files"0
-        self.assertEqual(file"filename", u"áb.txt")
+        self.assertEqual(file"filename", "áb.txt")
         self.assertEqual(file"body", b"Foo")
 
     def test_boundary_starts_and_ends_with_quotes(self):
@@ -301,13 +301,13 @@
         # and cpython's unicodeobject.c (which defines the implementation
         # of unicode_type.splitlines(), and uses a different list than TR13).
         newlines = 
-            u"\u001b",  # VERTICAL TAB
-            u"\u001c",  # FILE SEPARATOR
-            u"\u001d",  # GROUP SEPARATOR
-            u"\u001e",  # RECORD SEPARATOR
-            u"\u0085",  # NEXT LINE
-            u"\u2028",  # LINE SEPARATOR
-            u"\u2029",  # PARAGRAPH SEPARATOR
+            "\u001b",  # VERTICAL TAB
+            "\u001c",  # FILE SEPARATOR
+            "\u001d",  # GROUP SEPARATOR
+            "\u001e",  # RECORD SEPARATOR
+            "\u0085",  # NEXT LINE
+            "\u2028",  # LINE SEPARATOR
+            "\u2029",  # PARAGRAPH SEPARATOR
         
         for newline in newlines:
             # Try the utf8 and latin1 representations of each newline

_service:tar_scm:tornado-6.1.tar.gz/tornado/test/import_test.py -> _service:tar_scm:tornado-6.3.2.tar.gz/tornado/test/import_test.py Changed

@@ -11,38 +11,31 @@
 import asyncio
 asyncio.set_event_loop(None)
 
-import tornado.auth
-import tornado.autoreload
-import tornado.concurrent
-import tornado.escape
-import tornado.gen
-import tornado.http1connection
-import tornado.httpclient
-import tornado.httpserver
-import tornado.httputil
-import tornado.ioloop
-import tornado.iostream
-import tornado.locale
-import tornado.log
-import tornado.netutil
-import tornado.options
-import tornado.process
-import tornado.simple_httpclient
-import tornado.tcpserver
-import tornado.tcpclient
-import tornado.template
-import tornado.testing
-import tornado.util
-import tornado.web
-import tornado.websocket
-import tornado.wsgi
+import importlib
+import tornado
 
-try:
-    import pycurl
-except ImportError:
-    pass
-else:
-    import tornado.curl_httpclient
+for mod in tornado.__all__:
+    if mod == "curl_httpclient":
+        # This module has extra dependencies; skip it if they're not installed.
+        try:
+            import pycurl
+        except ImportError:
+            continue
+    importlib.import_module(f"tornado.{mod}")
+"""
+
+_import_lazy = b"""
+import sys
+import tornado
+
+if "tornado.web" in sys.modules:
+    raise Exception("unexpected eager import")
+
+# Trigger a lazy import by referring to something in a submodule.
+tornado.web.RequestHandler
+
+if "tornado.web" not in sys.modules:
+    raise Exception("lazy import did not update sys.modules")
 """
 
 
@@ -56,11 +49,17 @@
         proc.communicate(_import_everything)
         self.assertEqual(proc.returncode, 0)
 
+    def test_lazy_import(self):
+        # Test that submodules can be referenced lazily after "import tornado"
+        proc = subprocess.Popen(sys.executable, stdin=subprocess.PIPE)
+        proc.communicate(_import_lazy)
+        self.assertEqual(proc.returncode, 0)
+
     def test_import_aliases(self):
         # Ensure we don't delete formerly-documented aliases accidentally.
-        import tornado.ioloop
-        import tornado.gen
-        import tornado.util
+        import tornado
+        import asyncio
 
         self.assertIs(tornado.ioloop.TimeoutError, tornado.util.TimeoutError)
         self.assertIs(tornado.gen.TimeoutError, tornado.util.TimeoutError)
+        self.assertIs(tornado.util.TimeoutError, asyncio.TimeoutError)

_service:tar_scm:tornado-6.1.tar.gz/tornado/test/ioloop_test.py -> _service:tar_scm:tornado-6.3.2.tar.gz/tornado/test/ioloop_test.py Changed

@@ -1,5 +1,7 @@
+import asyncio
 from concurrent.futures import ThreadPoolExecutor
 from concurrent import futures
+from collections.abc import Generator
 import contextlib
 import datetime
 import functools
@@ -16,8 +18,19 @@
 from tornado import gen
 from tornado.ioloop import IOLoop, TimeoutError, PeriodicCallback
 from tornado.log import app_log
-from tornado.testing import AsyncTestCase, bind_unused_port, ExpectLog, gen_test
-from tornado.test.util import skipIfNonUnix, skipOnTravis
+from tornado.testing import (
+    AsyncTestCase,
+    bind_unused_port,
+    ExpectLog,
+    gen_test,
+    setup_with_context_manager,
+)
+from tornado.test.util import (
+    ignore_deprecation,
+    skipIfNonUnix,
+    skipOnTravis,
+)
+from tornado.concurrent import Future
 
 import typing
 
@@ -161,7 +174,7 @@
 
             self.io_loop.add_handler(client.fileno(), handler, IOLoop.READ)
             self.io_loop.add_timeout(
-                self.io_loop.time() + 0.01, functools.partial(server.send, b"asdf")  # type: ignore
+                self.io_loop.time() + 0.01, functools.partial(server.send, b"asdf")
             )
             self.wait()
             self.io_loop.remove_handler(client.fileno())
@@ -410,16 +423,26 @@
         # threads.
         def f():
             for i in range(10):
-                loop = IOLoop()
+                loop = IOLoop(make_current=False)
                 loop.close()
 
         yield gen.multi(self.io_loop.run_in_executor(None, f) for i in range(2))
 
+    def test_explicit_asyncio_loop(self):
+        asyncio_loop = asyncio.new_event_loop()
+        loop = IOLoop(asyncio_loop=asyncio_loop, make_current=False)
+        assert loop.asyncio_loop is asyncio_loop  # type: ignore
+        with self.assertRaises(RuntimeError):
+            # Can't register two IOLoops with the same asyncio_loop
+            IOLoop(asyncio_loop=asyncio_loop, make_current=False)
+        loop.close()
+
 
 # Deliberately not a subclass of AsyncTestCase so the IOLoop isn't
 # automatically set as current.
 class TestIOLoopCurrent(unittest.TestCase):
     def setUp(self):
+        setup_with_context_manager(self, ignore_deprecation())
         self.io_loop = None  # type: typing.OptionalIOLoop
         IOLoop.clear_current()
 
@@ -427,15 +450,6 @@
         if self.io_loop is not None:
             self.io_loop.close()
 
-    def test_default_current(self):
-        self.io_loop = IOLoop()
-        # The first IOLoop with default arguments is made current.
-        self.assertIs(self.io_loop, IOLoop.current())
-        # A second IOLoop can be created but is not made current.
-        io_loop2 = IOLoop()
-        self.assertIs(self.io_loop, IOLoop.current())
-        io_loop2.close()
-
     def test_non_current(self):
         self.io_loop = IOLoop(make_current=False)
         # The new IOLoop is not initially made current.
@@ -458,14 +472,13 @@
     def test_force_current(self):
         self.io_loop = IOLoop(make_current=True)
         self.assertIs(self.io_loop, IOLoop.current())
-        with self.assertRaises(RuntimeError):
-            # A second make_current=True construction cannot succeed.
-            IOLoop(make_current=True)
-        # current() was not affected by the failed construction.
-        self.assertIs(self.io_loop, IOLoop.current())
 
 
 class TestIOLoopCurrentAsync(AsyncTestCase):
+    def setUp(self):
+        super().setUp()
+        setup_with_context_manager(self, ignore_deprecation())
+
     @gen_test
     def test_clear_without_current(self):
         # If there is no current IOLoop, clear_current is a no-op (but
@@ -557,7 +570,7 @@
 
 class TestIOLoopRunSync(unittest.TestCase):
     def setUp(self):
-        self.io_loop = IOLoop()
+        self.io_loop = IOLoop(make_current=False)
 
     def tearDown(self):
         self.io_loop.close()
@@ -688,6 +701,63 @@
         with mock.patch("random.random", mock_random):
             self.assertEqual(self.simulate_calls(pc, call_durations), expected)
 
+    def test_timedelta(self):
+        pc = PeriodicCallback(lambda: None, datetime.timedelta(minutes=1, seconds=23))
+        expected_callback_time = 83000
+        self.assertEqual(pc.callback_time, expected_callback_time)
+
+
+class TestPeriodicCallbackAsync(AsyncTestCase):
+    def test_periodic_plain(self):
+        count = 0
+
+        def callback() -> None:
+            nonlocal count
+            count += 1
+            if count == 3:
+                self.stop()
+
+        pc = PeriodicCallback(callback, 10)
+        pc.start()
+        self.wait()
+        pc.stop()
+        self.assertEqual(count, 3)
+
+    def test_periodic_coro(self) -> None:
+        counts = 0, 0
+
+        @gen.coroutine
+        def callback() -> "GeneratorFutureNone, object, None":
+            counts0 += 1
+            yield gen.sleep(0.025)
+            counts1 += 1
+            if counts1 == 3:
+                pc.stop()
+                self.io_loop.add_callback(self.stop)
+
+        pc = PeriodicCallback(callback, 10)
+        pc.start()
+        self.wait()
+        self.assertEqual(counts0, 3)
+        self.assertEqual(counts1, 3)
+
+    def test_periodic_async(self) -> None:
+        counts = 0, 0
+
+        async def callback() -> None:
+            counts0 += 1
+            await gen.sleep(0.025)
+            counts1 += 1
+            if counts1 == 3:
+                pc.stop()
+                self.io_loop.add_callback(self.stop)
+
+        pc = PeriodicCallback(callback, 10)
+        pc.start()
+        self.wait()
+        self.assertEqual(counts0, 3)
+        self.assertEqual(counts1, 3)
+
 
 class TestIOLoopConfiguration(unittest.TestCase):
     def run_python(self, *statements):

_service:tar_scm:tornado-6.1.tar.gz/tornado/test/iostream_test.py -> _service:tar_scm:tornado-6.3.2.tar.gz/tornado/test/iostream_test.py Changed

@@ -12,7 +12,7 @@
 from tornado.httputil import HTTPHeaders
 from tornado.locks import Condition, Event
 from tornado.log import gen_log
-from tornado.netutil import ssl_wrap_socket
+from tornado.netutil import ssl_options_to_context, ssl_wrap_socket
 from tornado.platform.asyncio import AddThreadSelectorEventLoop
 from tornado.tcpserver import TCPServer
 from tornado.testing import (
@@ -23,7 +23,12 @@
     ExpectLog,
     gen_test,
 )
-from tornado.test.util import skipIfNonUnix, refusing_port, skipPypy3V58
+from tornado.test.util import (
+    skipIfNonUnix,
+    refusing_port,
+    skipPypy3V58,
+    ignore_deprecation,
+)
 from tornado.web import RequestHandler, Application
 import asyncio
 import errno
@@ -784,7 +789,7 @@
                 "tornado.iostream.BaseIOStream._try_inline_read",
                 side_effect=IOError("boom"),
             ):
-                with self.assertRaisesRegexp(IOError, "boom"):
+                with self.assertRaisesRegex(IOError, "boom"):
                     client.read_until_close()
         finally:
             server.close()
@@ -811,7 +816,10 @@
         # windows, making this check redundant with skipIfNonUnix, but
         # we sometimes enable it on other platforms for testing.
         io_loop = IOLoop.current()
-        if isinstance(io_loop.selector_loop, AddThreadSelectorEventLoop):
+        if isinstance(
+            io_loop.selector_loop,  # type: ignoreattr-defined
+            AddThreadSelectorEventLoop,
+        ):
             self.skipTest("AddThreadSelectorEventLoop not supported")
         server, client = yield self.make_iostream_pair()
         try:
@@ -900,11 +908,11 @@
 
 class TestIOStreamSSL(TestIOStreamMixin, AsyncTestCase):
     def _make_server_iostream(self, connection, **kwargs):
-        connection = ssl.wrap_socket(
+        ssl_ctx = ssl_options_to_context(_server_ssl_options(), server_side=True)
+        connection = ssl_ctx.wrap_socket(
             connection,
             server_side=True,
             do_handshake_on_connect=False,
-            **_server_ssl_options()
         )
         return SSLIOStream(connection, **kwargs)
 
@@ -919,7 +927,7 @@
 # instead of an ssl_options dict to the SSLIOStream constructor.
 class TestIOStreamSSLContext(TestIOStreamMixin, AsyncTestCase):
     def _make_server_iostream(self, connection, **kwargs):
-        context = ssl.SSLContext(ssl.PROTOCOL_SSLv23)
+        context = ssl.create_default_context(ssl.Purpose.CLIENT_AUTH)
         context.load_cert_chain(
             os.path.join(os.path.dirname(__file__), "test.crt"),
             os.path.join(os.path.dirname(__file__), "test.key"),
@@ -930,7 +938,9 @@
         return SSLIOStream(connection, **kwargs)
 
     def _make_client_iostream(self, connection, **kwargs):
-        context = ssl.SSLContext(ssl.PROTOCOL_SSLv23)
+        context = ssl.create_default_context(ssl.Purpose.SERVER_AUTH)
+        context.check_hostname = False
+        context.verify_mode = ssl.CERT_NONE
         return SSLIOStream(connection, ssl_options=context, **kwargs)
 
 
@@ -1047,6 +1057,17 @@
                 # The server fails to connect, but the exact error is unspecified.
                 yield server_future
 
+    @gen_test
+    def test_typed_memoryview(self):
+        # Test support of memoryviews with an item size greater than 1 byte.
+        buf = memoryview(bytes(80)).cast("L")
+        assert self.server_stream is not None
+        yield self.server_stream.write(buf)
+        assert self.client_stream is not None
+        # This will timeout if the calculation of the buffer size is incorrect
+        recv = yield self.client_stream.read_bytes(buf.nbytes)
+        self.assertEqual(bytes(recv), bytes(buf))
+
 
 class WaitForHandshakeTest(AsyncTestCase):
     @gen.coroutine
@@ -1065,8 +1086,11 @@
             # to openssl 1.1.c. Other platforms might be affected with
             # newer openssl too). Disable it until we figure out
             # what's up.
-            ssl_ctx.options |= getattr(ssl, "OP_NO_TLSv1_3", 0)
-            client = SSLIOStream(socket.socket(), ssl_options=ssl_ctx)
+            # Update 2021-12-28: Still happening with Python 3.10 on
+            # Windows. OP_NO_TLSv1_3 now raises a DeprecationWarning.
+            with ignore_deprecation():
+                ssl_ctx.options |= getattr(ssl, "OP_NO_TLSv1_3", 0)
+                client = SSLIOStream(socket.socket(), ssl_options=ssl_ctx)
             yield client.connect(("127.0.0.1", port))
             self.assertIsNotNone(client.socket.cipher())
         finally:

_service:tar_scm:tornado-6.1.tar.gz/tornado/test/locale_test.py -> _service:tar_scm:tornado-6.3.2.tar.gz/tornado/test/locale_test.py Changed

@@ -33,7 +33,7 @@
         )
         locale = tornado.locale.get("fr_FR")
         self.assertTrue(isinstance(locale, tornado.locale.CSVLocale))
-        self.assertEqual(locale.translate("school"), u"\u00e9cole")
+        self.assertEqual(locale.translate("school"), "\u00e9cole")
 
     def test_csv_bom(self):
         with open(
@@ -53,7 +53,7 @@
                 tornado.locale.load_translations(tmpdir)
                 locale = tornado.locale.get("fr_FR")
                 self.assertIsInstance(locale, tornado.locale.CSVLocale)
-                self.assertEqual(locale.translate("school"), u"\u00e9cole")
+                self.assertEqual(locale.translate("school"), "\u00e9cole")
             finally:
                 shutil.rmtree(tmpdir)
 
@@ -64,24 +64,22 @@
         )
         locale = tornado.locale.get("fr_FR")
         self.assertTrue(isinstance(locale, tornado.locale.GettextLocale))
-        self.assertEqual(locale.translate("school"), u"\u00e9cole")
-        self.assertEqual(locale.pgettext("law", "right"), u"le droit")
-        self.assertEqual(locale.pgettext("good", "right"), u"le bien")
+        self.assertEqual(locale.translate("school"), "\u00e9cole")
+        self.assertEqual(locale.pgettext("law", "right"), "le droit")
+        self.assertEqual(locale.pgettext("good", "right"), "le bien")
+        self.assertEqual(locale.pgettext("organization", "club", "clubs", 1), "le club")
         self.assertEqual(
-            locale.pgettext("organization", "club", "clubs", 1), u"le club"
+            locale.pgettext("organization", "club", "clubs", 2), "les clubs"
         )
-        self.assertEqual(
-            locale.pgettext("organization", "club", "clubs", 2), u"les clubs"
-        )
-        self.assertEqual(locale.pgettext("stick", "club", "clubs", 1), u"le b\xe2ton")
-        self.assertEqual(locale.pgettext("stick", "club", "clubs", 2), u"les b\xe2tons")
+        self.assertEqual(locale.pgettext("stick", "club", "clubs", 1), "le b\xe2ton")
+        self.assertEqual(locale.pgettext("stick", "club", "clubs", 2), "les b\xe2tons")
 
 
 class LocaleDataTest(unittest.TestCase):
     def test_non_ascii_name(self):
         name = tornado.locale.LOCALE_NAMES"es_LA""name"
         self.assertTrue(isinstance(name, unicode_type))
-        self.assertEqual(name, u"Espa\u00f1ol")
+        self.assertEqual(name, "Espa\u00f1ol")
         self.assertEqual(utf8(name), b"Espa\xc3\xb1ol")

_service:tar_scm:tornado-6.1.tar.gz/tornado/test/log_test.py -> _service:tar_scm:tornado-6.3.2.tar.gz/tornado/test/log_test.py Changed

@@ -49,8 +49,8 @@
         # variable when the tests are run, so just patch in some values
         # for testing.  (testing with color off fails to expose some potential
         # encoding issues from the control characters)
-        self.formatter._colors = {logging.ERROR: u"\u0001"}
-        self.formatter._normal = u"\u0002"
+        self.formatter._colors = {logging.ERROR: "\u0001"}
+        self.formatter._normal = "\u0002"
         # construct a Logger directly to bypass getLogger's caching
         self.logger = logging.Logger("LogFormatterTest")
         self.logger.propagate = False
@@ -93,16 +93,16 @@
 
     def test_utf8_logging(self):
         with ignore_bytes_warning():
-            self.logger.error(u"\u00e9".encode("utf8"))
+            self.logger.error("\u00e9".encode("utf8"))
         if issubclass(bytes, basestring_type):
             # on python 2, utf8 byte strings (and by extension ascii byte
             # strings) are passed through as-is.
-            self.assertEqual(self.get_output(), utf8(u"\u00e9"))
+            self.assertEqual(self.get_output(), utf8("\u00e9"))
         else:
             # on python 3, byte strings always get repr'd even if
             # they're ascii-only, so this degenerates into another
             # copy of test_bytes_logging.
-            self.assertEqual(self.get_output(), utf8(repr(utf8(u"\u00e9"))))
+            self.assertEqual(self.get_output(), utf8(repr(utf8("\u00e9"))))
 
     def test_bytes_exception_logging(self):
         try:
@@ -112,9 +112,9 @@
         # This will be "Exception: \xe9" on python 2 or
         # "Exception: b'\xe9'" on python 3.
         output = self.get_output()
-        self.assertRegexpMatches(output, br"Exception.*\\xe9")
+        self.assertRegex(output, rb"Exception.*\\xe9")
         # The traceback contains newlines, which should not have been escaped.
-        self.assertNotIn(br"\n", output)
+        self.assertNotIn(rb"\n", output)
 
 
 class UnicodeLogFormatterTest(LogFormatterTest):
@@ -125,8 +125,8 @@
         return logging.FileHandler(filename, encoding="utf8")
 
     def test_unicode_logging(self):
-        self.logger.error(u"\u00e9")
-        self.assertEqual(self.get_output(), utf8(u"\u00e9"))
+        self.logger.error("\u00e9")
+        self.assertEqual(self.get_output(), utf8("\u00e9"))
 
 
 class EnablePrettyLoggingTest(unittest.TestCase):
@@ -148,7 +148,7 @@
             filenames = glob.glob(tmpdir + "/test_log*")
             self.assertEqual(1, len(filenames))
             with open(filenames0) as f:
-                self.assertRegexpMatches(f.read(), r"^\E ^*\ hello$")
+                self.assertRegex(f.read(), r"^\E ^*\ hello$")
         finally:
             for handler in self.logger.handlers:
                 handler.flush()
@@ -168,7 +168,7 @@
             filenames = glob.glob(tmpdir + "/test_log*")
             self.assertEqual(1, len(filenames))
             with open(filenames0) as f:
-                self.assertRegexpMatches(f.read(), r"^\E ^*\ hello$")
+                self.assertRegex(f.read(), r"^\E ^*\ hello$")
         finally:
             for handler in self.logger.handlers:
                 handler.flush()

_service:tar_scm:tornado-6.1.tar.gz/tornado/test/netutil_test.py -> _service:tar_scm:tornado-6.3.2.tar.gz/tornado/test/netutil_test.py Changed

@@ -44,7 +44,14 @@
     @gen_test
     def test_localhost(self: typing.Any):
         addrinfo = yield self.resolver.resolve("localhost", 80, socket.AF_UNSPEC)
-        self.assertIn((socket.AF_INET, ("127.0.0.1", 80)), addrinfo)
+        # Most of the time localhost resolves to either the ipv4 loopback
+        # address alone, or ipv4+ipv6. But some versions of pycares will only
+        # return the ipv6 version, so we have to check for either one alone.
+        self.assertTrue(
+            ((socket.AF_INET, ("127.0.0.1", 80)) in addrinfo)
+            or ((socket.AF_INET6, ("::1", 80)) in addrinfo),
+            f"loopback address not found in {addrinfo}",
+        )
 
 
 # It is impossible to quickly and consistently generate an error in name
@@ -204,6 +211,7 @@
         self.assertTrue(not is_valid_ip(" "))
         self.assertTrue(not is_valid_ip("\n"))
         self.assertTrue(not is_valid_ip("\x00"))
+        self.assertTrue(not is_valid_ip("a" * 100))
 
 
 class TestPortAllocation(unittest.TestCase):

_service:tar_scm:tornado-6.1.tar.gz/tornado/test/options_test.py -> _service:tar_scm:tornado-6.3.2.tar.gz/tornado/test/options_test.py Changed

@@ -204,6 +204,7 @@
         options.define("timedelta", type=datetime.timedelta)
         options.define("email", type=Email)
         options.define("list-of-int", type=int, multiple=True)
+        options.define("list-of-str", type=str, multiple=True)
         return options
 
     def _check_options_values(self, options):
@@ -216,6 +217,7 @@
         self.assertEqual(options.email.value, "tornado@web.com")
         self.assertTrue(isinstance(options.email, Email))
         self.assertEqual(options.list_of_int, 1, 2, 3)
+        self.assertEqual(options.list_of_str, "a", "b", "c")
 
     def test_types(self):
         options = self._define_options()
@@ -230,6 +232,7 @@
                 "--timedelta=45s",
                 "--email=tornado@web.com",
                 "--list-of-int=1,2,3",
+                "--list-of-str=a,b,c",
             
         )
         self._check_options_values(options)
@@ -262,7 +265,7 @@
         options.define("foo")
         with self.assertRaises(Error) as cm:
             options.define("foo")
-        self.assertRegexpMatches(str(cm.exception), "Option.*foo.*already defined")
+        self.assertRegex(str(cm.exception), "Option.*foo.*already defined")
 
     def test_error_redefine_underscore(self):
         # Ensure that the dash/underscore normalization doesn't
@@ -279,9 +282,7 @@
                 options.define(a)
                 with self.assertRaises(Error) as cm:
                     options.define(b)
-                self.assertRegexpMatches(
-                    str(cm.exception), "Option.*foo.bar.*already defined"
-                )
+                self.assertRegex(str(cm.exception), "Option.*foo.bar.*already defined")
 
     def test_dash_underscore_cli(self):
         # Dashes and underscores should be interchangeable.

_service:tar_scm:tornado-6.1.tar.gz/tornado/test/options_test_types.cfg -> _service:tar_scm:tornado-6.3.2.tar.gz/tornado/test/options_test_types.cfg Changed

_service:tar_scm:tornado-6.1.tar.gz/tornado/test/options_test_types_str.cfg -> _service:tar_scm:tornado-6.3.2.tar.gz/tornado/test/options_test_types_str.cfg Changed

_service:tar_scm:tornado-6.1.tar.gz/tornado/test/process_test.py -> _service:tar_scm:tornado-6.3.2.tar.gz/tornado/test/process_test.py Changed

_service:tar_scm:tornado-6.1.tar.gz/tornado/test/resolve_test_helper.py -> _service:tar_scm:tornado-6.3.2.tar.gz/tornado/test/resolve_test_helper.py Changed

_service:tar_scm:tornado-6.1.tar.gz/tornado/test/simple_httpclient_test.py -> _service:tar_scm:tornado-6.3.2.tar.gz/tornado/test/simple_httpclient_test.py Changed

@@ -537,11 +537,14 @@
         )
 
     def test_ssl_options(self):
-        resp = self.fetch("/hello", ssl_options={})
+        resp = self.fetch("/hello", ssl_options={"cert_reqs": ssl.CERT_NONE})
         self.assertEqual(resp.body, b"Hello world!")
 
     def test_ssl_context(self):
-        resp = self.fetch("/hello", ssl_options=ssl.SSLContext(ssl.PROTOCOL_SSLv23))
+        ssl_ctx = ssl.create_default_context(ssl.Purpose.SERVER_AUTH)
+        ssl_ctx.check_hostname = False
+        ssl_ctx.verify_mode = ssl.CERT_NONE
+        resp = self.fetch("/hello", ssl_options=ssl_ctx)
         self.assertEqual(resp.body, b"Hello world!")
 
     def test_ssl_options_handshake_fail(self):
@@ -555,8 +558,8 @@
 
     def test_ssl_context_handshake_fail(self):
         with ExpectLog(gen_log, "SSL Error|Uncaught exception"):
-            ctx = ssl.SSLContext(ssl.PROTOCOL_SSLv23)
-            ctx.verify_mode = ssl.CERT_REQUIRED
+            # CERT_REQUIRED is set by default.
+            ctx = ssl.create_default_context(ssl.Purpose.SERVER_AUTH)
             with self.assertRaises(ssl.SSLError):
                 self.fetch("/hello", ssl_options=ctx, raise_error=True)

_service:tar_scm:tornado-6.1.tar.gz/tornado/test/tcpclient_test.py -> _service:tar_scm:tornado-6.3.2.tar.gz/tornado/test/tcpclient_test.py Changed

@@ -91,7 +91,11 @@
     def do_test_connect(self, family, host, source_ip=None, source_port=None):
         port = self.start_server(family)
         stream = yield self.client.connect(
-            host, port, source_ip=source_ip, source_port=source_port
+            host,
+            port,
+            source_ip=source_ip,
+            source_port=source_port,
+            af=family,
         )
         assert self.server is not None
         server_stream = yield self.server.queue.get()
@@ -137,8 +141,7 @@
             yield self.client.connect("127.0.0.1", port)
 
     def test_source_ip_fail(self):
-        """Fail when trying to use the source IP Address '8.8.8.8'.
-        """
+        """Fail when trying to use the source IP Address '8.8.8.8'."""
         self.assertRaises(
             socket.error,
             self.do_test_connect,
@@ -148,14 +151,12 @@
         )
 
     def test_source_ip_success(self):
-        """Success when trying to use the source IP Address '127.0.0.1'.
-        """
+        """Success when trying to use the source IP Address '127.0.0.1'."""
         self.do_test_connect(socket.AF_INET, "127.0.0.1", source_ip="127.0.0.1")
 
     @skipIfNonUnix
     def test_source_port_fail(self):
-        """Fail when trying to use source port 1.
-        """
+        """Fail when trying to use source port 1."""
         if getpass.getuser() == "root":
             # Root can use any port so we can't easily force this to fail.
             # This is mainly relevant for docker.

_service:tar_scm:tornado-6.1.tar.gz/tornado/test/tcpserver_test.py -> _service:tar_scm:tornado-6.3.2.tar.gz/tornado/test/tcpserver_test.py Changed

@@ -4,7 +4,6 @@
 import textwrap
 import unittest
 
-from tornado.escape import utf8, to_unicode
 from tornado import gen
 from tornado.iostream import IOStream
 from tornado.log import app_log
@@ -12,6 +11,8 @@
 from tornado.test.util import skipIfNonUnix
 from tornado.testing import AsyncTestCase, ExpectLog, bind_unused_port, gen_test
 
+from typing import Tuple
+
 
 class TCPServerTest(AsyncTestCase):
     @gen_test
@@ -122,45 +123,52 @@
     # processes, each of which prints its task id to stdout (a single
     # byte, so we don't have to worry about atomicity of the shared
     # stdout stream) and then exits.
-    def run_subproc(self, code):
-        proc = subprocess.Popen(
-            sys.executable, stdin=subprocess.PIPE, stdout=subprocess.PIPE
-        )
-        proc.stdin.write(utf8(code))
-        proc.stdin.close()
-        proc.wait()
-        stdout = proc.stdout.read()
-        proc.stdout.close()
-        if proc.returncode != 0:
-            raise RuntimeError(
-                "Process returned %d. stdout=%r" % (proc.returncode, stdout)
+    def run_subproc(self, code: str) -> Tuplestr, str:
+        try:
+            result = subprocess.run(
+                sys.executable, "-Werror::DeprecationWarning",
+                capture_output=True,
+                input=code,
+                encoding="utf8",
+                check=True,
             )
-        return to_unicode(stdout)
+        except subprocess.CalledProcessError as e:
+            raise RuntimeError(
+                f"Process returned {e.returncode} stdout={e.stdout} stderr={e.stderr}"
+            ) from e
+        return result.stdout, result.stderr
 
-    def test_single(self):
+    def test_listen_single(self):
         # As a sanity check, run the single-process version through this test
         # harness too.
         code = textwrap.dedent(
             """
-            from tornado.ioloop import IOLoop
+            import asyncio
             from tornado.tcpserver import TCPServer
 
-            server = TCPServer()
-            server.listen(0, address='127.0.0.1')
-            IOLoop.current().run_sync(lambda: None)
+            async def main():
+                server = TCPServer()
+                server.listen(0, address='127.0.0.1')
+
+            asyncio.run(main())
             print('012', end='')
         """
         )
-        out = self.run_subproc(code)
+        out, err = self.run_subproc(code)
         self.assertEqual("".join(sorted(out)), "012")
+        self.assertEqual(err, "")
 
-    def test_simple(self):
+    def test_bind_start(self):
         code = textwrap.dedent(
             """
+            import warnings
+
             from tornado.ioloop import IOLoop
             from tornado.process import task_id
             from tornado.tcpserver import TCPServer
 
+            warnings.simplefilter("ignore", DeprecationWarning)
+
             server = TCPServer()
             server.bind(0, address='127.0.0.1')
             server.start(3)
@@ -168,13 +176,14 @@
             print(task_id(), end='')
         """
         )
-        out = self.run_subproc(code)
+        out, err = self.run_subproc(code)
         self.assertEqual("".join(sorted(out)), "012")
+        self.assertEqual(err, "")
 
-    def test_advanced(self):
+    def test_add_sockets(self):
         code = textwrap.dedent(
             """
-            from tornado.ioloop import IOLoop
+            import asyncio
             from tornado.netutil import bind_sockets
             from tornado.process import fork_processes, task_id
             from tornado.ioloop import IOLoop
@@ -182,11 +191,40 @@
 
             sockets = bind_sockets(0, address='127.0.0.1')
             fork_processes(3)
-            server = TCPServer()
-            server.add_sockets(sockets)
-            IOLoop.current().run_sync(lambda: None)
+            async def post_fork_main():
+                server = TCPServer()
+                server.add_sockets(sockets)
+            asyncio.run(post_fork_main())
             print(task_id(), end='')
         """
         )
-        out = self.run_subproc(code)
+        out, err = self.run_subproc(code)
+        self.assertEqual("".join(sorted(out)), "012")
+        self.assertEqual(err, "")
+
+    def test_listen_multi_reuse_port(self):
+        code = textwrap.dedent(
+            """
+            import asyncio
+            import socket
+            from tornado.netutil import bind_sockets
+            from tornado.process import task_id, fork_processes
+            from tornado.tcpserver import TCPServer
+
+            # Pick an unused port which we will be able to bind to multiple times.
+            (sock,) = bind_sockets(0, address='127.0.0.1',
+                family=socket.AF_INET, reuse_port=True)
+            port = sock.getsockname()1
+
+            fork_processes(3)
+
+            async def main():
+                server = TCPServer()
+                server.listen(port, address='127.0.0.1', reuse_port=True)
+            asyncio.run(main())
+            print(task_id(), end='')
+            """
+        )
+        out, err = self.run_subproc(code)
         self.assertEqual("".join(sorted(out)), "012")
+        self.assertEqual(err, "")

_service:tar_scm:tornado-6.1.tar.gz/tornado/test/template_test.py -> _service:tar_scm:tornado-6.3.2.tar.gz/tornado/test/template_test.py Changed

@@ -78,16 +78,16 @@
         )
 
     def test_unicode_template(self):
-        template = Template(utf8(u"\u00e9"))
-        self.assertEqual(template.generate(), utf8(u"\u00e9"))
+        template = Template(utf8("\u00e9"))
+        self.assertEqual(template.generate(), utf8("\u00e9"))
 
     def test_unicode_literal_expression(self):
         # Unicode literals should be usable in templates.  Note that this
         # test simulates unicode characters appearing directly in the
         # template file (with utf8 encoding), i.e. \u escapes would not
         # be used in the template file itself.
-        template = Template(utf8(u'{{ "\u00e9" }}'))
-        self.assertEqual(template.generate(), utf8(u"\u00e9"))
+        template = Template(utf8('{{ "\u00e9" }}'))
+        self.assertEqual(template.generate(), utf8("\u00e9"))
 
     def test_custom_namespace(self):
         loader = DictLoader(
@@ -106,15 +106,15 @@
         def upper(s):
             return to_unicode(s).upper()
 
-        template = Template(utf8(u"{% apply upper %}foo \u00e9{% end %}"))
-        self.assertEqual(template.generate(upper=upper), utf8(u"FOO \u00c9"))
+        template = Template(utf8("{% apply upper %}foo \u00e9{% end %}"))
+        self.assertEqual(template.generate(upper=upper), utf8("FOO \u00c9"))
 
     def test_bytes_apply(self):
         def upper(s):
             return utf8(to_unicode(s).upper())
 
-        template = Template(utf8(u"{% apply upper %}foo \u00e9{% end %}"))
-        self.assertEqual(template.generate(upper=upper), utf8(u"FOO \u00c9"))
+        template = Template(utf8("{% apply upper %}foo \u00e9{% end %}"))
+        self.assertEqual(template.generate(upper=upper), utf8("FOO \u00c9"))
 
     def test_if(self):
         template = Template(utf8("{% if x > 4 %}yes{% else %}no{% end %}"))
@@ -194,8 +194,8 @@
         self.assertEqual(template.generate(), "0")
 
     def test_non_ascii_name(self):
-        loader = DictLoader({u"t\u00e9st.html": "hello"})
-        self.assertEqual(loader.load(u"t\u00e9st.html").generate(), b"hello")
+        loader = DictLoader({"t\u00e9st.html": "hello"})
+        self.assertEqual(loader.load("t\u00e9st.html").generate(), b"hello")
 
 
 class StackTraceTest(unittest.TestCase):
@@ -533,4 +533,4 @@
     def test_utf8_in_file(self):
         tmpl = self.loader.load("utf8.html")
         result = tmpl.generate()
-        self.assertEqual(to_unicode(result).strip(), u"H\u00e9llo")
+        self.assertEqual(to_unicode(result).strip(), "H\u00e9llo")

_service:tar_scm:tornado-6.1.tar.gz/tornado/test/testing_test.py -> _service:tar_scm:tornado-6.3.2.tar.gz/tornado/test/testing_test.py Changed

@@ -5,9 +5,11 @@
 from tornado.web import Application
 import asyncio
 import contextlib
+import inspect
 import gc
 import os
 import platform
+import sys
 import traceback
 import unittest
 import warnings
@@ -106,7 +108,7 @@
     def test_fetch_full_http_url(self):
         # Ensure that self.fetch() recognizes absolute urls and does
         # not transform them into references to our main test server.
-        path = "http://localhost:%d/path" % self.second_port
+        path = "http://127.0.0.1:%d/path" % self.second_port
 
         response = self.fetch(path)
         self.assertEqual(response.request.url, path)
@@ -132,6 +134,9 @@
         platform.python_implementation() == "PyPy",
         "pypy destructor warnings cannot be silenced",
     )
+    @unittest.skipIf(
+        sys.version_info >= (3, 12), "py312 has its own check for test case returns"
+    )
     def test_undecorated_coroutine(self):
         class Test(AsyncTestCase):
             async def test_coro(self):
@@ -171,6 +176,17 @@
         self.assertEqual(len(result.errors), 1)
         self.assertIn("Return value from test method ignored", result.errors01)
 
+    def test_unwrap(self):
+        class Test(AsyncTestCase):
+            def test_foo(self):
+                pass
+
+        test = Test("test_foo")
+        self.assertIs(
+            inspect.unwrap(test.test_foo),
+            test.test_foo.orig_method,  # type: ignoreattr-defined
+        )
+
 
 class SetUpTearDownTest(unittest.TestCase):
     def test_set_up_tear_down(self):
@@ -325,29 +341,5 @@
             self.finished = True
 
 
-class GetNewIOLoopTest(AsyncTestCase):
-    def get_new_ioloop(self):
-        # Use the current loop instead of creating a new one here.
-        return ioloop.IOLoop.current()
-
-    def setUp(self):
-        # This simulates the effect of an asyncio test harness like
-        # pytest-asyncio.
-        self.orig_loop = asyncio.get_event_loop()
-        self.new_loop = asyncio.new_event_loop()
-        asyncio.set_event_loop(self.new_loop)
-        super().setUp()
-
-    def tearDown(self):
-        super().tearDown()
-        # AsyncTestCase must not affect the existing asyncio loop.
-        self.assertFalse(asyncio.get_event_loop().is_closed())
-        asyncio.set_event_loop(self.orig_loop)
-        self.new_loop.close()
-
-    def test_loop(self):
-        self.assertIs(self.io_loop.asyncio_loop, self.new_loop)  # type: ignore
-
-
 if __name__ == "__main__":
     unittest.main()

_service:tar_scm:tornado-6.1.tar.gz/tornado/test/twisted_test.py -> _service:tar_scm:tornado-6.3.2.tar.gz/tornado/test/twisted_test.py Changed

@@ -13,31 +13,15 @@
 # License for the specific language governing permissions and limitations
 # under the License.
 
-import asyncio
-import logging
-import signal
 import unittest
-import warnings
 
-from tornado.escape import utf8
-from tornado import gen
-from tornado.httpclient import AsyncHTTPClient
-from tornado.httpserver import HTTPServer
-from tornado.ioloop import IOLoop
-from tornado.testing import bind_unused_port, AsyncTestCase, gen_test
-from tornado.web import RequestHandler, Application
+from tornado.testing import AsyncTestCase, gen_test
 
 try:
     from twisted.internet.defer import (  # type: ignore
-        Deferred,
         inlineCallbacks,
         returnValue,
     )
-    from twisted.internet.protocol import Protocol  # type: ignore
-    from twisted.internet.asyncioreactor import AsyncioSelectorReactor  # type: ignore
-    from twisted.web.client import Agent, readBody  # type: ignore
-    from twisted.web.resource import Resource  # type: ignore
-    from twisted.web.server import Site  # type: ignore
 
     have_twisted = True
 except ImportError:
@@ -49,173 +33,6 @@
 skipIfNoTwisted = unittest.skipUnless(have_twisted, "twisted module not present")
 
 
-def save_signal_handlers():
-    saved = {}
-    signals = signal.SIGINT, signal.SIGTERM
-    if hasattr(signal, "SIGCHLD"):
-        signals.append(signal.SIGCHLD)
-    for sig in signals:
-        savedsig = signal.getsignal(sig)
-    if "twisted" in repr(saved):
-        # This indicates we're not cleaning up after ourselves properly.
-        raise Exception("twisted signal handlers already installed")
-    return saved
-
-
-def restore_signal_handlers(saved):
-    for sig, handler in saved.items():
-        signal.signal(sig, handler)
-
-
-# Test various combinations of twisted and tornado http servers,
-# http clients, and event loop interfaces.
-
-
-@skipIfNoTwisted
-class CompatibilityTests(unittest.TestCase):
-    def setUp(self):
-        self.saved_signals = save_signal_handlers()
-        self.saved_policy = asyncio.get_event_loop_policy()
-        if hasattr(asyncio, "WindowsSelectorEventLoopPolicy"):
-            # Twisted requires a selector event loop, even if Tornado is
-            # doing its own tricks in AsyncIOLoop to support proactors.
-            # Setting an AddThreadSelectorEventLoop exposes various edge
-            # cases so just use a regular selector.
-            asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())  # type: ignore
-        self.io_loop = IOLoop()
-        self.io_loop.make_current()
-        self.reactor = AsyncioSelectorReactor()
-
-    def tearDown(self):
-        self.reactor.disconnectAll()
-        self.io_loop.clear_current()
-        self.io_loop.close(all_fds=True)
-        asyncio.set_event_loop_policy(self.saved_policy)
-        restore_signal_handlers(self.saved_signals)
-
-    def start_twisted_server(self):
-        class HelloResource(Resource):
-            isLeaf = True
-
-            def render_GET(self, request):
-                return b"Hello from twisted!"
-
-        site = Site(HelloResource())
-        port = self.reactor.listenTCP(0, site, interface="127.0.0.1")
-        self.twisted_port = port.getHost().port
-
-    def start_tornado_server(self):
-        class HelloHandler(RequestHandler):
-            def get(self):
-                self.write("Hello from tornado!")
-
-        app = Application(("/", HelloHandler), log_function=lambda x: None)
-        server = HTTPServer(app)
-        sock, self.tornado_port = bind_unused_port()
-        server.add_sockets(sock)
-
-    def run_reactor(self):
-        # In theory, we can run the event loop through Tornado,
-        # Twisted, or asyncio interfaces. However, since we're trying
-        # to avoid installing anything as the global event loop, only
-        # the twisted interface gets everything wired up correectly
-        # without extra hacks. This method is a part of a
-        # no-longer-used generalization that allowed us to test
-        # different combinations.
-        self.stop_loop = self.reactor.stop
-        self.stop = self.reactor.stop
-        self.reactor.run()
-
-    def tornado_fetch(self, url, runner):
-        client = AsyncHTTPClient()
-        fut = asyncio.ensure_future(client.fetch(url))
-        fut.add_done_callback(lambda f: self.stop_loop())
-        runner()
-        return fut.result()
-
-    def twisted_fetch(self, url, runner):
-        # http://twistedmatrix.com/documents/current/web/howto/client.html
-        chunks = 
-        client = Agent(self.reactor)
-        d = client.request(b"GET", utf8(url))
-
-        class Accumulator(Protocol):
-            def __init__(self, finished):
-                self.finished = finished
-
-            def dataReceived(self, data):
-                chunks.append(data)
-
-            def connectionLost(self, reason):
-                self.finished.callback(None)
-
-        def callback(response):
-            finished = Deferred()
-            response.deliverBody(Accumulator(finished))
-            return finished
-
-        d.addCallback(callback)
-
-        def shutdown(failure):
-            if hasattr(self, "stop_loop"):
-                self.stop_loop()
-            elif failure is not None:
-                # loop hasn't been initialized yet; try our best to
-                # get an error message out. (the runner() interaction
-                # should probably be refactored).
-                try:
-                    failure.raiseException()
-                except:
-                    logging.error("exception before starting loop", exc_info=True)
-
-        d.addBoth(shutdown)
-        runner()
-        self.assertTrue(chunks)
-        return b"".join(chunks)
-
-    def twisted_coroutine_fetch(self, url, runner):
-        body = None
-
-        @gen.coroutine
-        def f():
-            # This is simpler than the non-coroutine version, but it cheats
-            # by reading the body in one blob instead of streaming it with
-            # a Protocol.
-            client = Agent(self.reactor)
-            response = yield client.request(b"GET", utf8(url))
-            with warnings.catch_warnings():
-                # readBody has a buggy DeprecationWarning in Twisted 15.0:
-                # https://twistedmatrix.com/trac/changeset/43379
-                warnings.simplefilter("ignore", category=DeprecationWarning)
-                body0 = yield readBody(response)
-            self.stop_loop()
-
-        self.io_loop.add_callback(f)
-        runner()
-        return body0
-
-    def testTwistedServerTornadoClientReactor(self):
-        self.start_twisted_server()
-        response = self.tornado_fetch(
-            "http://127.0.0.1:%d" % self.twisted_port, self.run_reactor
-        )
-        self.assertEqual(response.body, b"Hello from twisted!")
-
-    def testTornadoServerTwistedClientReactor(self):
-        self.start_tornado_server()
-        response = self.twisted_fetch(
-            "http://127.0.0.1:%d" % self.tornado_port, self.run_reactor
-        )
-        self.assertEqual(response, b"Hello from tornado!")
-
-    def testTornadoServerTwistedCoroutineClientReactor(self):
-        self.start_tornado_server()
-        response = self.twisted_coroutine_fetch(
-            "http://127.0.0.1:%d" % self.tornado_port, self.run_reactor

_service:tar_scm:tornado-6.1.tar.gz/tornado/test/util_test.py -> _service:tar_scm:tornado-6.3.2.tar.gz/tornado/test/util_test.py Changed

@@ -4,7 +4,7 @@
 import datetime
 import unittest
 
-import tornado.escape
+import tornado
 from tornado.escape import utf8
 from tornado.util import (
     raise_exc_info,
@@ -214,7 +214,7 @@
 
 class UnicodeLiteralTest(unittest.TestCase):
     def test_unicode_escapes(self):
-        self.assertEqual(utf8(u"\u00e9"), b"\xc3\xa9")
+        self.assertEqual(utf8("\u00e9"), b"\xc3\xa9")
 
 
 class ExecInTest(unittest.TestCase):
@@ -276,7 +276,7 @@
         self.assertIs(import_object("tornado.escape.utf8"), utf8)
 
     def test_import_member_unicode(self):
-        self.assertIs(import_object(u"tornado.escape.utf8"), utf8)
+        self.assertIs(import_object("tornado.escape.utf8"), utf8)
 
     def test_import_module(self):
         self.assertIs(import_object("tornado.escape"), tornado.escape)
@@ -285,7 +285,7 @@
         # The internal implementation of __import__ differs depending on
         # whether the thing being imported is a module or not.
         # This variant requires a byte string in python 2.
-        self.assertIs(import_object(u"tornado.escape"), tornado.escape)
+        self.assertIs(import_object("tornado.escape"), tornado.escape)
 
 
 class ReUnescapeTest(unittest.TestCase):

_service:tar_scm:tornado-6.1.tar.gz/tornado/test/web_test.py -> _service:tar_scm:tornado-6.3.2.tar.gz/tornado/test/web_test.py Changed

@@ -17,6 +17,7 @@
 from tornado.simple_httpclient import SimpleAsyncHTTPClient
 from tornado.template import DictLoader
 from tornado.testing import AsyncHTTPTestCase, AsyncTestCase, ExpectLog, gen_test
+from tornado.test.util import ignore_deprecation
 from tornado.util import ObjectDict, unicode_type
 from tornado.web import (
     Application,
@@ -97,7 +98,7 @@
 
 
 class CookieTestRequestHandler(RequestHandler):
-    # stub out enough methods to make the secure_cookie functions work
+    # stub out enough methods to make the signed_cookie functions work
     def __init__(self, cookie_secret="0123456789", key_version=None):
         # don't call super.__init__
         self._cookies = {}  # type: typing.Dictstr, bytes
@@ -121,15 +122,15 @@
 class SecureCookieV1Test(unittest.TestCase):
     def test_round_trip(self):
         handler = CookieTestRequestHandler()
-        handler.set_secure_cookie("foo", b"bar", version=1)
-        self.assertEqual(handler.get_secure_cookie("foo", min_version=1), b"bar")
+        handler.set_signed_cookie("foo", b"bar", version=1)
+        self.assertEqual(handler.get_signed_cookie("foo", min_version=1), b"bar")
 
     def test_cookie_tampering_future_timestamp(self):
         handler = CookieTestRequestHandler()
         # this string base64-encodes to '12345678'
-        handler.set_secure_cookie("foo", binascii.a2b_hex(b"d76df8e7aefc"), version=1)
+        handler.set_signed_cookie("foo", binascii.a2b_hex(b"d76df8e7aefc"), version=1)
         cookie = handler._cookies"foo"
-        match = re.match(br"12345678\|(0-9+)\|(0-9a-f+)", cookie)
+        match = re.match(rb"12345678\|(0-9+)\|(0-9a-f+)", cookie)
         assert match is not None
         timestamp = match.group(1)
         sig = match.group(2)
@@ -160,14 +161,14 @@
         )
         # it gets rejected
         with ExpectLog(gen_log, "Cookie timestamp in future"):
-            self.assertTrue(handler.get_secure_cookie("foo", min_version=1) is None)
+            self.assertTrue(handler.get_signed_cookie("foo", min_version=1) is None)
 
     def test_arbitrary_bytes(self):
         # Secure cookies accept arbitrary data (which is base64 encoded).
         # Note that normal cookies accept only a subset of ascii.
         handler = CookieTestRequestHandler()
-        handler.set_secure_cookie("foo", b"\xe9", version=1)
-        self.assertEqual(handler.get_secure_cookie("foo", min_version=1), b"\xe9")
+        handler.set_signed_cookie("foo", b"\xe9", version=1)
+        self.assertEqual(handler.get_signed_cookie("foo", min_version=1), b"\xe9")
 
 
 # See SignedValueTest below for more.
@@ -176,46 +177,46 @@
 
     def test_round_trip(self):
         handler = CookieTestRequestHandler()
-        handler.set_secure_cookie("foo", b"bar", version=2)
-        self.assertEqual(handler.get_secure_cookie("foo", min_version=2), b"bar")
+        handler.set_signed_cookie("foo", b"bar", version=2)
+        self.assertEqual(handler.get_signed_cookie("foo", min_version=2), b"bar")
 
     def test_key_version_roundtrip(self):
         handler = CookieTestRequestHandler(
             cookie_secret=self.KEY_VERSIONS, key_version=0
         )
-        handler.set_secure_cookie("foo", b"bar")
-        self.assertEqual(handler.get_secure_cookie("foo"), b"bar")
+        handler.set_signed_cookie("foo", b"bar")
+        self.assertEqual(handler.get_signed_cookie("foo"), b"bar")
 
     def test_key_version_roundtrip_differing_version(self):
         handler = CookieTestRequestHandler(
             cookie_secret=self.KEY_VERSIONS, key_version=1
         )
-        handler.set_secure_cookie("foo", b"bar")
-        self.assertEqual(handler.get_secure_cookie("foo"), b"bar")
+        handler.set_signed_cookie("foo", b"bar")
+        self.assertEqual(handler.get_signed_cookie("foo"), b"bar")
 
     def test_key_version_increment_version(self):
         handler = CookieTestRequestHandler(
             cookie_secret=self.KEY_VERSIONS, key_version=0
         )
-        handler.set_secure_cookie("foo", b"bar")
+        handler.set_signed_cookie("foo", b"bar")
         new_handler = CookieTestRequestHandler(
             cookie_secret=self.KEY_VERSIONS, key_version=1
         )
         new_handler._cookies = handler._cookies
-        self.assertEqual(new_handler.get_secure_cookie("foo"), b"bar")
+        self.assertEqual(new_handler.get_signed_cookie("foo"), b"bar")
 
     def test_key_version_invalidate_version(self):
         handler = CookieTestRequestHandler(
             cookie_secret=self.KEY_VERSIONS, key_version=0
         )
-        handler.set_secure_cookie("foo", b"bar")
+        handler.set_signed_cookie("foo", b"bar")
         new_key_versions = self.KEY_VERSIONS.copy()
         new_key_versions.pop(0)
         new_handler = CookieTestRequestHandler(
             cookie_secret=new_key_versions, key_version=1
         )
         new_handler._cookies = handler._cookies
-        self.assertEqual(new_handler.get_secure_cookie("foo"), None)
+        self.assertEqual(new_handler.get_signed_cookie("foo"), None)
 
 
 class FinalReturnTest(WebTestCase):
@@ -274,7 +275,7 @@
                 # Try setting cookies with different argument types
                 # to ensure that everything gets encoded correctly
                 self.set_cookie("str", "asdf")
-                self.set_cookie("unicode", u"qwer")
+                self.set_cookie("unicode", "qwer")
                 self.set_cookie("bytes", b"zxcv")
 
         class GetCookieHandler(RequestHandler):
@@ -287,7 +288,7 @@
             def get(self):
                 # unicode domain and path arguments shouldn't break things
                 # either (see bug #285)
-                self.set_cookie("unicode_args", "blah", domain=u"foo.com", path=u"/foo")
+                self.set_cookie("unicode_args", "blah", domain="foo.com", path="/foo")
 
         class SetCookieSpecialCharHandler(RequestHandler):
             def get(self):
@@ -318,6 +319,11 @@
                 self.set_cookie("c", "1", httponly=True)
                 self.set_cookie("d", "1", httponly=False)
 
+        class SetCookieDeprecatedArgs(RequestHandler):
+            def get(self):
+                # Mixed case is supported, but deprecated
+                self.set_cookie("a", "b", HttpOnly=True, pATH="/foo")
+
         return 
             ("/set", SetCookieHandler),
             ("/get", GetCookieHandler),
@@ -327,6 +333,7 @@
             ("/set_max_age", SetCookieMaxAgeHandler),
             ("/set_expires_days", SetCookieExpiresDaysHandler),
             ("/set_falsy_flags", SetCookieFalsyFlags),
+            ("/set_deprecated", SetCookieDeprecatedArgs),
         
 
     def test_set_cookie(self):
@@ -413,6 +420,12 @@
         self.assertEqual(headers2.lower(), "c=1; httponly; path=/")
         self.assertEqual(headers3.lower(), "d=1; path=/")
 
+    def test_set_cookie_deprecated(self):
+        with ignore_deprecation():
+            response = self.fetch("/set_deprecated")
+        header = response.headers.get("Set-Cookie")
+        self.assertEqual(header, "a=b; HttpOnly; Path=/foo")
+
 
 class AuthRedirectRequestHandler(RequestHandler):
     def initialize(self, login_url):
@@ -542,9 +555,9 @@
         self.assertEqual(
             self.fetch_json("/group/%C3%A9?arg=%C3%A9"),
             {
-                u"path": u"/group/%C3%A9",
-                u"path_args": u"\u00e9",
-                u"args": {u"arg": u"\u00e9"},
+                "path": "/group/%C3%A9",
+                "path_args": "\u00e9",
+                "args": {"arg": "\u00e9"},
             },
         )
 
@@ -585,7 +598,7 @@
             raise Exception(
                 "unexpected values for cookie keys: %r" % self.cookies.keys()
             )
-        self.check_type("get_secure_cookie", self.get_secure_cookie("asdf"), bytes)
+        self.check_type("get_signed_cookie", self.get_signed_cookie("asdf"), bytes)
         self.check_type("get_cookie", self.get_cookie("asdf"), str)
 
         self.check_type("xsrf_token", self.xsrf_token, bytes)
@@ -813,15 +826,13 @@
             data = json_decode(response.body)
             self.assertEqual(
                 data,
-                {u"path": u"unicode", u"\u00e9", u"query": u"unicode", u"\u00e9"},
+                {"path": "unicode", "\u00e9", "query": "unicode", "\u00e9"},
             )
 
         response = self.fetch("/decode_arg/%C3%A9?foo=%C3%A9")
         response.rethrow()
         data = json_decode(response.body)
-        self.assertEqual(
-            data, {u"path": u"bytes", u"c3a9", u"query": u"bytes", u"c3a9"}
-        )
+        self.assertEqual(data, {"path": "bytes", "c3a9", "query": "bytes", "c3a9"})

_service:tar_scm:tornado-6.1.tar.gz/tornado/test/websocket_test.py -> _service:tar_scm:tornado-6.3.2.tar.gz/tornado/test/websocket_test.py Changed

@@ -1,5 +1,6 @@
 import asyncio
 import functools
+import socket
 import traceback
 import typing
 import unittest
@@ -9,6 +10,7 @@
 from tornado.httpclient import HTTPError, HTTPRequest
 from tornado.locks import Event
 from tornado.log import gen_log, app_log
+from tornado.netutil import Resolver
 from tornado.simple_httpclient import SimpleAsyncHTTPClient
 from tornado.template import DictLoader
 from tornado.testing import AsyncHTTPTestCase, gen_test, bind_unused_port, ExpectLog
@@ -341,9 +343,16 @@
     @gen_test
     def test_unicode_message(self):
         ws = yield self.ws_connect("/echo")
-        ws.write_message(u"hello \u00e9")
+        ws.write_message("hello \u00e9")
         response = yield ws.read_message()
-        self.assertEqual(response, u"hello \u00e9")
+        self.assertEqual(response, "hello \u00e9")
+
+    @gen_test
+    def test_error_in_closed_client_write_message(self):
+        ws = yield self.ws_connect("/echo")
+        ws.close()
+        with self.assertRaises(WebSocketClosedError):
+            ws.write_message("hello \u00e9")
 
     @gen_test
     def test_render_message(self):
@@ -381,7 +390,7 @@
         sock, port = bind_unused_port()
         sock.close()
         with self.assertRaises(IOError):
-            with ExpectLog(gen_log, ".*"):
+            with ExpectLog(gen_log, ".*", required=False):
                 yield websocket_connect(
                     "ws://127.0.0.1:%d/" % port, connect_timeout=3600
                 )
@@ -532,6 +541,15 @@
     def test_check_origin_invalid_subdomains(self):
         port = self.get_http_port()
 
+        # CaresResolver may return ipv6-only results for localhost, but our
+        # server is only running on ipv4. Test for this edge case and skip
+        # the test if it happens.
+        addrinfo = yield Resolver().resolve("localhost", port)
+        families = set(addr0 for addr in addrinfo)
+        if socket.AF_INET not in families:
+            self.skipTest("localhost does not resolve to ipv4")
+            return
+
         url = "ws://localhost:%d/echo" % port
         # Subdomains should be disallowed by default.  If we could pass a
         # resolver to websocket_connect we could test sibling domains as well.
@@ -789,6 +807,7 @@
             response = yield ws.read_message()
             self.assertEqual(response, "got ping")
         # TODO: test that the connection gets closed if ping responses stop.
+        ws.close()
 
 
 class ManualPingTest(WebSocketBaseTestCase):

_service:tar_scm:tornado-6.1.tar.gz/tornado/test/wsgi_test.py -> _service:tar_scm:tornado-6.3.2.tar.gz/tornado/test/wsgi_test.py Changed

@@ -1,20 +1,116 @@
+import asyncio
+import concurrent.futures
+import threading
+
 from wsgiref.validate import validator
 
-from tornado.testing import AsyncHTTPTestCase
+from tornado.routing import RuleRouter
+from tornado.testing import AsyncHTTPTestCase, gen_test
 from tornado.wsgi import WSGIContainer
 
 
-class WSGIContainerTest(AsyncHTTPTestCase):
+class WSGIAppMixin:
     # TODO: Now that WSGIAdapter is gone, this is a pretty weak test.
-    def wsgi_app(self, environ, start_response):
+    def get_executor(self):
+        raise NotImplementedError()
+
+    def get_app(self):
+        executor = self.get_executor()
+        # The barrier test in DummyExecutorTest will always wait the full
+        # value of this timeout, so we don't want it to be too high.
+        self.barrier = threading.Barrier(2, timeout=0.3)
+
+        def make_container(app):
+            return WSGIContainer(validator(app), executor=executor)
+
+        return RuleRouter(
+            
+                ("/simple", make_container(self.simple_wsgi_app)),
+                ("/barrier", make_container(self.barrier_wsgi_app)),
+                ("/streaming_barrier", make_container(self.streaming_barrier_wsgi_app)),
+            
+        )
+
+    def respond_plain(self, start_response):
         status = "200 OK"
         response_headers = ("Content-Type", "text/plain")
         start_response(status, response_headers)
+
+    def simple_wsgi_app(self, environ, start_response):
+        self.respond_plain(start_response)
         return b"Hello world!"
 
-    def get_app(self):
-        return WSGIContainer(validator(self.wsgi_app))
+    def barrier_wsgi_app(self, environ, start_response):
+        self.respond_plain(start_response)
+        try:
+            n = self.barrier.wait()
+        except threading.BrokenBarrierError:
+            return b"broken barrier"
+        else:
+            return b"ok %d" % n
+
+    def streaming_barrier_wsgi_app(self, environ, start_response):
+        self.respond_plain(start_response)
+        yield b"ok "
+        try:
+            n = self.barrier.wait()
+        except threading.BrokenBarrierError:
+            yield b"broken barrier"
+        else:
+            yield b"%d" % n
+
+
+class WSGIContainerDummyExecutorTest(WSGIAppMixin, AsyncHTTPTestCase):
+    def get_executor(self):
+        return None
+
+    def test_simple(self):
+        response = self.fetch("/simple")
+        self.assertEqual(response.body, b"Hello world!")
+
+    @gen_test
+    async def test_concurrent_barrier(self):
+        self.barrier.reset()
+        resps = await asyncio.gather(
+            self.http_client.fetch(self.get_url("/barrier")),
+            self.http_client.fetch(self.get_url("/barrier")),
+        )
+        for resp in resps:
+            self.assertEqual(resp.body, b"broken barrier")
+
+    @gen_test
+    async def test_concurrent_streaming_barrier(self):
+        self.barrier.reset()
+        resps = await asyncio.gather(
+            self.http_client.fetch(self.get_url("/streaming_barrier")),
+            self.http_client.fetch(self.get_url("/streaming_barrier")),
+        )
+        for resp in resps:
+            self.assertEqual(resp.body, b"ok broken barrier")
+
+
+class WSGIContainerThreadPoolTest(WSGIAppMixin, AsyncHTTPTestCase):
+    def get_executor(self):
+        return concurrent.futures.ThreadPoolExecutor()
 
     def test_simple(self):
-        response = self.fetch("/")
+        response = self.fetch("/simple")
         self.assertEqual(response.body, b"Hello world!")
+
+    @gen_test
+    async def test_concurrent_barrier(self):
+        self.barrier.reset()
+        resps = await asyncio.gather(
+            self.http_client.fetch(self.get_url("/barrier")),
+            self.http_client.fetch(self.get_url("/barrier")),
+        )
+        self.assertEqual(b"ok 0", b"ok 1", sorted(resp.body for resp in resps))
+
+    @gen_test
+    async def test_concurrent_streaming_barrier(self):
+        self.barrier.reset()
+        resps = await asyncio.gather(
+            self.http_client.fetch(self.get_url("/streaming_barrier")),
+            self.http_client.fetch(self.get_url("/streaming_barrier")),
+        )
+        self.assertEqual(b"ok 0", b"ok 1", sorted(resp.body for resp in resps))

_service:tar_scm:tornado-6.1.tar.gz/tornado/testing.py -> _service:tar_scm:tornado-6.3.2.tar.gz/tornado/testing.py Changed

@@ -20,6 +20,7 @@
 import socket
 import sys
 import unittest
+import warnings
 
 from tornado import gen
 from tornado.httpclient import AsyncHTTPClient, HTTPResponse
@@ -33,14 +34,10 @@
 from tornado.web import Application
 
 import typing
-from typing import Tuple, Any, Callable, Type, Dict, Union, Optional
+from typing import Tuple, Any, Callable, Type, Dict, Union, Optional, Coroutine
 from types import TracebackType
 
 if typing.TYPE_CHECKING:
-    # Coroutine wasn't added to typing until 3.5.3, so only import it
-    # when mypy is running and use forward references.
-    from typing import Coroutine  # noqa: F401
-
     _ExcInfoTuple = Tuple
         OptionalTypeBaseException, OptionalBaseException, OptionalTracebackType
     
@@ -49,7 +46,9 @@
 _NON_OWNED_IOLOOPS = AsyncIOMainLoop
 
 
-def bind_unused_port(reuse_port: bool = False) -> Tuplesocket.socket, int:
+def bind_unused_port(
+    reuse_port: bool = False, address: str = "127.0.0.1"
+) -> Tuplesocket.socket, int:
     """Binds a server socket to an available port on localhost.
 
     Returns a tuple (socket, port).
@@ -57,9 +56,13 @@
     .. versionchanged:: 4.4
        Always binds to ``127.0.0.1`` without resolving the name
        ``localhost``.
+
+    .. versionchanged:: 6.2
+       Added optional ``address`` argument to
+       override the default "127.0.0.1".
     """
     sock = netutil.bind_sockets(
-        0, "127.0.0.1", family=socket.AF_INET, reuse_port=reuse_port
+        0, address, family=socket.AF_INET, reuse_port=reuse_port
     )0
     port = sock.getsockname()1
     return sock, port
@@ -93,6 +96,7 @@
 
     def __init__(self, orig_method: Callable) -> None:
         self.orig_method = orig_method
+        self.__wrapped__ = orig_method
 
     def __call__(self, *args: Any, **kwargs: Any) -> None:
         result = self.orig_method(*args, **kwargs)
@@ -131,7 +135,8 @@
 
     By default, a new `.IOLoop` is constructed for each test and is available
     as ``self.io_loop``.  If the code being tested requires a
-    global `.IOLoop`, subclasses should override `get_new_ioloop` to return it.
+    reused global `.IOLoop`, subclasses should override `get_new_ioloop` to return it,
+    although this is deprecated as of Tornado 6.3.
 
     The `.IOLoop`'s ``start`` and ``stop`` methods should not be
     called directly.  Instead, use `self.stop <stop>` and `self.wait
@@ -178,9 +183,22 @@
         self._test_generator = None  # type: OptionalUnionGenerator, Coroutine
 
     def setUp(self) -> None:
+        py_ver = sys.version_info
+        if ((3, 10, 0) <= py_ver < (3, 10, 9)) or ((3, 11, 0) <= py_ver <= (3, 11, 1)):
+            # Early releases in the Python 3.10 and 3.1 series had deprecation
+            # warnings that were later reverted; we must suppress them here.
+            setup_with_context_manager(self, warnings.catch_warnings())
+            warnings.filterwarnings(
+                "ignore",
+                message="There is no current event loop",
+                category=DeprecationWarning,
+                module=r"tornado\..*",
+            )
         super().setUp()
+        if type(self).get_new_ioloop is not AsyncTestCase.get_new_ioloop:
+            warnings.warn("get_new_ioloop is deprecated", DeprecationWarning)
         self.io_loop = self.get_new_ioloop()
-        self.io_loop.make_current()
+        asyncio.set_event_loop(self.io_loop.asyncio_loop)  # type: ignoreattr-defined
 
     def tearDown(self) -> None:
         # Native coroutines tend to produce warnings if they're not
@@ -194,7 +212,7 @@
             tasks = asyncio.Task.all_tasks(asyncio_loop)
         # Tasks that are done may still appear here and may contain
         # non-cancellation exceptions, so filter them out.
-        tasks = t for t in tasks if not t.done()
+        tasks = t for t in tasks if not t.done()  # type: ignore
         for t in tasks:
             t.cancel()
         # Allow the tasks to run and finalize themselves (which means
@@ -215,7 +233,7 @@
 
         # Clean up Subprocess, so it can be used again with a new ioloop.
         Subprocess.uninitialize()
-        self.io_loop.clear_current()
+        asyncio.set_event_loop(None)
         if not isinstance(self.io_loop, _NON_OWNED_IOLOOPS):
             # Try to clean up any file descriptors left open in the ioloop.
             # This avoids leaks, especially when tests are run repeatedly
@@ -239,8 +257,11 @@
         singletons using the default `.IOLoop`) or if a per-test event
         loop is being provided by another system (such as
         ``pytest-asyncio``).
+
+        .. deprecated:: 6.3
+           This method will be removed in Tornado 7.0.
         """
-        return IOLoop()
+        return IOLoop(make_current=False)
 
     def _handle_exception(
         self, typ: TypeException, value: Exception, tb: TracebackType
@@ -590,7 +611,7 @@
         if inspect.iscoroutinefunction(f):
             coro = pre_coroutine
         else:
-            coro = gen.coroutine(pre_coroutine)
+            coro = gen.coroutine(pre_coroutine)  # type: ignoreassignment
 
         @functools.wraps(coro)
         def post_coroutine(self, *args, **kwargs):
@@ -609,7 +630,7 @@
                 if self._test_generator is not None and getattr(
                     self._test_generator, "cr_running", True
                 ):
-                    self._test_generator.throw(type(e), e)
+                    self._test_generator.throw(e)
                     # In case the test contains an overly broad except
                     # clause, we may get back here.
                 # Coroutine was stopped or didn't raise a useful stack trace,
@@ -661,28 +682,37 @@
     ) -> None:
         """Constructs an ExpectLog context manager.
 
-        :param logger: Logger object (or name of logger) to watch.  Pass
-            an empty string to watch the root logger.
-        :param regex: Regular expression to match.  Any log entries on
-            the specified logger that match this regex will be suppressed.
-        :param required: If true, an exception will be raised if the end of
-            the ``with`` statement is reached without matching any log entries.
+        :param logger: Logger object (or name of logger) to watch.  Pass an
+            empty string to watch the root logger.
+        :param regex: Regular expression to match.  Any log entries on the
+            specified logger that match this regex will be suppressed.
+        :param required: If true, an exception will be raised if the end of the
+            ``with`` statement is reached without matching any log entries.
         :param level: A constant from the ``logging`` module indicating the
             expected log level. If this parameter is provided, only log messages
             at this level will be considered to match. Additionally, the
-            supplied ``logger`` will have its level adjusted if necessary
-            (for the duration of the ``ExpectLog`` to enable the expected
-            message.
+            supplied ``logger`` will have its level adjusted if necessary (for
+            the duration of the ``ExpectLog`` to enable the expected message.
 
         .. versionchanged:: 6.1
            Added the ``level`` parameter.
+
+        .. deprecated:: 6.3
+           In Tornado 7.0, only ``WARNING`` and higher logging levels will be
+           matched by default. To match ``INFO`` and lower levels, the ``level``
+           argument must be used. This is changing to minimize differences
+           between ``tornado.testing.main`` (which enables ``INFO`` logs by
+           default) and most other test runners (including those in IDEs)
+           which have ``INFO`` logs disabled by default.
         """
         if isinstance(logger, basestring_type):
             logger = logging.getLogger(logger)
         self.logger = logger
         self.regex = re.compile(regex)
         self.required = required
-        self.matched = False
+        # matched and deprecated_level_matched are a counter for the respective event.
+        self.matched = 0
+        self.deprecated_level_matched = 0
         self.logged_stack = False
         self.level = level
         self.orig_level = None  # type: Optionalint
@@ -692,13 +722,20 @@
             self.logged_stack = True
         message = record.getMessage()
         if self.regex.match(message):
+            if self.level is None and record.levelno < logging.WARNING:
+                # We're inside the logging machinery here so generating a DeprecationWarning
+                # here won't be reported cleanly (if warnings-as-errors is enabled, the error
+                # just gets swallowed by the logging module), and even if it were it would
+                # have the wrong stack trace. Just remember this fact and report it in
+                # __exit__ instead.
+                self.deprecated_level_matched += 1

_service:tar_scm:tornado-6.1.tar.gz/tornado/util.py -> _service:tar_scm:tornado-6.3.2.tar.gz/tornado/util.py Changed

@@ -11,6 +11,7 @@
 """
 
 import array
+import asyncio
 import atexit
 from inspect import getfullargspec
 import os
@@ -63,19 +64,13 @@
     is_finalizing = _get_emulated_is_finalizing()
 
 
-class TimeoutError(Exception):
-    """Exception raised by `.with_timeout` and `.IOLoop.run_sync`.
-
-    .. versionchanged:: 5.0:
-       Unified ``tornado.gen.TimeoutError`` and
-       ``tornado.ioloop.TimeoutError`` as ``tornado.util.TimeoutError``.
-       Both former names remain as aliases.
-    """
+# versionchanged:: 6.2
+# no longer our own TimeoutError, use standard asyncio class
+TimeoutError = asyncio.TimeoutError
 
 
 class ObjectDict(Dictstr, Any):
-    """Makes a dictionary behave like an object, with attribute-style access.
-    """
+    """Makes a dictionary behave like an object, with attribute-style access."""
 
     def __getattr__(self, name: str) -> Any:
         try:
@@ -115,8 +110,7 @@
 
     @property
     def unconsumed_tail(self) -> bytes:
-        """Returns the unconsumed portion left over
-        """
+        """Returns the unconsumed portion left over"""
         return self.decompressobj.unconsumed_tail
 
     def flush(self) -> bytes:
@@ -168,14 +162,8 @@
 
 
 def raise_exc_info(
-    exc_info,  # type: TupleOptionaltype, OptionalBaseException, OptionalTracebackType
-):
-    # type: (...) -> typing.NoReturn
-    #
-    # This function's type annotation must use comments instead of
-    # real annotations because typing.NoReturn does not exist in
-    # python 3.5's typing module. The formatting is funky because this
-    # is apparently what flake8 wants.
+    exc_info: TupleOptionaltype, OptionalBaseException, Optional"TracebackType"
+) -> typing.NoReturn:
     try:
         if exc_info1 is not None:
             raise exc_info1.with_traceback(exc_info2)

_service:tar_scm:tornado-6.1.tar.gz/tornado/web.py -> _service:tar_scm:tornado-6.3.2.tar.gz/tornado/web.py Changed

@@ -22,19 +22,22 @@
 
 .. testcode::
 
-    import tornado.ioloop
-    import tornado.web
+    import asyncio
+    import tornado
 
     class MainHandler(tornado.web.RequestHandler):
         def get(self):
             self.write("Hello, world")
 
-    if __name__ == "__main__":
+    async def main():
         application = tornado.web.Application(
             (r"/", MainHandler),
         )
         application.listen(8888)
-        tornado.ioloop.IOLoop.current().start()
+        await asyncio.Event().wait()
+
+    if __name__ == "__main__":
+        asyncio.run(main())
 
 .. testoutput::
    :hide:
@@ -72,9 +75,11 @@
 import numbers
 import os.path
 import re
+import socket
 import sys
 import threading
 import time
+import warnings
 import tornado
 import traceback
 import types
@@ -87,7 +92,6 @@
 from tornado.httpserver import HTTPServer
 from tornado import httputil
 from tornado import iostream
-import tornado.locale
 from tornado import locale
 from tornado.log import access_log, app_log, gen_log
 from tornado import template
@@ -118,6 +122,7 @@
     Iterable,
     Generator,
     Type,
+    TypeVar,
     cast,
     overload,
 )
@@ -160,7 +165,7 @@
 """
 
 DEFAULT_SIGNED_VALUE_MIN_VERSION = 1
-"""The oldest signed value accepted by `.RequestHandler.get_secure_cookie`.
+"""The oldest signed value accepted by `.RequestHandler.get_signed_cookie`.
 
 May be overridden by passing a ``min_version`` keyword argument.
 
@@ -204,7 +209,7 @@
         self,
         application: "Application",
         request: httputil.HTTPServerRequest,
-        **kwargs: Any
+        **kwargs: Any,
     ) -> None:
         super().__init__()
 
@@ -399,14 +404,10 @@
         # cases are covered by the first match for str.
         if isinstance(value, str):
             retval = value
-        elif isinstance(value, bytes):  # py3
+        elif isinstance(value, bytes):
             # Non-ascii characters in headers are not well supported,
             # but if you pass bytes, use latin1 so they pass through as-is.
             retval = value.decode("latin1")
-        elif isinstance(value, unicode_type):  # py2
-            # TODO: This is inconsistent with the use of latin1 above,
-            # but it's been that way for a long time. Should it change?
-            retval = escape.utf8(value)
         elif isinstance(value, numbers.Integral):
             # return immediately since we know the converted value will be safe
             return str(value)
@@ -601,21 +602,33 @@
         expires: OptionalUnionfloat, Tuple, datetime.datetime = None,
         path: str = "/",
         expires_days: Optionalfloat = None,
-        **kwargs: Any
+        # Keyword-only args start here for historical reasons.
+        *,
+        max_age: Optionalint = None,
+        httponly: bool = False,
+        secure: bool = False,
+        samesite: Optionalstr = None,
+        **kwargs: Any,
     ) -> None:
         """Sets an outgoing cookie name/value with the given options.
 
         Newly-set cookies are not immediately visible via `get_cookie`;
         they are not present until the next request.
 
-        expires may be a numeric timestamp as returned by `time.time`,
-        a time tuple as returned by `time.gmtime`, or a
-        `datetime.datetime` object.
+        Most arguments are passed directly to `http.cookies.Morsel` directly.
+        See https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Set-Cookie
+        for more information.
 
-        Additional keyword arguments are set on the cookies.Morsel
-        directly.
-        See https://docs.python.org/3/library/http.cookies.html#http.cookies.Morsel
-        for available attributes.
+        ``expires`` may be a numeric timestamp as returned by `time.time`,
+        a time tuple as returned by `time.gmtime`, or a
+        `datetime.datetime` object. ``expires_days`` is provided as a convenience
+        to set an expiration time in days from today (if both are set, ``expires``
+        is used).
+
+        .. deprecated:: 6.3
+           Keyword arguments are currently accepted case-insensitively.
+           In Tornado 7.0 this will be changed to only accept lowercase
+           arguments.
         """
         # The cookie library only accepts type str, in both python 2 and 3
         name = escape.native_str(name)
@@ -639,56 +652,93 @@
             morsel"expires" = httputil.format_timestamp(expires)
         if path:
             morsel"path" = path
-        for k, v in kwargs.items():
-            if k == "max_age":
-                k = "max-age"
-
-            # skip falsy values for httponly and secure flags because
-            # SimpleCookie sets them regardless
-            if k in "httponly", "secure" and not v:
-                continue
-
-            morselk = v
+        if max_age:
+            # Note change from _ to -.
+            morsel"max-age" = str(max_age)
+        if httponly:
+            # Note that SimpleCookie ignores the value here. The presense of an
+            # httponly (or secure) key is treated as true.
+            morsel"httponly" = True
+        if secure:
+            morsel"secure" = True
+        if samesite:
+            morsel"samesite" = samesite
+        if kwargs:
+            # The setitem interface is case-insensitive, so continue to support
+            # kwargs for backwards compatibility until we can remove deprecated
+            # features.
+            for k, v in kwargs.items():
+                morselk = v
+            warnings.warn(
+                f"Deprecated arguments to set_cookie: {set(kwargs.keys())} "
+                "(should be lowercase)",
+                DeprecationWarning,
+            )
 
-    def clear_cookie(
-        self, name: str, path: str = "/", domain: Optionalstr = None
-    ) -> None:
+    def clear_cookie(self, name: str, **kwargs: Any) -> None:
         """Deletes the cookie with the given name.
 
-        Due to limitations of the cookie protocol, you must pass the same
-        path and domain to clear a cookie as were used when that cookie
-        was set (but there is no way to find out on the server side
-        which values were used for a given cookie).
+        This method accepts the same arguments as `set_cookie`, except for
+        ``expires`` and ``max_age``. Clearing a cookie requires the same
+        ``domain`` and ``path`` arguments as when it was set. In some cases the
+        ``samesite`` and ``secure`` arguments are also required to match. Other
+        arguments are ignored.
 
         Similar to `set_cookie`, the effect of this method will not be
         seen until the following request.
-        """
+
+        .. versionchanged:: 6.3
+
+           Now accepts all keyword arguments that ``set_cookie`` does.
+           The ``samesite`` and ``secure`` flags have recently become
+           required for clearing ``samesite="none"`` cookies.
+        """
+        for excluded_arg in "expires", "max_age":
+            if excluded_arg in kwargs:
+                raise TypeError(
+                    f"clear_cookie() got an unexpected keyword argument '{excluded_arg}'"
+                )
         expires = datetime.datetime.utcnow() - datetime.timedelta(days=365)

_service:tar_scm:tornado-6.1.tar.gz/tornado/websocket.py -> _service:tar_scm:tornado-6.3.2.tar.gz/tornado/websocket.py Changed

@@ -1,16 +1,11 @@
 """Implementation of the WebSocket protocol.
 
 `WebSockets <http://dev.w3.org/html5/websockets/>`_ allow for bidirectional
-communication between the browser and server.
-
-WebSockets are supported in the current versions of all major browsers,
-although older versions that do not support WebSockets are still in use
-(refer to http://caniuse.com/websockets for details).
+communication between the browser and server. WebSockets are supported in the
+current versions of all major browsers.
 
 This module implements the final version of the WebSocket protocol as
-defined in `RFC 6455 <http://tools.ietf.org/html/rfc6455>`_.  Certain
-browser versions (notably Safari 5.x) implemented an earlier draft of
-the protocol (known as "draft 76") and are not compatible with this module.
+defined in `RFC 6455 <http://tools.ietf.org/html/rfc6455>`_.
 
 .. versionchanged:: 4.0
    Removed support for the draft 76 protocol version.
@@ -23,8 +18,7 @@
 import os
 import sys
 import struct
-import tornado.escape
-import tornado.web
+import tornado
 from urllib.parse import urlparse
 import zlib
 
@@ -34,6 +28,7 @@
 from tornado.ioloop import IOLoop, PeriodicCallback
 from tornado.iostream import StreamClosedError, IOStream
 from tornado.log import gen_log, app_log
+from tornado.netutil import Resolver
 from tornado import simple_httpclient
 from tornado.queues import Queue
 from tornado.tcpclient import TCPClient
@@ -225,7 +220,6 @@
         self.ws_connection = None  # type: OptionalWebSocketProtocol
         self.close_code = None  # type: Optionalint
         self.close_reason = None  # type: Optionalstr
-        self.stream = None  # type: OptionalIOStream
         self._on_close_called = False
 
     async def get(self, *args: Any, **kwargs: Any) -> None:
@@ -584,16 +578,6 @@
         if self.get_status() != 101 or self._on_close_called:
             super()._break_cycles()
 
-    def send_error(self, *args: Any, **kwargs: Any) -> None:
-        if self.stream is None:
-            super().send_error(*args, **kwargs)
-        else:
-            # If we get an uncaught exception during the handshake,
-            # we have no choice but to abruptly close the connection.
-            # TODO: for uncaught exceptions after the handshake,
-            # we can close the connection more gracefully.
-            self.stream.close()
-
     def get_websocket_protocol(self) -> Optional"WebSocketProtocol":
         websocket_version = self.request.headers.get("Sec-WebSocket-Version")
         if websocket_version in ("7", "8", "13"):
@@ -626,8 +610,7 @@
 
 
 class WebSocketProtocol(abc.ABC):
-    """Base class for WebSocket protocol versions.
-    """
+    """Base class for WebSocket protocol versions."""
 
     def __init__(self, handler: "_WebSocketDelegate") -> None:
         self.handler = handler
@@ -681,7 +664,7 @@
 
     @abc.abstractmethod
     def write_message(
-        self, message: Unionstr, bytes, binary: bool = False
+        self, message: Unionstr, bytes, Dictstr, Any, binary: bool = False
     ) -> "FutureNone":
         raise NotImplementedError()
 
@@ -834,7 +817,7 @@
         self._masked_frame = None
         self._frame_mask = None  # type: Optionalbytes
         self._frame_length = None
-        self._fragmented_message_buffer = None  # type: Optionalbytes
+        self._fragmented_message_buffer = None  # type: Optionalbytearray
         self._fragmented_message_opcode = None
         self._waiting = None  # type: object
         self._compression_options = params.compression_options
@@ -1073,13 +1056,15 @@
         return self.stream.write(frame)
 
     def write_message(
-        self, message: Unionstr, bytes, binary: bool = False
+        self, message: Unionstr, bytes, Dictstr, Any, binary: bool = False
     ) -> "FutureNone":
         """Sends the given message to the client of this Web Socket."""
         if binary:
             opcode = 0x2
         else:
             opcode = 0x1
+        if isinstance(message, dict):
+            message = tornado.escape.json_encode(message)
         message = tornado.escape.utf8(message)
         assert isinstance(message, bytes)
         self._message_bytes_out += len(message)
@@ -1187,10 +1172,10 @@
                 # nothing to continue
                 self._abort()
                 return
-            self._fragmented_message_buffer += data
+            self._fragmented_message_buffer.extend(data)
             if is_final_frame:
                 opcode = self._fragmented_message_opcode
-                data = self._fragmented_message_buffer
+                data = bytes(self._fragmented_message_buffer)
                 self._fragmented_message_buffer = None
         else:  # start of new data message
             if self._fragmented_message_buffer is not None:
@@ -1199,7 +1184,7 @@
                 return
             if not is_final_frame:
                 self._fragmented_message_opcode = opcode
-                self._fragmented_message_buffer = data
+                self._fragmented_message_buffer = bytearray(data)
 
         if is_final_frame:
             handled_future = self._handle_message(opcode, data)
@@ -1372,6 +1357,7 @@
         ping_timeout: Optionalfloat = None,
         max_message_size: int = _default_max_message_size,
         subprotocols: OptionalListstr = ,
+        resolver: OptionalResolver = None,
     ) -> None:
         self.connect_future = Future()  # type: FutureWebSocketClientConnection
         self.read_queue = Queue(1)  # type: QueueUnionNone, str, bytes
@@ -1412,7 +1398,7 @@
         # Websocket connection is currently unable to follow redirects
         request.follow_redirects = False
 
-        self.tcp_client = TCPClient()
+        self.tcp_client = TCPClient(resolver=resolver)
         super().__init__(
             None,
             request,
@@ -1494,7 +1480,7 @@
         future_set_result_unless_cancelled(self.connect_future, self)
 
     def write_message(
-        self, message: Unionstr, bytes, binary: bool = False
+        self, message: Unionstr, bytes, Dictstr, Any, binary: bool = False
     ) -> "FutureNone":
         """Sends a message to the WebSocket server.
 
@@ -1505,6 +1491,8 @@
            Exception raised on a closed stream changed from `.StreamClosedError`
            to `WebSocketClosedError`.
         """
+        if self.protocol is None:
+            raise WebSocketClosedError("Client connection has been closed")
         return self.protocol.write_message(message, binary=binary)
 
     def read_message(
@@ -1596,6 +1584,7 @@
     ping_timeout: Optionalfloat = None,
     max_message_size: int = _default_max_message_size,
     subprotocols: OptionalListstr = None,
+    resolver: OptionalResolver = None,
 ) -> "AwaitableWebSocketClientConnection":
     """Client-side websocket support.
 
@@ -1639,6 +1628,9 @@
 
     .. versionchanged:: 5.1
        Added the ``subprotocols`` argument.
+
+    .. versionchanged:: 6.3
+       Added the ``resolver`` argument.
     """
     if isinstance(url, httpclient.HTTPRequest):
         assert connect_timeout is None
@@ -1660,6 +1652,7 @@
         ping_timeout=ping_timeout,
         max_message_size=max_message_size,
         subprotocols=subprotocols,
+        resolver=resolver,
     )
     if callback is not None:
         IOLoop.current().add_future(conn.connect_future, callback)

_service:tar_scm:tornado-6.1.tar.gz/tornado/wsgi.py -> _service:tar_scm:tornado-6.3.2.tar.gz/tornado/wsgi.py Changed

@@ -27,12 +27,15 @@
 
 """
 
-import sys
+import concurrent.futures
 from io import BytesIO
 import tornado
+import sys
 
+from tornado.concurrent import dummy_executor
 from tornado import escape
 from tornado import httputil
+from tornado.ioloop import IOLoop
 from tornado.log import access_log
 
 from typing import List, Tuple, Optional, Callable, Any, Dict, Text
@@ -41,7 +44,7 @@
 
 if typing.TYPE_CHECKING:
     from typing import Type  # noqa: F401
-    from wsgiref.types import WSGIApplication as WSGIAppType  # noqa: F401
+    from _typeshed.wsgi import WSGIApplication as WSGIAppType  # noqa: F401
 
 
 # PEP 3333 specifies that WSGI on python 3 generally deals with byte strings
@@ -54,44 +57,83 @@
 
 
 class WSGIContainer(object):
-    r"""Makes a WSGI-compatible function runnable on Tornado's HTTP server.
+    r"""Makes a WSGI-compatible application runnable on Tornado's HTTP server.
 
     .. warning::
 
        WSGI is a *synchronous* interface, while Tornado's concurrency model
-       is based on single-threaded asynchronous execution.  This means that
-       running a WSGI app with Tornado's `WSGIContainer` is *less scalable*
-       than running the same app in a multi-threaded WSGI server like
-       ``gunicorn`` or ``uwsgi``.  Use `WSGIContainer` only when there are
-       benefits to combining Tornado and WSGI in the same process that
-       outweigh the reduced scalability.
+       is based on single-threaded *asynchronous* execution.  Many of Tornado's
+       distinguishing features are not available in WSGI mode, including efficient
+       long-polling and websockets. The primary purpose of `WSGIContainer` is
+       to support both WSGI applications and native Tornado ``RequestHandlers`` in
+       a single process. WSGI-only applications are likely to be better off
+       with a dedicated WSGI server such as ``gunicorn`` or ``uwsgi``.
+
+    Wrap a WSGI application in a `WSGIContainer` to make it implement the Tornado
+    `.HTTPServer` ``request_callback`` interface.  The `WSGIContainer` object can
+    then be passed to classes from the `tornado.routing` module,
+    `tornado.web.FallbackHandler`, or to `.HTTPServer` directly.
+
+    This class is intended to let other frameworks (Django, Flask, etc)
+    run on the Tornado HTTP server and I/O loop.
 
-    Wrap a WSGI function in a `WSGIContainer` and pass it to `.HTTPServer` to
-    run it. For example::
+    Realistic usage will be more complicated, but the simplest possible example uses a
+    hand-written WSGI application with `.HTTPServer`::
 
         def simple_app(environ, start_response):
             status = "200 OK"
             response_headers = ("Content-type", "text/plain")
             start_response(status, response_headers)
-            return "Hello world!\n"
+            return b"Hello world!\n"
 
-        container = tornado.wsgi.WSGIContainer(simple_app)
-        http_server = tornado.httpserver.HTTPServer(container)
-        http_server.listen(8888)
-        tornado.ioloop.IOLoop.current().start()
+        async def main():
+            container = tornado.wsgi.WSGIContainer(simple_app)
+            http_server = tornado.httpserver.HTTPServer(container)
+            http_server.listen(8888)
+            await asyncio.Event().wait()
 
-    This class is intended to let other frameworks (Django, web.py, etc)
-    run on the Tornado HTTP server and I/O loop.
+        asyncio.run(main())
+
+    The recommended pattern is to use the `tornado.routing` module to set up routing
+    rules between your WSGI application and, typically, a `tornado.web.Application`.
+    Alternatively, `tornado.web.Application` can be used as the top-level router
+    and `tornado.web.FallbackHandler` can embed a `WSGIContainer` within it.
+
+    If the ``executor`` argument is provided, the WSGI application will be executed
+    on that executor. This must be an instance of `concurrent.futures.Executor`,
+    typically a ``ThreadPoolExecutor`` (``ProcessPoolExecutor`` is not supported).
+    If no ``executor`` is given, the application will run on the event loop thread in
+    Tornado 6.3; this will change to use an internal thread pool by default in
+    Tornado 7.0.
 
-    The `tornado.web.FallbackHandler` class is often useful for mixing
-    Tornado and WSGI apps in the same server.  See
-    https://github.com/bdarnell/django-tornado-demo for a complete example.
+    .. warning::
+       By default, the WSGI application is executed on the event loop's thread. This
+       limits the server to one request at a time (per process), making it less scalable
+       than most other WSGI servers. It is therefore highly recommended that you pass
+       a ``ThreadPoolExecutor`` when constructing the `WSGIContainer`, after verifying
+       that your application is thread-safe. The default will change to use a
+       ``ThreadPoolExecutor`` in Tornado 7.0.
+
+    .. versionadded:: 6.3
+       The ``executor`` parameter.
+
+    .. deprecated:: 6.3
+       The default behavior of running the WSGI application on the event loop thread
+       is deprecated and will change in Tornado 7.0 to use a thread pool by default.
     """
 
-    def __init__(self, wsgi_application: "WSGIAppType") -> None:
+    def __init__(
+        self,
+        wsgi_application: "WSGIAppType",
+        executor: Optionalconcurrent.futures.Executor = None,
+    ) -> None:
         self.wsgi_application = wsgi_application
+        self.executor = dummy_executor if executor is None else executor
 
     def __call__(self, request: httputil.HTTPServerRequest) -> None:
+        IOLoop.current().spawn_callback(self.handle_request, request)
+
+    async def handle_request(self, request: httputil.HTTPServerRequest) -> None:
         data = {}  # type: Dictstr, Any
         response =   # type: Listbytes
 
@@ -110,15 +152,33 @@
             data"headers" = headers
             return response.append
 
-        app_response = self.wsgi_application(
-            WSGIContainer.environ(request), start_response
+        loop = IOLoop.current()
+        app_response = await loop.run_in_executor(
+            self.executor,
+            self.wsgi_application,
+            self.environ(request),
+            start_response,
         )
         try:
-            response.extend(app_response)
-            body = b"".join(response)
+            app_response_iter = iter(app_response)
+
+            def next_chunk() -> Optionalbytes:
+                try:
+                    return next(app_response_iter)
+                except StopIteration:
+                    # StopIteration is special and is not allowed to pass through
+                    # coroutines normally.
+                    return None
+
+            while True:
+                chunk = await loop.run_in_executor(self.executor, next_chunk)
+                if chunk is None:
+                    break
+                response.append(chunk)
         finally:
             if hasattr(app_response, "close"):
                 app_response.close()  # type: ignore
+        body = b"".join(response)
         if not data:
             raise Exception("WSGI app did not call start_response")
 
@@ -144,9 +204,11 @@
         request.connection.finish()
         self._log(status_code, request)
 
-    @staticmethod
-    def environ(request: httputil.HTTPServerRequest) -> DictText, Any:
+    def environ(self, request: httputil.HTTPServerRequest) -> DictText, Any:
         """Converts a `tornado.httputil.HTTPServerRequest` to a WSGI environment.
+
+        .. versionchanged:: 6.3
+           No longer a static method.
         """
         hostport = request.host.split(":")
         if len(hostport) == 2:
@@ -170,7 +232,7 @@
             "wsgi.url_scheme": request.protocol,
             "wsgi.input": BytesIO(escape.utf8(request.body)),
             "wsgi.errors": sys.stderr,
-            "wsgi.multithread": False,
+            "wsgi.multithread": self.executor is not dummy_executor,
             "wsgi.multiprocess": True,
             "wsgi.run_once": False,
         }
@@ -192,7 +254,14 @@
         request_time = 1000.0 * request.request_time()
         assert request.method is not None
         assert request.uri is not None
-        summary = request.method + " " + request.uri + " (" + request.remote_ip + ")"
+        summary = (
+            request.method  # type: ignoreoperator
+            + " "
+            + request.uri

Changes of Revision 10