NewYour coding agent can read the release notes before it upgrades.Set up the MCP server →
PyPI, #264 most downloaded on PyPI
Tornado is a Python web framework and asynchronous networking library, originally developed at FriendFeed.
Latest stable
6.6.1
Last release 5 days ago
09 Nov 2026
Release timing varies
gaps range from 2 weeks to 4 months
Nearly every release is documented
notes for 60 of the last 60 stable releases
Nothing withdrawn
no release was ever pulled
16 years old
91 releases · first in 2010
Drag across the ruler to compare, or tap a release to open it.
Nothing published for this version
This release fixes a path traversal vulnerability in .StaticFileHandler, in which files whose names *started with* the static_path directory but were…
This release fixes a path traversal vulnerability in .StaticFileHandler, in which files whose names started with the static_path directory but were not actually in that directory could be accessed.
The deprecated classes in the tornado.auth module, GoogleMixin, FacebookMixin, and FriendFeedMixin have been removed.
Your coding agent can read these notes before it upgrades. Set up the MCP server →
SSLIOStream.connect and .IOStream.start_tls now validate certificates by default.
Certificate validation will now use the system CA root certificates instead of certifi when possible (i.e. Python 2.7.9+ or 3.4+). This includes .IOStream and simple_httpclient, but not curl_httpclient.
The default SSL configuration has become stricter, using ssl.create_default_context where available on the client side. (On the server side, applications are encouraged to migrate from the ssl_options dict-based API to pass an ssl.SSLContext instead).
The deprecated classes in the tornado.auth module, GoogleMixin, FacebookMixin, and FriendFeedMixin have been removed.
These modules provide classes for coordinating coroutines, merged from Toro.
To port your code from Toro's queues to Tornado 4.2, import .Queue, .PriorityQueue, or .LifoQueue from tornado.queues instead of from toro.
Use .Queue instead of Toro's JoinableQueue. In Tornado the methods ~.Queue.join and ~.Queue.task_done are available on all queues, not on a special JoinableQueue.
Tornado queues raise exceptions specific to Tornado instead of reusing exceptions from the Python standard library. Therefore instead of catching the standard queue.Empty exception from .Queue.get_nowait, catch the special tornado.queues.QueueEmpty exception, and instead of catching the standard queue.Full from .Queue.get_nowait, catch tornado.queues.QueueFull.
To port from Toro's locks to Tornado 4.2, import .Condition, .Event, .Semaphore, .BoundedSemaphore, or .Lock from tornado.locks instead of from toro.
Toro's Semaphore.wait allowed a coroutine to wait for the semaphore to be unlocked without acquiring it. This encouraged unorthodox patterns; in Tornado, just use ~.Semaphore.acquire.
Toro's Event.wait raised a Timeout exception after a timeout. In Tornado, .Event.wait raises tornado.gen.TimeoutError.
Toro's Condition.wait also raised Timeout, but in Tornado, the .Future returned by .Condition.wait resolves to False after a timeout:
@gen.coroutine
def await_notification():
if not (yield condition.wait(timeout=timedelta(seconds=1))):
print('timed out')
else:
print('condition is true')
In lock and queue methods, wherever Toro accepted deadline as a keyword argument, Tornado names the argument timeout instead.
Toro's AsyncResult is not merged into Tornado, nor its exceptions NotReady and AlreadySet. Use a .Future instead. If you wrote code like this:
from tornado import gen
import toro
result = toro.AsyncResult()
@gen.coroutine
def setter():
result.set(1)
@gen.coroutine
def getter():
value = yield result.get()
print(value) # Prints "1".
Then the Tornado equivalent is:
from tornado import gen
from tornado.concurrent import Future
result = Future()
@gen.coroutine
def setter():
result.set_result(1)
@gen.coroutine
def getter():
value = yield result
print(value) # Prints "1".
Improved compatibility with Windows.
Fixed a bug in Python 3 if a module was imported during a reload check.
.run_on_executor now accepts arguments to control which attributes it uses to find the .IOLoop and executor.
Fixed a bug that would cause the client to stop processing requests if an exception occurred in certain places while there is a queue.
.xhtml_escape now supports numeric character references in hex format ( )
.WaitIterator no longer uses weak references, which fixes several garbage-collection-related bugs.
tornado.gen.Multi and tornado.gen.multi_future (which are used when yielding a list or dict in a coroutine) now log any exceptions after the first if more than one .Future fails (previously they would be logged when the .Future was garbage-collected, but this is more reliable). Both have a new keyword argument quiet_exceptions to suppress logging of certain exception types; to use this argument you must call Multi or multi_future directly instead of simply yielding a list.
.multi_future now works when given multiple copies of the same .Future.
On Python 3, catching an exception in a coroutine no longer leads to leaks via Exception.__context__.
The raise_error argument now works correctly with the synchronous .HTTPClient.
The synchronous .HTTPClient no longer interferes with .IOLoop.current().
.HTTPServer is now a subclass of tornado.util.Configurable.
.HTTPHeaders can now be copied with copy.copy and copy.deepcopy.
The .IOLoop constructor now has a make_current keyword argument to control whether the new .IOLoop becomes .IOLoop.current().
Third-party implementations of .IOLoop should accept **kwargs in their IOLoop.initialize methods and pass them to the superclass implementation.
.PeriodicCallback is now more efficient when the clock jumps forward by a large amount.
SSLIOStream.connect and .IOStream.start_tls now validate certificates by default.
New method .SSLIOStream.wait_for_handshake allows server-side applications to wait for the handshake to complete in order to verify client certificates or use NPN/ALPN.
The .Future returned by SSLIOStream.connect now resolves after the handshake is complete instead of as soon as the TCP connection is established.
Reduced logging of SSL errors.
.BaseIOStream.read_until_close now works correctly when a streaming_callback is given but callback is None (i.e. when it returns a .Future)
New method .GettextLocale.pgettext allows additional context to be supplied for gettext translations.
.define_logging_options now works correctly when given a non-default options object.
New method .Subprocess.wait_for_exit is a coroutine-friendly version of .Subprocess.set_exit_callback.
Improved performance on Python 3 by reusing a single ssl.SSLContext.
New constructor argument max_body_size controls the maximum response size the client is willing to accept. It may be bigger than max_buffer_size if streaming_callback is used.
.TCPServer.handle_stream may be a coroutine (so that any exceptions it raises will be logged).
.import_object now supports unicode strings on Python 2.
.Configurable.initialize now supports positional arguments.
Key versioning support for cookie signing. cookie_secret application setting can now contain a dict of valid keys with version as key. The current signing key then must be specified via key_version setting.
Parsing of the If-None-Match header now follows the RFC and supports weak validators.
Passing secure=False or httponly=False to .RequestHandler.set_cookie now works as expected (previously only the presence of the argument was considered and its value was ignored).
.RequestHandler.get_arguments now requires that its strip argument be of type bool. This helps prevent errors caused by the slightly dissimilar interfaces between the singular and plural methods.
Errors raised in _handle_request_exception are now logged more reliably.
.RequestHandler.redirect now works correctly when called from a handler whose path begins with two slashes.
Passing messages containing % characters to tornado.web.HTTPError no longer causes broken error messages.
The on_close method will no longer be called more than once.
When the other side closes a connection, we now echo the received close code back instead of sending an empty close frame.
Nothing published for this version
If a .Future contains an exception but that exception is never examined or re-raised (e.g. by yielding the .Future), a stack trace will be logged when
If a .Future contains an exception but that exception is never examined or re-raised (e.g. by yielding the .Future), a stack trace will be logged when the .Future is garbage-collected.
New class tornado.gen.WaitIterator provides a way to iterate over Futures in the order they resolve.
The tornado.websocket module now supports compression via the "permessage-deflate" extension. Override .WebSocketHandler.get_compression_options to enable on the server side, and use the compression_options keyword argument to .websocket_connect on the client side.
When the appropriate packages are installed, it is possible to yield asyncio.Future or Twisted Defered objects in Tornado coroutines.
.HTTPServer now calls start_request with the correct arguments. This change is backwards-incompatible, affecting any application which implemented .HTTPServerConnectionDelegate by following the example of .Application instead of the documented method signatures.
If a .Future contains an exception but that exception is never examined or re-raised (e.g. by yielding the .Future), a stack trace will be logged when the .Future is garbage-collected.
.Future now catches and logs exceptions in its callbacks.
tornado.curl_httpclient now supports request bodies for PATCH and custom methods.
tornado.curl_httpclient now supports resubmitting bodies after following redirects for methods other than POST.
curl_httpclient now runs the streaming and header callbacks on the IOLoop.
tornado.curl_httpclient now uses its own logger for debug output so it can be filtered more easily.
New class tornado.gen.WaitIterator provides a way to iterate over Futures in the order they resolve.
When the ~functools.singledispatch library is available (standard on Python 3.4, available via pip install singledispatch on older versions), the .convert_yielded function can be used to make other kinds of objects yieldable in coroutines.
New function tornado.gen.sleep is a coroutine-friendly analogue to time.sleep.
gen.engine now correctly captures the stack context for its callbacks.
tornado.httpclient.HTTPRequest accepts a new argument raise_error=False to suppress the default behavior of raising an error for non-200 response codes.
.HTTPServer now calls start_request with the correct arguments. This change is backwards-incompatible, afffecting any application which implemented .HTTPServerConnectionDelegate by following the example of .Application instead of the documented method signatures.
.HTTPServer now tolerates extra newlines which are sometimes inserted between requests on keep-alive connections.
.HTTPServer can now use keep-alive connections after a request with a chunked body.
.HTTPServer now always reports HTTP/1.1 instead of echoing the request version.
New function tornado.httputil.split_host_and_port for parsing the netloc portion of URLs.
The context argument to .HTTPServerRequest is now optional, and if a context is supplied the remote_ip attribute is also optional.
.HTTPServerRequest.body is now always a byte string (previously the default empty body would be a unicode string on python 3).
Header parsing now works correctly when newline-like unicode characters are present.
Header parsing again supports both CRLF and bare LF line separators.
Malformed multipart/form-data bodies will always be logged quietly instead of raising an unhandled exception; previously the behavior was inconsistent depending on the exact error.
The kqueue and select IOLoop implementations now report writeability correctly, fixing flow control in IOStream.
When a new .IOLoop is created, it automatically becomes "current" for the thread if there is not already a current instance.
New method .PeriodicCallback.is_running can be used to see whether the .PeriodicCallback has been started.
.IOStream.start_tls now uses the server_hostname parameter for certificate validation.
.SSLIOStream will no longer consume 100% CPU after certain error conditions.
.SSLIOStream no longer logs EBADF errors during the handshake as they can result from nmap scans in certain modes.
~tornado.options.parse_config_file now always decodes the config file as utf8 on Python 3.
tornado.options.define more accurately finds the module defining the option.
It is now possible to yield asyncio.Future objects in coroutines when the ~functools.singledispatch library is available and tornado.platform.asyncio has been imported.
New methods tornado.platform.asyncio.to_tornado_future and ~tornado.platform.asyncio.to_asyncio_future convert between the two libraries' .Future classes.
It is now possible to yield Deferred objects in coroutines when the ~functools.singledispatch library is available and tornado.platform.twisted has been imported.
.TCPClient will no longer raise an exception due to an ill-timed timeout.
.TCPServer no longer ignores its read_chunk_size argument.
.AsyncTestCase has better support for multiple exceptions. Previously it would silently swallow all but the last; now it raises the first and logs all the rest.
.AsyncTestCase now cleans up .Subprocess state on tearDown when necessary.
The asynchronous decorator now understands concurrent.futures.Future in addition to tornado.concurrent.Future.
.StaticFileHandler no longer logs a stack trace if the connection is closed while sending the file.
.RequestHandler.send_error now supports a reason keyword argument, similar to tornado.web.HTTPError.
.RequestHandler.locale now has a property setter.
.Application.add_handlers hostname matching now works correctly with IPv6 literals.
Redirects for the .Application default_host setting now match the request protocol instead of redirecting HTTPS to HTTP.
Malformed _xsrf cookies are now ignored instead of causing uncaught exceptions.
Application.start_request now has the same signature as .HTTPServerConnectionDelegate.start_request.
The tornado.websocket module now supports compression via the "permessage-deflate" extension. Override .WebSocketHandler.get_compression_options to enable on the server side, and use the compression_options keyword argument to .websocket_connect on the client side.
.WebSocketHandler no longer logs stack traces when the connection is closed.
.WebSocketHandler.open now accepts *args, **kw for consistency with RequestHandler.get and related methods.
The Sec-WebSocket-Version header now includes all supported versions.
.websocket_connect now has a on_message_callback keyword argument for callback-style use without read_message().
Nothing published for this version
Fixed a bug that could sometimes cause a timeout to fire after being cancelled.
Fixed a bug that could sometimes cause a timeout to fire after being cancelled.
.AsyncTestCase once again passes along arguments to test methods, making it compatible with extensions such as Nose's test generators.
.StaticFileHandler can again compress its responses when gzip is enabled.
simple_httpclient passes its max_buffer_size argument to the underlying stream.
Fixed a reference cycle that can lead to increased memory consumption.
.add_accept_handler will now limit the number of times it will call ~socket.socket.accept per .IOLoop iteration, addressing a potential starvation issue.
Improved error handling in .IOStream.connect (primarily for FreeBSD systems)
The build will now fall back to pure-python mode if the C extension fails to build for any reason (previously it would fall back for some errors but n
The build will now fall back to pure-python mode if the C extension fails to build for any reason (previously it would fall back for some errors but not others).
.IOLoop.call_at and .IOLoop.call_later now always return a timeout handle for use with .IOLoop.remove_timeout.
If any callback of a .PeriodicCallback or .IOStream returns a .Future, any error raised in that future will now be logged (similar to the behavior of .IOLoop.add_callback).
Fixed an exception in client-side websocket connections when the connection is closed.
simple_httpclient once again correctly handles 204 status codes with no content-length header.
Fixed a regression in simple_httpclient that would result in timeouts for certain kinds of errors.
The HTTPServerRequest.write and HTTPServerRequest.finish methods are now deprecated. (.RequestHandler.write and .RequestHandler.finish are *not* depre…
The tornado.web.stream_request_body decorator allows large files to be uploaded with limited memory usage.
Coroutines are now faster and are used extensively throughout Tornado itself. More methods now return Futures <.Future>, including most .IOStream methods and .RequestHandler.flush.
Many user-overridden methods are now allowed to return a .Future for flow control.
HTTP-related code is now shared between the tornado.httpserver, tornado.simple_httpclient and tornado.wsgi modules, making support for features such as chunked and gzip encoding more consistent. .HTTPServer now uses new delegate interfaces defined in tornado.httputil in addition to its old single-callback interface.
New module tornado.tcpclient creates TCP connections with non-blocking DNS, SSL handshaking, and support for IPv6.
tornado.concurrent.Future is no longer thread-safe; use concurrent.futures.Future when thread-safety is needed.
Tornado now depends on the certifi package instead of bundling its own copy of the Mozilla CA list. This will be installed automatically when using pip or easy_install.
This version includes the changes to the secure cookie format first introduced in version 3.2.1, and the xsrf token change in version 3.2.2. If you are upgrading from an earlier version, see those versions' release notes.
WebSocket connections from other origin sites are now rejected by default. To accept cross-origin websocket connections, override the new method WebSocketHandler.check_origin.
.WebSocketHandler no longer supports the old draft 76 protocol (this mainly affects Safari 5.x browsers). Applications should use non-websocket workarounds for these browsers.
Authors of alternative .IOLoop implementations should see the changes to .IOLoop.add_handler in this release.
The RequestHandler.async_callback and WebSocketHandler.async_callback wrapper functions have been removed; they have been obsolete for a long time due to stack contexts (and more recently coroutines).
curl_httpclient now requires a minimum of libcurl version 7.21.1 and pycurl 7.18.2.
Support for RequestHandler.get_error_html has been removed; override .RequestHandler.write_error instead.
The git repository has moved to https://github.com/tornadoweb/tornado. All old links should be redirected to the new location.
An announcement mailing list is now available.
All Tornado modules are now importable on Google App Engine (although the App Engine environment does not allow the system calls used by .IOLoop so many modules are still unusable).
Fixed a bug in .FacebookMixin on Python 3.
When using the .Future interface, exceptions are more reliably delivered to the caller.
tornado.concurrent.Future is now always thread-unsafe (previously it would be thread-safe if the concurrent.futures package was available). This improves performance and provides more consistent semantics. The parts of Tornado that accept Futures will accept both Tornado's thread-unsafe Futures and the thread-safe concurrent.futures.Future.
tornado.concurrent.Future now includes all the functionality of the old TracebackFuture class. TracebackFuture is now simply an alias for Future.
curl_httpclient now passes along the HTTP "reason" string in response.reason.
Performance of coroutines has been improved.
Coroutines no longer generate StackContexts by default, but they will be created on demand when needed.
The internals of the tornado.gen module have been rewritten to improve performance when using Futures, at the expense of some performance degradation for the older YieldPoint interfaces.
New function .with_timeout wraps a .Future and raises an exception if it doesn't complete in a given amount of time.
New object .moment can be yielded to allow the IOLoop to run for one iteration before resuming.
Task is now a function returning a .Future instead of a YieldPoint subclass. This change should be transparent to application code, but allows Task to take advantage of the newly-optimized .Future handling.
New module contains the HTTP implementation shared by tornado.httpserver and tornado.simple_httpclient.
The command-line HTTP client (python -m tornado.httpclient $URL) now works on Python 3.
Fixed a memory leak in .AsyncHTTPClient shutdown that affected applications that created many HTTP clients and IOLoops.
New client request parameter decompress_response replaces the existing use_gzip parameter; both names are accepted.
tornado.httpserver.HTTPRequest has moved to tornado.httputil.HTTPServerRequest.
HTTP implementation has been unified with tornado.simple_httpclient in tornado.http1connection.
Now supports Transfer-Encoding: chunked for request bodies.
Now supports Content-Encoding: gzip for request bodies if decompress_request=True is passed to the .HTTPServer constructor.
The connection attribute of .HTTPServerRequest is now documented for public use; applications are expected to write their responses via the .HTTPConnection interface.
The HTTPServerRequest.write and HTTPServerRequest.finish methods are now deprecated. (.RequestHandler.write and .RequestHandler.finish are not deprecated; this only applies to the methods on .HTTPServerRequest)
.HTTPServer now supports .HTTPServerConnectionDelegate in addition to the old request_callback interface. The delegate interface supports streaming of request bodies.
.HTTPServer now detects the error of an application sending a Content-Length error that is inconsistent with the actual content.
New constructor arguments max_header_size and max_body_size allow separate limits to be set for different parts of the request. max_body_size is applied even in streaming mode.
New constructor argument chunk_size can be used to limit the amount of data read into memory at one time per request.
New constructor arguments idle_connection_timeout and body_timeout allow time limits to be placed on the reading of requests.
Form-encoded message bodies are now parsed for all HTTP methods, not just POST, PUT, and PATCH.
.HTTPServerRequest was moved to this module from tornado.httpserver.
New base classes .HTTPConnection, .HTTPServerConnectionDelegate, and .HTTPMessageDelegate define the interaction between applications and the HTTP implementation.
.IOLoop.add_handler and related methods now accept file-like objects in addition to raw file descriptors. Passing the objects is recommended (when possible) to avoid a garbage-collection-related problem in unit tests.
New method .IOLoop.clear_instance makes it possible to uninstall the singleton instance.
Timeout scheduling is now more robust against slow callbacks.
.IOLoop.add_timeout is now a bit more efficient.
When a function run by the .IOLoop returns a .Future and that .Future has an exception, the .IOLoop will log the exception.
New method .IOLoop.spawn_callback simplifies the process of launching a fire-and-forget callback that is separated from the caller's stack context.
New methods .IOLoop.call_later and .IOLoop.call_at simplify the specification of relative or absolute timeouts (as opposed to ~.IOLoop.add_timeout, which used the type of its argument).
The callback argument to most .IOStream methods is now optional. When called without a callback the method will return a .Future for use with coroutines.
New method .IOStream.start_tls converts an .IOStream to an .SSLIOStream.
No longer gets confused when an IOError or OSError without an errno attribute is raised.
.BaseIOStream.read_bytes now accepts a partial keyword argument, which can be used to return before the full amount has been read. This is a more coroutine-friendly alternative to streaming_callback.
.BaseIOStream.read_until and read_until_regex now acept a max_bytes keyword argument which will cause the request to fail if it cannot be satisfied from the given number of bytes.
.IOStream no longer reads from the socket into memory if it does not need data to satisfy a pending read. As a side effect, the close callback will not be run immediately if the other side closes the connection while there is unconsumed data in the buffer.
The default chunk_size has been increased to 64KB (from 4KB)
The .IOStream constructor takes a new keyword argument max_write_buffer_size (defaults to unlimited). Calls to .BaseIOStream.write will raise .StreamBufferFullError if the amount of unsent buffered data exceeds this limit.
ETIMEDOUT errors are no longer logged. If you need to distinguish timeouts from other forms of closed connections, examine stream.error from a close callback.
When .bind_sockets chooses a port automatically, it will now use the same port for IPv4 and IPv6.
TLS compression is now disabled by default on Python 3.3 and higher (it is not possible to change this option in older versions).
It is now possible to disable the default logging configuration by setting options.logging to None instead of the string "none".
Now works on Python 2.6.
Now works with Trollius version 0.3.
TwistedIOLoop now works on Python 3.3+ (with Twisted 14.0.0+).
simple_httpclient has better support for IPv6, which is now enabled by default.
Improved default cipher suite selection (Python 2.7+).
HTTP implementation has been unified with tornado.httpserver in tornado.http1connection
Streaming request bodies are now supported via the body_producer keyword argument to tornado.httpclient.HTTPRequest.
The expect_100_continue keyword argument to tornado.httpclient.HTTPRequest allows the use of the HTTP Expect: 100-continue feature.
simple_httpclient now raises the original exception (e.g. an IOError) in more cases, instead of converting everything to HTTPError.
The stack context system now has less performance overhead when no stack contexts are active.
New module which creates TCP connections and IOStreams, including name resolution, connecting, and SSL handshakes.
.AsyncTestCase now attempts to detect test methods that are generators but were not run with @gen_test or any similar decorator (this would previously result in the test silently being skipped).
Better stack traces are now displayed when a test times out.
The @gen_test decorator now passes along *args, **kwargs so it can be used on functions with arguments.
Fixed the test suite when unittest2 is installed on Python 3.
It is now possible to support streaming request bodies with the .stream_request_body decorator and the new .RequestHandler.data_received method.
.RequestHandler.flush now returns a .Future if no callback is given.
New exception .Finish may be raised to finish a request without triggering error handling.
When gzip support is enabled, all text/* mime types will be compressed, not just those on a whitelist.
.Application now implements the .HTTPMessageDelegate interface.
HEAD requests in .StaticFileHandler no longer read the entire file.
.StaticFileHandler now streams response bodies to the client.
New setting compress_response replaces the existing gzip setting; both names are accepted.
XSRF cookies that were not generated by this module (i.e. strings without any particular formatting) are once again accepted (as long as the cookie and body/header match). This pattern was common for testing and non-browser clients but was broken by the changes in Tornado 3.2.2.
WebSocket connections from other origin sites are now rejected by default. Browsers do not use the same-origin policy for WebSocket connections as they do for most other browser-initiated communications. This can be surprising and a security risk, so we disallow these connections on the server side by default. To accept cross-origin websocket connections, override the new method WebSocketHandler.check_origin.
.WebSocketHandler.close and .WebSocketClientConnection.close now support code and reason arguments to send a status code and message to the other side of the connection when closing. Both classes also have close_code and close_reason attributes to receive these values when the other side closes.
The C speedup module now builds correctly with MSVC, and can support messages larger than 2GB on 64-bit systems.
The fallback mechanism for detecting a missing C compiler now works correctly on Mac OS X.
Arguments to .WebSocketHandler.open are now decoded in the same way as arguments to .RequestHandler.get and similar methods.
It is now allowed to override prepare in a .WebSocketHandler, and this method may generate HTTP responses (error pages) in the usual way. The HTTP response methods are still not allowed once the WebSocket handshake has completed.
New class WSGIAdapter supports running a Tornado .Application on a WSGI server in a way that is more compatible with Tornado's non-WSGI .HTTPServer. WSGIApplication is deprecated in favor of using WSGIAdapter with a regular .Application.
WSGIAdapter now supports gzipped output.
This makes it safe to include in compressed pages without being vulnerable to the BREACH attack _. This applies to most applications that use both the…
The XSRF token is now encoded with a random mask on each request. This makes it safe to include in compressed pages without being vulnerable to the BREACH attack. This applies to most applications that use both the xsrf_cookies and gzip options (or have gzip applied by a proxy).
If Tornado 3.2.2 is run at the same time as older versions on the same domain, there is some potential for issues with the differing cookie versions. The .Application setting xsrf_cookie_version=1 can be used for a transitional period to generate the older cookie format on newer servers.
tornado.platform.asyncio is now compatible with trollius version 0.3.
The new cookie format fixes a vulnerability that may be present in applications that use multiple cookies where the name of one cookie is a prefix of…
The signed-value format used by .RequestHandler.set_secure_cookie and .RequestHandler.get_secure_cookie has changed to be more secure. This is a disruptive change. The secure_cookie functions take new version parameters to support transitions between cookie formats.
The new cookie format fixes a vulnerability that may be present in applications that use multiple cookies where the name of one cookie is a prefix of the name of another.
To minimize disruption, cookies in the older format will be accepted by default until they expire. Applications that may be vulnerable can reject all cookies in the older format by passing min_version=2 to .RequestHandler.get_secure_cookie.
Thanks to Joost Pol of Certified Secure for reporting this issue.
Signed cookies issued by .RequestHandler.set_secure_cookie in Tornado 3.2.1 cannot be read by older releases. If you need to run 3.2.1 in parallel with older releases, you can pass version=1 to .RequestHandler.set_secure_cookie to issue cookies that are backwards-compatible (but have a known weakness, so this option should only be used for a transitional period).
The C extension used to speed up the websocket module now compiles correctly on Windows with MSVC and 64-bit mode. The fallback to the pure-Python alternative now works correctly on Mac OS X machines with no C compiler installed.
Tornado now depends on the backports.ssl_match_hostname _ when running on Python 2. This will be installed automatically when using pip or easy_instal
Tornado now depends on the backports.ssl_match_hostname when running on Python 2. This will be installed automatically when using pip or easy_install
Tornado now includes an optional C extension module, which greatly improves performance of websockets. This extension will be built automatically if a C compiler is found at install time.
The tornado.platform.asyncio module provides integration with the asyncio module introduced in Python 3.4 (also available for Python 3.3 with pip install asyncio).
Added .GoogleOAuth2Mixin support authentication to Google services with OAuth 2 instead of OpenID and OAuth 1.
.FacebookGraphMixin has been updated to use the current Facebook login URL, which saves a redirect.
TracebackFuture now accepts a timeout keyword argument (although it is still incorrect to use a non-zero timeout in non-blocking code).
tornado.curl_httpclient now works on Python 3 with the soon-to-be-released pycurl 7.19.3, which will officially support Python 3 for the first time. Note that there are some unofficial Python 3 ports of pycurl (Ubuntu has included one for its past several releases); these are not supported for use with Tornado.
.xhtml_escape now escapes apostrophes as well.
tornado.escape.utf8, .to_unicode, and .native_str now raise TypeError instead of AssertionError when given an invalid value.
Coroutines may now yield dicts in addition to lists to wait for multiple tasks in parallel.
Improved performance of tornado.gen when yielding a .Future that is already done.
tornado.httpclient.HTTPRequest now uses property setters so that setting attributes after construction applies the same conversions as __init__ (e.g. converting the body attribute to bytes).
Malformed x-www-form-urlencoded request bodies will now log a warning and continue instead of causing the request to fail (similar to the existing handling of malformed multipart/form-data bodies. This is done mainly because some libraries send this content type by default even when the data is not form-encoded.
Fix some error messages for unix sockets (and other non-IP sockets)
.IOLoop now uses IOLoop.handle_callback_exception consistently for error logging.
.IOLoop now frees callback objects earlier, reducing memory usage while idle.
.IOLoop will no longer call logging.basicConfig if there is a handler defined for the root logger or for the tornado or tornado.application loggers (previously it only looked at the root logger).
.IOStream now recognizes ECONNABORTED error codes in more places (which was mainly an issue on Windows).
.IOStream now frees memory earlier if a connection is closed while there is data in the write buffer.
.PipeIOStream now handles EAGAIN error codes correctly.
.SSLIOStream now initiates the SSL handshake automatically without waiting for the application to try and read or write to the connection.
Swallow a spurious exception from set_nodelay when a connection has been reset.
.Locale.format_date no longer forces the use of absolute dates in Russian.
Fix an error from tornado.log.enable_pretty_logging when sys.stderr does not have an isatty method.
tornado.log.LogFormatter now accepts keyword arguments fmt and datefmt.
.is_valid_ip (and therefore HTTPRequest.remote_ip) now rejects empty strings.
Synchronously using .ThreadedResolver at import time to resolve a unicode hostname no longer deadlocks.
.TwistedResolver` now has better error handling.
.Subprocess no longer leaks file descriptors if subprocess.Popen fails.
simple_httpclient now applies the connect_timeout to requests that are queued and have not yet started.
On Python 2.6, simple_httpclient now uses TLSv1 instead of SSLv3.
simple_httpclient now enforces the connect timeout during DNS resolution.
The embedded ca-certificates.crt file has been updated with the current Mozilla CA list.
.StaticFileHandler no longer fails if the client requests a Range that is larger than the entire file (Facebook has a crawler that does this).
.RequestHandler.on_connection_close now works correctly on subsequent requests of a keep-alive connection.
New application setting default_handler_class can be used to easily set up custom 404 pages.
New application settings autoreload, compiled_template_cache, static_hash_cache, and serve_traceback can be used to control individual aspects of debug mode.
New methods .RequestHandler.get_query_argument and .RequestHandler.get_body_argument and new attributes HTTPRequest.query_arguments and HTTPRequest.body_arguments allow access to arguments without intermingling those from the query string with those from the request body.
.RequestHandler.decode_argument and related methods now raise an HTTPError(400) instead of UnicodeDecodeError when the argument could not be decoded.
.RequestHandler.clear_all_cookies now accepts domain and path arguments, just like ~.RequestHandler.clear_cookie.
It is now possible to specify handlers by name when using the tornado.web.URLSpec class.
.Application now accepts 4-tuples to specify the name parameter (which previously required constructing a tornado.web.URLSpec object instead of a tuple).
Fixed an incorrect error message when handler methods return a value other than None or a Future.
Exceptions will no longer be logged twice when using both @asynchronous and @gen.coroutine
.WebSocketHandler.write_message now raises .WebSocketClosedError instead of AttributeError when the connection has been closed.
.websocket_connect now accepts preconstructed HTTPRequest objects.
Fix a bug with .WebSocketHandler when used with some proxies that unconditionally modify the Connection header.
.websocket_connect now returns an error immediately for refused connections instead of waiting for the timeout.
.WebSocketClientConnection now has a close method.
.WSGIContainer now calls the iterable's close() method even if an error is raised, in compliance with the spec.
.StaticFileHandler no longer fails if the client requests a Range that is larger than the entire file (Facebook has a crawler that does this).
.StaticFileHandler no longer fails if the client requests a Range that is larger than the entire file (Facebook has a crawler that does this).
.RequestHandler.on_connection_close now works correctly on subsequent requests of a keep-alive connection.
Multiple modules ~~~~~~~~~~~~~~~~
Many reference cycles have been broken up throughout the package, allowing for more efficient garbage collection on CPython.
Silenced some log messages when connections are opened and immediately closed (i.e. port scans), or other situations related to closed connections.
Various small speedups: .HTTPHeaders case normalization, .UIModule proxy objects, precompile some regexes.
~tornado.auth.OAuthMixin always sends oauth_version=1.0 in its request as required by the spec.
~tornado.auth.FacebookGraphMixin now uses self._FACEBOOK_BASE_URL in ~.FacebookGraphMixin.facebook_request to allow the base url to be overridden.
The authenticate_redirect and authorize_redirect methods in the tornado.auth mixin classes all now return Futures. These methods are asynchronous in .OAuthMixin and derived classes, although they do not take a callback. The .Future these methods return must be yielded if they are called from a function decorated with .gen.coroutine (but not gen.engine).
.TwitterMixin now uses /account/verify_credentials to get information about the logged-in user, which is more robust against changing screen names.
The demos directory (in the source distribution) has a new twitter demo using .TwitterMixin.
.url_escape and .url_unescape have a new plus argument (defaulting to True for consistency with the previous behavior) which specifies whether they work like urllib.parse.unquote or urllib.parse.unquote_plus.
Fixed a potential memory leak with long chains of tornado.gen coroutines.
tornado.httpclient.HTTPRequest takes a new argument auth_mode, which can be either basic or digest. Digest authentication is only supported with tornado.curl_httpclient.
tornado.curl_httpclient no longer goes into an infinite loop when pycurl returns a negative timeout.
curl_httpclient now supports the PATCH and OPTIONS methods without the use of allow_nonstandard_methods=True.
Worked around a class of bugs in libcurl that would result in errors from .IOLoop.update_handler in various scenarios including digest authentication and socks proxies.
The TCP_NODELAY flag is now set when appropriate in simple_httpclient.
simple_httpclient no longer logs exceptions, since those exceptions are made available to the caller as HTTPResponse.error.
tornado.httpserver.HTTPServer handles malformed HTTP headers more gracefully.
.HTTPServer now supports lists of IPs in X-Forwarded-For (it chooses the last, i.e. nearest one).
Memory is now reclaimed promptly on CPython when an HTTP request fails because it exceeded the maximum upload size.
The TCP_NODELAY flag is now set when appropriate in .HTTPServer.
The .HTTPServer no_keep_alive option is now respected with HTTP 1.0 connections that explicitly pass Connection: keep-alive.
The Connection: keep-alive check for HTTP 1.0 connections is now case-insensitive.
The str and repr of tornado.httpserver.HTTPRequest no longer include the request body, reducing log spam on errors (and potential exposure/retention of private data).
The cache used in .HTTPHeaders will no longer grow without bound.
Some .IOLoop implementations (such as pyzmq) accept objects other than integer file descriptors; these objects will now have their .close() method called when the IOLoop` is closed with ``all_fds=True.
The stub handles left behind by .IOLoop.remove_timeout will now get cleaned up instead of waiting to expire.
Fixed a bug in .BaseIOStream.read_until_close that would sometimes cause data to be passed to the final callback instead of the streaming callback.
The .IOStream close callback is now run more reliably if there is an exception in _try_inline_read.
New method .BaseIOStream.set_nodelay can be used to set the TCP_NODELAY flag.
Fixed a case where errors in SSLIOStream.connect (and SimpleAsyncHTTPClient) were not being reported correctly.
.Locale.format_date now works on Python 3.
The default .Resolver implementation now works on Solaris.
.Resolver now has a ~.Resolver.close method.
Fixed a potential CPU DoS when tornado.netutil.ssl_match_hostname is used on certificates with an abusive wildcard pattern.
All instances of .ThreadedResolver now share a single thread pool, whose size is set by the first one to be created (or the static Resolver.configure method).
.ExecutorResolver is now documented for public use.
.bind_sockets now works in configurations with incomplete IPv6 support.
tornado.options.define with multiple=True now works on Python 3.
tornado.options.options and other .OptionParser instances support some new dict-like methods: ~.OptionParser.items(), iteration over keys, and (read-only) access to options with square braket syntax. .OptionParser.group_dict returns all options with a given group name, and .OptionParser.as_dict returns all options.
tornado.process.Subprocess no longer leaks file descriptors into the child process, which fixes a problem in which the child could not detect that the parent process had closed its stdin pipe.
.Subprocess.set_exit_callback now works for subprocesses created without an explicit io_loop parameter.
tornado.stack_context has been rewritten and is now much faster.
New function run_with_stack_context facilitates the use of stack contexts with coroutines.
The constructors of .TCPServer and .HTTPServer now take a max_buffer_size keyword argument.
Some internal names used by the template system have been changed; now all "reserved" names in templates start with _tt_.
tornado.testing.AsyncTestCase.wait now raises the correct exception when it has been modified by tornado.stack_context.
tornado.testing.gen_test can now be called as @gen_test(timeout=60) to give some tests a longer timeout than others.
The environment variable ASYNC_TEST_TIMEOUT can now be set to override the default timeout for .AsyncTestCase.wait and .gen_test.
.bind_unused_port now passes None instead of 0 as the port to getaddrinfo, which works better with some unusual network configurations.
tornado.util.import_object now works with top-level module names that do not contain a dot.
tornado.util.import_object now consistently raises ImportError instead of AttributeError when it fails.
The handlers list passed to the tornado.web.Application constructor and ~tornado.web.Application.add_handlers methods can now contain lists in addition to tuples and ~tornado.web.URLSpec objects.
tornado.web.StaticFileHandler now works on Windows when the client passes an If-Modified-Since timestamp before 1970.
New method .RequestHandler.log_exception can be overridden to customize the logging behavior when an exception is uncaught. Most apps that currently override _handle_request_exception can now use a combination of .RequestHandler.log_exception and .write_error.
.RequestHandler.get_argument now raises .MissingArgumentError (a subclass of tornado.web.HTTPError, which is what it raised previously) if the argument cannot be found.
.Application.reverse_url now uses .url_escape with plus=False, i.e. spaces are encoded as %20 instead of +.
Arguments extracted from the url path are now decoded with .url_unescape with plus=False, so plus signs are left as-is instead of being turned into spaces.
.RequestHandler.send_error will now only be called once per request, even if multiple exceptions are caught by the stack context.
The tornado.web.asynchronous decorator is no longer necessary for methods that return a .Future (i.e. those that use the .gen.coroutine or return_future decorators)
.RequestHandler.prepare may now be asynchronous if it returns a .Future. The tornado.web.asynchronous decorator is not used with prepare; one of the .Future-related decorators should be used instead.
RequestHandler.current_user may now be assigned to normally.
.RequestHandler.redirect no longer silently strips control characters and whitespace. It is now an error to pass control characters, newlines or tabs.
.StaticFileHandler has been reorganized internally and now has additional extension points that can be overridden in subclasses.
.StaticFileHandler now supports HTTP Range requests. .StaticFileHandler is still not suitable for files too large to comfortably fit in memory, but Range support is necessary in some browsers to enable seeking of HTML5 audio and video.
.StaticFileHandler now uses longer hashes by default, and uses the same hashes for Etag as it does for versioned urls.
.StaticFileHandler.make_static_url and .RequestHandler.static_url now have an additional keyword argument include_version to suppress the url versioning.
.StaticFileHandler now reads its file in chunks, which will reduce memory fragmentation.
Fixed a problem with the Date header and cookie expiration dates when the system locale is set to a non-english configuration.
.WebSocketHandler now catches .StreamClosedError and runs ~.WebSocketHandler.on_close immediately instead of logging a stack trace.
New method .WebSocketHandler.set_nodelay can be used to set the TCP_NODELAY flag.
Fixed an exception in .WSGIContainer when the connection is closed while output is being written.
tornado.auth.TwitterMixin now defaults to version 1.1 of the Twitter API, instead of version 1.0 which is being discontinued on June 11 _. It also now
tornado.auth.TwitterMixin now defaults to version 1.1 of the Twitter API, instead of version 1.0 which is being discontinued on June 11. It also now uses HTTPS when talking to Twitter.
Fixed a potential memory leak with a long chain of .gen.coroutine or gen.engine functions.
The interface of tornado.auth.FacebookGraphMixin is now consistent with its documentation and the rest of the module. The get_authenticated_user and f
The interface of tornado.auth.FacebookGraphMixin is now consistent with its documentation and the rest of the module. The get_authenticated_user and facebook_request methods return a Future and the callback argument is optional.
The tornado.testing.gen_test decorator will no longer be recognized as a (broken) test by nose.
Work around a bug in Ubuntu 13.04 betas involving an incomplete backport of the ssl.match_hostname function.
tornado.websocket.websocket_connect now fails cleanly when it attempts to connect to a non-websocket url.
tornado.testing.LogTrapTestCase once again works with byte strings on Python 2.
The request attribute of tornado.httpclient.HTTPResponse is now always an ~tornado.httpclient.HTTPRequest, never a _RequestProxy.
Exceptions raised by the tornado.gen module now have better messages when tuples are used as callback keys.
…using the same port. get_unused_port is now deprecated.
The callback argument to many asynchronous methods is now optional, and these methods return a .Future. The tornado.gen module now understands Futures, and these methods can be used directly without a gen.Task wrapper.
New function .IOLoop.current returns the .IOLoop that is running on the current thread (as opposed to .IOLoop.instance, which returns a specific thread's (usually the main thread's) IOLoop.
New class tornado.netutil.Resolver provides an asynchronous interface to DNS resolution. The default implementation is still blocking, but non-blocking implementations are available using one of three optional dependencies: ~tornado.netutil.ThreadedResolver using the concurrent.futures thread pool, tornado.platform.caresresolver.CaresResolver using the pycares library, or tornado.platform.twisted.TwistedResolver using twisted
Tornado's logging is now less noisy, and it no longer goes directly to the root logger, allowing for finer-grained configuration.
New class tornado.process.Subprocess wraps subprocess.Popen with .PipeIOStream access to the child's file descriptors.
.IOLoop now has a static configure <.Configurable.configure> method like the one on .AsyncHTTPClient, which can be used to select an .IOLoop implementation other than the default.
.IOLoop can now optionally use a monotonic clock if available (see below for more details).
Python 2.5 is no longer supported. Python 3 is now supported in a single codebase instead of using 2to3
The tornado.database module has been removed. It is now available as a separate package, torndb
Functions that take an io_loop parameter now default to .IOLoop.current() instead of .IOLoop.instance().
Empty HTTP request arguments are no longer ignored. This applies to HTTPRequest.arguments and RequestHandler.get_argument[s] in WSGI and non-WSGI modes.
On Python 3, tornado.escape.json_encode no longer accepts byte strings.
On Python 3, the get_authenticated_user methods in tornado.auth now return character strings instead of byte strings.
tornado.netutil.TCPServer has moved to its own module, tornado.tcpserver.
The Tornado test suite now requires unittest2 when run on Python 2.6.
tornado.options.options is no longer a subclass of dict; attribute-style access is now required.
Tornado no longer logs to the root logger. Details on the new logging scheme can be found under the tornado.log module. Note that in some cases this will require that you add an explicit logging configuration in order to see any output (perhaps just calling logging.basicConfig()), although both .IOLoop.start() and tornado.options.parse_command_line will do this for you.
On python 3.2+, methods that take an ssl_options argument (on .SSLIOStream, .TCPServer, and .HTTPServer) now accept either a dictionary of options or an ssl.SSLContext object.
New optional dependency on concurrent.futures to provide better support for working with threads. concurrent.futures is in the standard library for Python 3.2+, and can be installed on older versions with pip install futures.
tornado.autoreload is now more reliable when there are errors at import time.
Calling tornado.autoreload.start (or creating an .Application with debug=True) twice on the same .IOLoop now does nothing (instead of creating multiple periodic callbacks). Starting autoreload on more than one .IOLoop in the same process now logs a warning.
Scripts run by autoreload no longer inherit __future__ imports used by Tornado.
On Python 3, the get_authenticated_user method family now returns character strings instead of byte strings.
Asynchronous methods defined in tornado.auth now return a .Future, and their callback argument is optional. The Future interface is preferred as it offers better error handling (the previous interface just logged a warning and returned None).
The tornado.auth mixin classes now define a method get_auth_http_client, which can be overridden to use a non-default .AsyncHTTPClient instance (e.g. to use a different .IOLoop)
Subclasses of .OAuthMixin are encouraged to override .OAuthMixin._oauth_get_user_future instead of _oauth_get_user, although both methods are still supported.
New module tornado.concurrent contains code to support working with concurrent.futures, or to emulate future-based interface when that module is not available.
Preliminary support for tornado.curl_httpclient on Python 3. The latest official release of pycurl only supports Python 2, but Ubuntu has a port available in 12.10 (apt-get install python3-pycurl). This port currently has bugs that prevent it from handling arbitrary binary data but it should work for textual (utf8) resources.
Fix a crash with libcurl 7.29.0 if a curl object is created and closed without being used.
On Python 3, ~tornado.escape.json_encode no longer accepts byte strings. This mirrors the behavior of the underlying json module. Python 2 behavior is unchanged but should be faster.
New decorator @gen.coroutine is available as an alternative to @gen.engine. It automatically returns a .Future, and within the function instead of calling a callback you return a value with raise gen.Return(value) (or simply return value in Python 3.3).
Generators may now yield .Future objects.
Callbacks produced by gen.Callback and gen.Task are now automatically stack-context-wrapped, to minimize the risk of context leaks when used with asynchronous functions that don't do their own wrapping.
Fixed a memory leak involving generators, .RequestHandler.flush, and clients closing connections while output is being written.
Yielding a large list no longer has quadratic performance.
.AsyncHTTPClient.fetch now returns a .Future and its callback argument is optional. When the future interface is used, any error will be raised automatically, as if .HTTPResponse.rethrow was called.
.AsyncHTTPClient.configure and all .AsyncHTTPClient constructors now take a defaults keyword argument. This argument should be a dictionary, and its values will be used in place of corresponding attributes of ~tornado.httpclient.HTTPRequest that are not set.
All unset attributes of tornado.httpclient.HTTPRequest are now None. The default values of some attributes (connect_timeout, request_timeout, follow_redirects, max_redirects, use_gzip, proxy_password, allow_nonstandard_methods, and validate_cert have been moved from ~tornado.httpclient.HTTPRequest to the client implementations.
The max_clients argument to .AsyncHTTPClient is now a keyword-only argument.
Keyword arguments to .AsyncHTTPClient.configure are no longer used when instantiating an implementation subclass directly.
Secondary .AsyncHTTPClient callbacks (streaming_callback, header_callback, and prepare_curl_callback) now respect StackContext.
.HTTPServer no longer logs an error when it is unable to read a second request from an HTTP 1.1 keep-alive connection.
.HTTPServer now takes a protocol keyword argument which can be set to https if the server is behind an SSL-decoding proxy that does not set any supported X-headers.
tornado.httpserver.HTTPConnection now has a set_close_callback method that should be used instead of reaching into its stream attribute.
Empty HTTP request arguments are no longer ignored. This applies to HTTPRequest.arguments and RequestHandler.get_argument[s] in WSGI and non-WSGI modes.
New function .IOLoop.current returns the IOLoop that is running on the current thread (as opposed to .IOLoop.instance, which returns a specific thread's (usually the main thread's) IOLoop).
New method .IOLoop.add_future to run a callback on the IOLoop when an asynchronous .Future finishes.
.IOLoop now has a static configure <.Configurable.configure> method like the one on .AsyncHTTPClient, which can be used to select an .IOLoop implementation other than the default.
The .IOLoop poller implementations (select, epoll, kqueue) are now available as distinct subclasses of .IOLoop. Instantiating .IOLoop will continue to automatically choose the best available implementation.
The .IOLoop constructor has a new keyword argument time_func, which can be used to set the time function used when scheduling callbacks. This is most useful with the time.monotonic function, introduced in Python 3.3 and backported to older versions via the monotime module. Using a monotonic clock here avoids problems when the system clock is changed.
New function .IOLoop.time returns the current time according to the IOLoop. To use the new monotonic clock functionality, all calls to .IOLoop.add_timeout must be either pass a datetime.timedelta or a time relative to .IOLoop.time, not time.time. (time.time will continue to work only as long as the IOLoop's time_func argument is not used).
New convenience method .IOLoop.run_sync can be used to start an IOLoop just long enough to run a single coroutine.
New method .IOLoop.add_callback_from_signal is safe to use in a signal handler (the regular .add_callback method may deadlock).
.IOLoop now uses signal.set_wakeup_fd where available (Python 2.6+ on Unix) to avoid a race condition that could result in Python signal handlers being delayed.
Method IOLoop.running() has been removed.
.IOLoop has been refactored to better support subclassing.
.IOLoop.add_callback and .add_callback_from_signal now take *args, **kwargs to pass along to the callback.
.IOStream.connect now has an optional server_hostname argument which will be used for SSL certificate validation when applicable. Additionally, when supported (on Python 3.2+), this hostname will be sent via SNI (and this is supported by tornado.simple_httpclient)
Much of .IOStream has been refactored into a separate class .BaseIOStream.
New class tornado.iostream.PipeIOStream provides the IOStream interface on pipe file descriptors.
.IOStream now raises a new exception tornado.iostream.StreamClosedError when you attempt to read or write after the stream has been closed (by either side).
.IOStream now simply closes the connection when it gets an ECONNRESET error, rather than logging it as an error.
IOStream.error no longer picks up unrelated exceptions.
.BaseIOStream.close now has an exc_info argument (similar to the one used in the logging module) that can be used to set the stream's error attribute when closing it.
.BaseIOStream.read_until_close now works correctly when it is called while there is buffered data.
Fixed a major performance regression when run on PyPy (introduced in Tornado 2.3).
New module containing .enable_pretty_logging and .LogFormatter, moved from the options module.
.LogFormatter now handles non-ascii data in messages and tracebacks better.
New class tornado.netutil.Resolver provides an asynchronous interface to DNS resolution. The default implementation is still blocking, but non-blocking implementations are available using one of three optional dependencies: ~tornado.netutil.ThreadedResolver using the concurrent.futures thread pool, tornado.platform.caresresolver.CaresResolver using the pycares library, or tornado.platform.twisted.TwistedResolver using twisted
New function tornado.netutil.is_valid_ip returns true if a given string is a valid IP (v4 or v6) address.
tornado.netutil.bind_sockets has a new flags argument that can be used to pass additional flags to getaddrinfo.
tornado.netutil.bind_sockets no longer sets AI_ADDRCONFIG; this will cause it to bind to both ipv4 and ipv6 more often than before.
tornado.netutil.bind_sockets now works when Python was compiled with --disable-ipv6 but IPv6 DNS resolution is available on the system.
tornado.netutil.TCPServer has moved to its own module, tornado.tcpserver.
The class underlying the functions in tornado.options is now public (tornado.options.OptionParser). This can be used to create multiple independent option sets, such as for subcommands.
tornado.options.parse_config_file now configures logging automatically by default, in the same way that ~tornado.options.parse_command_line does.
New function tornado.options.add_parse_callback schedules a callback to be run after the command line or config file has been parsed. The keyword argument final=False can be used on either parsing function to suppress these callbacks.
tornado.options.define now takes a callback argument. This callback will be run with the new value whenever the option is changed. This is especially useful for options that set other options, such as by reading from a config file.
tornado.options.parse_command_line --help output now goes to stderr rather than stdout.
tornado.options.options is no longer a subclass of dict; attribute-style access is now required.
tornado.options.options (and .OptionParser instances generally) now have a .mockable() method that returns a wrapper object compatible with mock.patch <unittest.mock.patch>.
Function tornado.options.enable_pretty_logging has been moved to the tornado.log module.
New module containing an asynchronous implementation of the .Resolver interface, using the pycares library.
New class tornado.platform.twisted.TwistedIOLoop allows Tornado code to be run on the Twisted reactor (as opposed to the existing TornadoReactor, which bridges the gap in the other direction).
New class tornado.platform.twisted.TwistedResolver` is an asynchronous implementation of the .Resolver interface.
New class tornado.process.Subprocess wraps subprocess.Popen with .PipeIOStream access to the child's file descriptors.
SimpleAsyncHTTPClient now takes a resolver keyword argument (which may be passed to either the constructor or configure <.Configurable.configure>), to allow it to use the new non-blocking tornado.netutil.Resolver.
When following redirects, SimpleAsyncHTTPClient now treats a 302 response code the same as a 303. This is contrary to the HTTP spec but consistent with all browsers and other major HTTP clients (including CurlAsyncHTTPClient).
The behavior of header_callback with SimpleAsyncHTTPClient has changed and is now the same as that of CurlAsyncHTTPClient. The header callback now receives the first line of the response (e.g. HTTP/1.0 200 OK) and the final empty line.
tornado.simple_httpclient now accepts responses with a 304 status code that include a Content-Length header.
Fixed a bug in which SimpleAsyncHTTPClient callbacks were being run in the client's stack_context.
stack_context.wrap now runs the wrapped callback in a more consistent environment by recreating contexts even if they already exist on the stack.
Fixed a bug in which stack contexts could leak from one callback chain to another.
Yield statements inside a with statement can cause stack contexts to become inconsistent; an exception will now be raised when this case is detected.
Errors while rendering templates no longer log the generated code, since the enhanced stack traces (from version 2.1) should make this unnecessary.
The {% apply %} directive now works properly with functions that return both unicode strings and byte strings (previously only byte strings were supported).
Code in templates is no longer affected by Tornado's __future__ imports (which previously included absolute_import and division).
New function tornado.testing.bind_unused_port both chooses a port and binds a socket to it, so there is no risk of another process using the same port. get_unused_port is now deprecated.
New decorator tornado.testing.gen_test can be used to allow for yielding tornado.gen objects in tests, as an alternative to the stop and wait methods of .AsyncTestCase.
tornado.testing.AsyncTestCase and friends now extend unittest2.TestCase when it is available (and continue to use the standard unittest module when unittest2 is not available)
tornado.testing.ExpectLog can be used as a finer-grained alternative to tornado.testing.LogTrapTestCase
The command-line interface to tornado.testing.main now supports additional arguments from the underlying unittest module: verbose, quiet, failfast, catch, buffer.
The deprecated --autoreload option of tornado.testing.main has been removed. Use python -m tornado.autoreload as a prefix command instead.
The --httpclient option of tornado.testing.main has been moved to tornado.test.runtests so as not to pollute the application option namespace. The tornado.options module's new callback support now makes it easy to add options from a wrapper script instead of putting all possible options in tornado.testing.main.
.AsyncHTTPTestCase no longer calls .AsyncHTTPClient.close for tests that use the singleton .IOLoop.instance.
LogTrapTestCase no longer fails when run in unknown logging configurations. This allows tests to be run under nose, which does its own log buffering (LogTrapTestCase doesn't do anything useful in this case, but at least it doesn't break things any more).
tornado.util.b (which was only intended for internal use) is gone.
.RequestHandler.set_header now overwrites previous header values case-insensitively.
tornado.web.RequestHandler has new attributes path_args and path_kwargs, which contain the positional and keyword arguments that are passed to the get/post/etc method. These attributes are set before those methods are called, so they are available during prepare()
tornado.web.ErrorHandler no longer requires XSRF tokens on POST requests, so posts to an unknown url will always return 404 instead of complaining about XSRF tokens.
Several methods related to HTTP status codes now take a reason keyword argument to specify an alternate "reason" string (i.e. the "Not Found" in "HTTP/1.1 404 Not Found"). It is now possible to set status codes other than those defined in the spec, as long as a reason string is given.
The Date HTTP header is now set by default on all responses.
Etag/If-None-Match requests now work with .StaticFileHandler.
.StaticFileHandler no longer sets Cache-Control: public unnecessarily.
When gzip is enabled in a tornado.web.Application, appropriate Vary: Accept-Encoding headers are now sent.
It is no longer necessary to pass all handlers for a host in a single .Application.add_handlers call. Now the request will be matched against the handlers for any host_pattern that includes the request's Host header.
Client-side WebSocket support is now available: tornado.websocket.websocket_connect
.WebSocketHandler has new methods ~.WebSocketHandler.ping and ~.WebSocketHandler.on_pong to send pings to the browser (not supported on the draft76 protocol)
Fixed a memory leak in tornado.stack_context that was especially likely with long-running @gen.engine functions.
Fixed a memory leak in tornado.stack_context that was especially likely with long-running @gen.engine functions.
tornado.auth.TwitterMixin now works on Python 3.
Fixed a bug in which IOStream.read_until_close with a streaming callback would sometimes pass the last chunk of data to the final callback instead of the streaming callback.
Fixed Python 3 bugs in tornado.auth, tornado.locale, and tornado.wsgi.
Fixed Python 3 bugs in tornado.auth, tornado.locale, and tornado.wsgi.
Removed max_simultaneous_connections argument from tornado.httpclient (both implementations). This argument hasn't been useful for some time (if you were using it you probably want max_clients instead)
tornado.simple_httpclient now accepts and ignores HTTP 1xx status responses.
Fixed a bug introduced in 2.3 that would cause .IOStream close callbacks to not run if there were pending reads.
Improved error handling in .SSLIOStream and SSL-enabled .TCPServer.
SSLIOStream.get_ssl_certificate now has a binary_form argument which is passed to SSLSocket.getpeercert.
SSLIOStream.write can now be called while the connection is in progress, same as non-SSL .IOStream (but be careful not to send sensitive data until the connection has completed and the certificate has been verified).
.IOLoop.add_handler cannot be called more than once with the same file descriptor. This was always true for epoll, but now the other implementations enforce it too.
On Windows, .TCPServer uses SO_EXCLUSIVEADDRUSER instead of SO_REUSEADDR.
{% break %} and {% continue %} can now be used looping constructs in templates.
It is no longer an error for an if/else/for/etc block in a template to have an empty body.
New class tornado.testing.AsyncHTTPSTestCase is like .AsyncHTTPTestCase. but enables SSL for the testing server (by default using a self-signed testing certificate).
tornado.testing.main now accepts additional keyword arguments and forwards them to unittest.main.
New method .RequestHandler.get_template_namespace can be overridden to add additional variables without modifying keyword arguments to render_string.
.RequestHandler.add_header now works with WSGIApplication.
.RequestHandler.get_secure_cookie now handles a potential error case.
RequestHandler.__init__ now calls super().__init__ to ensure that all constructors are called when multiple inheritance is used.
Docs have been updated with a description of all available Application settings
.OAuthMixin now accepts "oob" as a callback_uri.
OpenIdMixin now also returns the claimed_id field for the user.
tornado.platform.twisted shutdown sequence is now more compatible.
The logging configuration used in tornado.options is now more tolerant of non-ascii byte strings.
tornado.httpclient.HTTPClient now supports the same constructor keyword arguments as .AsyncHTTPClient.
tornado.httpclient.HTTPClient now supports the same constructor keyword arguments as .AsyncHTTPClient.
The max_clients keyword argument to .AsyncHTTPClient.configure now works.
tornado.simple_httpclient now supports the OPTIONS and PATCH HTTP methods.
tornado.simple_httpclient is better about closing its sockets instead of leaving them for garbage collection.
tornado.simple_httpclient correctly verifies SSL certificates for URLs containing IPv6 literals (This bug affected Python 2.5 and 2.6).
tornado.simple_httpclient no longer includes basic auth credentials in the Host header when those credentials are extracted from the URL.
tornado.simple_httpclient no longer modifies the caller-supplied header dictionary, which caused problems when following redirects.
tornado.curl_httpclient now supports client SSL certificates (using the same client_cert and client_key arguments as tornado.simple_httpclient)
.HTTPServer now works correctly with paths starting with //
HTTPHeaders.copy (inherited from dict.copy) now works correctly.
HTTPConnection.address is now always the socket address, even for non-IP sockets. HTTPRequest.remote_ip is still always an IP-style address (fake data is used for non-IP sockets)
Extra data at the end of multipart form bodies is now ignored, which fixes a compatibility problem with an iOS HTTP client library.
.IOStream now has an error attribute that can be used to determine why a socket was closed.
tornado.iostream.IOStream.read_until and read_until_regex are much faster with large input.
IOStream.write performs better when given very large strings.
.IOLoop.instance() is now thread-safe.
tornado.options options with multiple=True that are set more than once now overwrite rather than append. This makes it possible to override values set in parse_config_file with parse_command_line.
tornado.options --help output is now prettier.
tornado.options.options now supports attribute assignment.
Template files containing non-ASCII (utf8) characters now work on Python 3 regardless of the locale environment variables.
Templates now support else clauses in try/except/finally/else blocks.
tornado.web.RequestHandler now supports the PATCH HTTP method. Note that this means any existing methods named patch in RequestHandler subclasses will need to be renamed.
tornado.web.addslash and removeslash decorators now send permanent redirects (301) instead of temporary (302).
.RequestHandler.flush now invokes its callback whether there was any data to flush or not.
Repeated calls to .RequestHandler.set_cookie with the same name now overwrite the previous cookie instead of producing additional copies.
tornado.web.OutputTransform.transform_first_chunk now takes and returns a status code in addition to the headers and chunk. This is a backwards-incompatible change to an interface that was never technically private, but was not included in the documentation and does not appear to have been used outside Tornado itself.
Fixed a bug on python versions before 2.6.5 when tornado.web.URLSpec regexes are constructed from unicode strings and keyword arguments are extracted.
The reverse_url function in the template namespace now comes from the .RequestHandler rather than the .Application. (Unless overridden, .RequestHandler.reverse_url is just an alias for the .Application method).
The Etag header is now returned on 304 responses to an If-None-Match request, improving compatibility with some caches.
tornado.web will no longer produce responses with status code 304 that also have entity headers such as Content-Length.
tornado.auth.FacebookGraphMixin no longer sends post_args redundantly in the url.
The extra_params argument to tornado.escape.linkify may now be a callable, to allow parameters to be chosen separately for each link.
tornado.gen no longer leaks StackContexts when a @gen.engine wrapped function is called repeatedly.
tornado.locale.get_supported_locales no longer takes a meaningless cls argument.
StackContext instances now have a deactivation callback that can be used to prevent further propagation.
tornado.testing.AsyncTestCase.wait now resets its timeout on each call.
tornado.wsgi.WSGIApplication now parses arguments correctly on Python 3.
Exception handling on Python 3 has been improved; previously some exceptions such as UnicodeDecodeError would generate TypeErrors
tornado.web.RequestHandler.set_header now properly sanitizes input values to protect against header injection, response splitting, etc. (it has always
tornado.web.RequestHandler.set_header now properly sanitizes input values to protect against header injection, response splitting, etc. (it has always attempted to do this, but the check was incorrect). Note that redirects, the most likely source of such bugs, are protected by a separate check in .RequestHandler.redirect.
Colored logging configuration in tornado.options is compatible with Python 3.2.3 (and 3.3).
Updated and expanded WebSocket support.
Updated and expanded WebSocket support.
Improved compatibility in the Twisted/Tornado bridge.
Template errors now generate better stack traces.
Better exception handling in tornado.gen.
tornado.simple_httpclient now disables SSLv2 in all cases. Previously SSLv2 would be allowed if the Python interpreter was linked against a pre-1.0 version of OpenSSL.
tornado.process.fork_processes now raises SystemExit if all child processes exit cleanly rather than returning None. The old behavior was surprising and inconsistent with most of the documented examples of this function (which did not check the return value).
On Python 2.6, tornado.simple_httpclient only supports SSLv3. This is because Python 2.6 does not expose a way to support both SSLv3 and TLSv1 without also supporting the insecure SSLv2.
tornado.websocket no longer supports the older "draft 76" version of the websocket protocol by default, although this version can be enabled by overriding tornado.websocket.WebSocketHandler.allow_draft76.
SimpleAsyncHTTPClient no longer hangs on HEAD requests, responses with no content, or empty POST/PUT response bodies.
SimpleAsyncHTTPClient now supports 303 and 307 redirect codes.
tornado.curl_httpclient now accepts non-integer timeouts.
tornado.curl_httpclient now supports basic authentication with an empty password.
.HTTPServer with xheaders=True will no longer accept X-Real-IP headers that don't look like valid IP addresses.
.HTTPServer now treats the Connection request header as case-insensitive.
IOStream.write now works correctly when given an empty string.
IOStream.read_until (and read_until_regex) now perform better when there is a lot of buffered data, which improves performance of SimpleAsyncHTTPClient when downloading files with lots of chunks.
.SSLIOStream now works correctly when ssl_version is set to a value other than SSLv23.
Idle IOLoops no longer wake up several times a second.
tornado.ioloop.PeriodicCallback no longer triggers duplicate callbacks when stopped and started repeatedly.
Exceptions in template code will now show better stack traces that reference lines from the original template file.
{# and #} can now be used for comments (and unlike the old {% comment %} directive, these can wrap other template directives).
Template directives may now span multiple lines.
Now behaves better when given malformed Cookie headers
.RequestHandler.redirect now has a status argument to send status codes other than 301 and 302.
New method .RequestHandler.on_finish may be overridden for post-request processing (as a counterpart to .RequestHandler.prepare)
.StaticFileHandler now outputs Content-Length and Etag headers on HEAD requests.
.StaticFileHandler now has overridable get_version and parse_url_path methods for use in subclasses.
.RequestHandler.static_url now takes an include_host parameter (in addition to the old support for the RequestHandler.include_host attribute).
Updated to support the latest version of the protocol, as finalized in RFC 6455.
Many bugs were fixed in all supported protocol versions.
tornado.websocket no longer supports the older "draft 76" version of the websocket protocol by default, although this version can be enabled by overriding tornado.websocket.WebSocketHandler.allow_draft76.
.WebSocketHandler.write_message now accepts a binary argument to send binary messages.
Subprotocols (i.e. the Sec-WebSocket-Protocol header) are now supported; see the .WebSocketHandler.select_subprotocol method for details.
.WebSocketHandler.get_websocket_scheme can be used to select the appropriate url scheme (ws:// or wss://) in cases where HTTPRequest.protocol is not set correctly.
tornado.auth.TwitterMixin.authenticate_redirect now takes a callback_uri parameter.
tornado.auth.TwitterMixin.twitter_request now accepts both URLs and partial paths (complete URLs are useful for the search API which follows different patterns).
Exception handling in tornado.gen has been improved. It is now possible to catch exceptions thrown by a Task.
tornado.netutil.bind_sockets now works when getaddrinfo returns duplicate addresses.
tornado.platform.twisted compatibility has been significantly improved. Twisted version 11.1.0 is now supported in addition to 11.0.0.
tornado.process.fork_processes correctly reseeds the random module even when os.urandom is not implemented.
tornado.testing.main supports a new flag --exception_on_interrupt, which can be set to false to make Ctrl-C kill the process more reliably (at the expense of stack traces when it does so).
tornado.version_info is now a four-tuple so official releases can be distinguished from development branches.
Fixed handling of closed connections with the epoll (i.e. Linux) IOLoop. Previously, closed connections could be shut down too early, which most often
Fixed handling of closed connections with the epoll (i.e. Linux) IOLoop. Previously, closed connections could be shut down too early, which most often manifested as "Stream is closed" exceptions in SimpleAsyncHTTPClient.
Fixed a case in which chunked responses could be closed prematurely, leading to truncated output.
IOStream.connect now reports errors more consistently via logging and the close callback (this affects e.g. connections to localhost on FreeBSD).
IOStream.read_bytes again accepts both int and long arguments.
PeriodicCallback no longer runs repeatedly when IOLoop iterations complete faster than the resolution of time.time() (mainly a problem on Windows).
Listening for IOLoop.ERROR alone is no longer sufficient for detecting closed connections on an otherwise unused socket. IOLoop.ERROR must always be used in combination with READ or WRITE.
…pages (get_error_html is still supported, but deprecated)
Support for secure cookies written by pre-1.0 releases of Tornado has been removed. The .RequestHandler.get_secure_cookie method no longer takes an include_name parameter.
The debug application setting now causes stack traces to be displayed in the browser on uncaught exceptions. Since this may leak sensitive information, debug mode is not recommended for public-facing servers.
Diginotar has been removed from the default CA certificates file used by SimpleAsyncHTTPClient.
tornado.gen: A generator-based interface to simplify writing asynchronous functions.
tornado.netutil: Parts of tornado.httpserver have been extracted into a new module for use with non-HTTP protocols.
tornado.platform.twisted: A bridge between the Tornado IOLoop and the Twisted Reactor, allowing code written for Twisted to be run on Tornado.
tornado.process: Multi-process mode has been improved, and can now restart crashed child processes. A new entry point has been added at tornado.process.fork_processes, although tornado.httpserver.HTTPServer.start is still supported.
tornado.web.RequestHandler.write_error replaces get_error_html as the preferred way to generate custom error pages (get_error_html is still supported, but deprecated)
In tornado.web.Application, handlers may be specified by (fully-qualified) name instead of importing and passing the class object itself.
It is now possible to use a custom subclass of StaticFileHandler with the static_handler_class application setting, and this subclass can override the behavior of the static_url method.
~tornado.web.StaticFileHandler subclasses can now override get_cache_time to customize cache control behavior.
tornado.web.RequestHandler.get_secure_cookie now has a max_age_days parameter to allow applications to override the default one-month expiration.
~tornado.web.RequestHandler.set_cookie now accepts a max_age keyword argument to set the max-age cookie attribute (note underscore vs dash)
tornado.web.RequestHandler.set_default_headers may be overridden to set headers in a way that does not get reset during error handling.
.RequestHandler.add_header can now be used to set a header that can appear multiple times in the response.
.RequestHandler.flush can now take a callback for flow control.
The application/json content type can now be gzipped.
The cookie-signing functions are now accessible as static functions tornado.web.create_signed_value and tornado.web.decode_signed_value.
To facilitate some advanced multi-process scenarios, HTTPServer has a new method add_sockets, and socket-opening code is available separately as tornado.netutil.bind_sockets.
The cookies property is now available on tornado.httpserver.HTTPRequest (it is also available in its old location as a property of ~tornado.web.RequestHandler)
tornado.httpserver.HTTPServer.bind now takes a backlog argument with the same meaning as socket.listen.
~tornado.httpserver.HTTPServer can now be run on a unix socket as well as TCP.
Fixed exception at startup when socket.AI_ADDRCONFIG is not available, as on Windows XP
~tornado.iostream.IOStream performance has been improved, especially for small synchronous requests.
New methods tornado.iostream.IOStream.read_until_close and tornado.iostream.IOStream.read_until_regex.
IOStream.read_bytes and IOStream.read_until_close now take a streaming_callback argument to return data as it is received rather than all at once.
.IOLoop.add_timeout now accepts datetime.timedelta objects in addition to absolute timestamps.
~tornado.ioloop.PeriodicCallback now sticks to the specified period instead of creeping later due to accumulated errors.
tornado.ioloop.IOLoop and tornado.httpclient.HTTPClient now have close() methods that should be used in applications that create and destroy many of these objects.
.IOLoop.install can now be used to use a custom subclass of IOLoop as the singleton without monkey-patching.
~tornado.iostream.IOStream should now always call the close callback instead of the connect callback on a connection error.
The .IOStream close callback will no longer be called while there are pending read callbacks that can be satisfied with buffered data.
Now supports client SSL certificates with the client_key and client_cert parameters to tornado.httpclient.HTTPRequest
Now takes a maximum buffer size, to allow reading files larger than 100MB
Now works with HTTP 1.0 servers that don't send a Content-Length header
The allow_nonstandard_methods flag on HTTP client requests now permits methods other than POST and PUT to contain bodies.
Fixed file descriptor leaks and multiple callback invocations in SimpleAsyncHTTPClient
No longer consumes extra connection resources when following redirects.
Now works with buggy web servers that separate headers with \n instead of \r\n\r\n.
Now sets response.request_time correctly.
Connect timeouts now work correctly.
tornado.auth.OpenIdMixin now uses the correct realm when the callback URI is on a different domain.
tornado.autoreload has a new command-line interface which can be used to wrap any script. This replaces the --autoreload argument to tornado.testing.main and is more robust against syntax errors.
tornado.autoreload.watch can be used to watch files other than the sources of imported modules.
tornado.database.Connection has new variants of execute and executemany that return the number of rows affected instead of the last inserted row id.
tornado.locale.load_translations now accepts any properly-formatted locale name, not just those in the predefined LOCALE_NAMES list.
tornado.options.define now takes a group parameter to group options in --help output.
Template loaders now take a namespace constructor argument to add entries to the template namespace.
tornado.websocket now supports the latest ("hybi-10") version of the protocol (the old version, "hixie-76" is still supported; the correct version is detected automatically).
tornado.websocket now works on Python 3
Windows support has been improved. Windows is still not an officially supported platform, but the test suite now passes and tornado.autoreload works.
Uploading files whose names contain special characters will now work.
Cookie values containing special characters are now properly quoted and unquoted.
Multi-line headers are now supported.
Repeated Content-Length headers (which may be added by certain proxies) are now supported in .HTTPServer.
Unicode string literals now work in template expressions.
The template {% module %} directive now works even if applications use a template variable named modules.
Requests with "Expect: 100-continue" now work on python 3
Template output is automatically escaped by default; see backwards compatibility note below.
Major changes:
* Template output is automatically escaped by default; see backwards
compatibility note below.
* The default AsyncHTTPClient implementation is now simple_httpclient.
* Python 3.2 is now supported.
Backwards compatibility:
* Template autoescaping is enabled by default. Applications upgrading from
a previous release of Tornado must either disable autoescaping or adapt
their templates to work with it. For most applications, the simplest
way to do this is to pass autoescape=None to the Application constructor.
Note that this affects certain built-in methods, e.g. xsrf_form_html
and linkify, which must now be called with {% raw %} instead of {}
* Applications that wish to continue using curl_httpclient instead of
simple_httpclient may do so by calling
AsyncHTTPClient.configure("tornado.curl_httpclient.CurlAsyncHTTPClient")
at the beginning of the process. Users of Python 2.5 will probably want
to use curl_httpclient as simple_httpclient only supports ssl on Python 2.6+.
* Python 3 compatibility involved many changes throughout the codebase,
so users are encouraged to test their applications more thoroughly than
usual when upgrading to this release.
Other changes in this release:
* Templates support several new directives:
- {% autoescape ...%} to control escaping behavior
- {% raw ... %} for unescaped output
- {% module ... %} for calling UIModules
* {% module Template(path, **kwargs) %} may now be used to call another
template with an independent namespace
* All IOStream callbacks are now run directly on the IOLoop via add_callback.
* HTTPServer now supports IPv6 where available. To disable, pass
family=socket.AF_INET to HTTPServer.bind().
* HTTPClient now supports IPv6, configurable via allow_ipv6=bool on the
HTTPRequest. allow_ipv6 defaults to false on simple_httpclient and true
on curl_httpclient.
* RequestHandlers can use an encoding other than utf-8 for query parameters
by overriding decode_argument()
* Performance improvements, especially for applications that use a lot of
IOLoop timeouts
* HTTP OPTIONS method no longer requires an XSRF token.
* JSON output (RequestHandler.write(dict)) now sets Content-Type to
application/json
* Etag computation can now be customized or disabled by overriding
RequestHandler.compute_etag
* USE_SIMPLE_HTTPCLIENT environment variable is no longer supported.
Use AsyncHTTPClient.configure instead.
We are pleased to announce the release of Tornado 1.2.1, available from https://github.com/downloads/facebook/tornado/tornado-1.2.1.tar.gz
We are pleased to announce the release of Tornado 1.2.1, available from https://github.com/downloads/facebook/tornado/tornado-1.2.1.tar.gz This release contains only two small changes relative to version 1.2: * FacebookGraphMixin has been updated to work with a recent change to the Facebook API. * Running "setup.py install" will no longer attempt to automatically install pycurl. This wasn't working well on platforms where the best way to install pycurl is via something like apt-get instead of easy_install. This is an important upgrade if you are using FacebookGraphMixin, but otherwise it can be safely ignored.
We are pleased to announce the release of Tornado 1.2, available from https://github.com/downloads/facebook/tornado/tornado-1.2.tar.gz
We are pleased to announce the release of Tornado 1.2, available from
https://github.com/downloads/facebook/tornado/tornado-1.2.tar.gz
Backwards compatibility notes:
* This release includes the backwards-incompatible security change from
version 1.1.1. Users upgrading from 1.1 or earlier should read the
release notes from that release:
http://groups.google.com/group/python-tornado/browse_thread/thread/b36191c781580cde
* StackContexts that do something other than catch exceptions may need to
be modified to be reentrant.
https://github.com/tornadoweb/tornado/commit/7a7e24143e77481d140fb5579bc67e4c45cbcfad
* When XSRF tokens are used, the token must also be present on PUT and
DELETE requests (anything but GET and HEAD)
New features:
* A new HTTP client implementation is available in the module
tornado.simple_httpclient. This HTTP client does not depend on pycurl.
It has not yet been tested extensively in production, but is intended
to eventually replace the pycurl-based HTTP client in a future release of
Tornado. To transparently replace tornado.httpclient.AsyncHTTPClient with
this new implementation, you can set the environment variable
USE_SIMPLE_HTTPCLIENT=1 (note that the next release of Tornado will
likely include a different way to select HTTP client implementations)
* Request logging is now done by the Application rather than the
RequestHandler. Logging behavior may be customized by either overriding
Application.log_request in a subclass or by passing log_function
as an Application setting
* Application.listen(port): Convenience method as an alternative to
explicitly creating an HTTPServer
* tornado.escape.linkify(): Wrap urls in <a> tags
* RequestHandler.create_signed_value(): Create signatures like the
secure_cookie methods without setting cookies.
* tornado.testing.get_unused_port(): Returns a port selected in the same
way as inAsyncHTTPTestCase
* AsyncHTTPTestCase.fetch(): Convenience method for synchronous fetches
* IOLoop.set_blocking_signal_threshold(): Set a callback to be run when
the IOLoop is blocked.
* IOStream.connect(): Asynchronously connect a client socket
* AsyncHTTPClient.handle_callback_exception(): May be overridden
in subclass for custom error handling
* httpclient.HTTPRequest has two new keyword arguments, validate_cert and
ca_certs. Setting validate_cert=False will disable all certificate checks
when fetching https urls. ca_certs may be set to a filename containing
trusted certificate authorities (defaults will be used if this is
unspecified)
* HTTPRequest.get_ssl_certificate(): Returns the client's SSL certificate
(if client certificates were requested in the server's ssl_options
* StaticFileHandler can be configured to return a default file (e.g.
index.html) when a directory is requested
* Template directives of the form "{% from x import y %}" are now
supported (in addition to the existing support for "{% import x
%}"
* FacebookGraphMixin.get_authenticated_user now accepts a new
parameter 'extra_fields' which may be used to request additional
information about the user
Bug fixes:
* auth: Fixed KeyError with Facebook offline_access
* auth: Uses request.uri instead of request.path as the default redirect
so that parameters are preserved.
* escape: xhtml_escape() now returns a unicode string, not
utf8-encoded bytes
* ioloop: Callbacks added with add_callback are now run in the order they
were added
* ioloop: PeriodicCallback.stop can now be called from inside the callback.
* iostream: Fixed several bugs in SSLIOStream
* iostream: Detect when the other side has closed the connection even with
the select()-based IOLoop
* iostream: read_bytes(0) now works as expected
* iostream: Fixed bug when writing large amounts of data on windows
* iostream: Fixed infinite loop that could occur with unhandled exceptions
* httpclient: Fix bugs when some requests use proxies and others don't
* httpserver: HTTPRequest.protocol is now set correctly when using the
built-in SSL support
* httpserver: When using multiple processes, the standard library's
random number generator is re-seeded in each child process
* httpserver: With xheaders enabled, X-Forwarded-Proto is supported as an
alternative to X-Scheme
* httpserver: Fixed bugs in multipart/form-data parsing
* locale: format_date() now behaves sanely with dates in the future
* locale: Updates to the language list
* stack_context: Fixed bug with contexts leaking through reused IOStreams
* stack_context: Simplified semantics and improved performance
* web: The order of css_files from UIModules is now preserved
* web: Fixed error with default_host redirect
* web: StaticFileHandler works when os.path.sep != '/' (i.e. on Windows)
* web: Fixed a caching-related bug in StaticFileHandler when a file's
timestamp has changed but its contents have not.
* web: Fixed bugs with HEAD requests and e.g. Etag headers
* web: Fix bugs when different handlers have different static_paths
* web: @removeslash will no longer cause a redirect loop when applied to the
root path
* websocket: Now works over SSL
* websocket: Improved compatibility with proxies
Many thanks to everyone who contributed patches, bug reports, and feedback
that went into this release!
-Ben
Tornado 1.1.1 is a BACKWARDS-INCOMPATIBLE security update that fixes an XSRF vulnerability. It is available at https://github.com/downloads/facebook/t…
Tornado 1.1.1 is a BACKWARDS-INCOMPATIBLE security update that fixes an XSRF vulnerability. It is available at https://github.com/downloads/facebook/tornado/tornado-1.1.1.tar.gz This is a backwards-incompatible change. Applications that previously relied on a blanket exception for XMLHTTPRequest may need to be modified to explicitly include the XSRF token when making ajax requests. The tornado chat demo application demonstrates one way of adding this token (specifically the function postJSON in demos/chat/static/chat.js). More information about this change and its justification can be found at http://www.djangoproject.com/weblog/2011/feb/08/security/ http://weblog.rubyonrails.org/2011/2/8/csrf-protection-bypass-in-ruby-on-rails
We are pleased to announce the release of Tornado 1.1, available from https://github.com/downloads/facebook/tornado/tornado-1.1.tar.gz
We are pleased to announce the release of Tornado 1.1, available from https://github.com/downloads/facebook/tornado/tornado-1.1.tar.gz Changes in this release: * RequestHandler.async_callback and related functions in other classes are no longer needed in most cases (although it's harmless to continue using them). Uncaught exceptions will now cause the request to be closed even in a callback. If you're curious how this works, see the new tornado.stack_context module. * The new tornado.testing module contains support for unit testing asynchronous IOLoop-based code. * AsyncHTTPClient has been rewritten (the new implementation was available as AsyncHTTPClient2 in Tornado 1.0; both names are supported for backwards compatibility). * The tornado.auth module has had a number of updates, including support for OAuth 2.0 and the Facebook Graph API, and upgrading Twitter and Google support to OAuth 1.0a. * The websocket module is back and supports the latest version (76) of the websocket protocol. Note that this module's interface is different from the websocket module that appeared in pre-1.0 versions of Tornado. * New method RequestHandler.initialize() can be overridden in subclasses to simplify handling arguments from URLSpecs. The sequence of methods called during initialization is documented at http://tornadoweb.org/documentation#overriding-requesthandler-methods * get_argument() and related methods now work on PUT requests in addition to POST. * The httpclient module now supports HTTP proxies. * When HTTPServer is run in SSL mode, the SSL handshake is now non-blocking. * Many smaller bug fixes and documentation updates Backwards-compatibility notes: * While most users of Tornado should not have to deal with the stack_context module directly, users of worker thread pools and similar constructs may need to use stack_context.wrap and/or NullContext to avoid memory leaks. * The new AsyncHTTPClient still works with libcurl version 7.16.x, but it performs better when both libcurl and pycurl are at least version 7.18.2. * OAuth transactions started under previous versions of the auth module cannot be completed under the new module. This applies only to the initial authorization process; once an authorized token is issued that token works with either version. Many thanks to everyone who contributed patches, bug reports, and feedback that went into this release! -Ben
We are pleased to announce the release of Tornado 1.0, available from https://github.com/downloads/facebook/tornado/tornado-1.0.tar.gz. There have bee
We are pleased to announce the release of Tornado 1.0, available
from
https://github.com/downloads/facebook/tornado/tornado-1.0.tar.gz.
There have been many changes since version 0.2; here are some of
the highlights:
New features:
* Improved support for running other WSGI applications in a
Tornado server (tested with Django and CherryPy)
* Improved performance on Mac OS X and BSD (kqueue-based IOLoop),
and experimental support for win32
* Rewritten AsyncHTTPClient available as
tornado.httpclient.AsyncHTTPClient2 (this will become the
default in a future release)
* Support for standard .mo files in addition to .csv in the locale
module
* Pre-forking support for running multiple Tornado processes at
once (see HTTPServer.start())
* SSL and gzip support in HTTPServer
* reverse_url() function refers to urls from the Application
config by name from templates and RequestHandlers
* RequestHandler.on_connection_close() callback is called when the
client has closed the connection (subject to limitations of the
underlying network stack, any proxies, etc)
* Static files can now be served somewhere other than /static/ via
the static_url_prefix application setting
* URL regexes can now use named groups ("(?P<name>)") to pass
arguments to get()/post() via keyword instead of position
* HTTP header dictionary-like objects now support multiple values
for the same header via the get_all() and add() methods.
* Several new options in the httpclient module, including
prepare_curl_callback and header_callback
* Improved logging configuration in tornado.options.
* UIModule.html_body() can be used to return html to be inserted
at the end of the document body.
Backwards-incompatible changes:
* RequestHandler.get_error_html() now receives the exception
object as a keyword argument if the error was caused by an
uncaught exception.
* Secure cookies are now more secure, but incompatible with
cookies set by Tornado 0.2. To read cookies set by older
versions of Tornado, pass include_name=False to
RequestHandler.get_secure_cookie()
* Parameters passed to RequestHandler.get/post() by extraction
from the path now have %-escapes decoded, for consistency with
the processing that was already done with other query
parameters.
Many thanks to everyone who contributed patches, bug reports, and
feedback that went into this release!
-Ben
Nothing published for this version
One column per quarter.