Context manager to capture and suppress expected log output. Useful to make tests of error conditions less noisy, while still leaving unexpec

r"""A collection of request handlers that make up a web application. Instances of this class are callable and can be passed directly to HTTPS

A template loader that loads from a dictionary.

An exception that will turn into an HTTP error response. Raising an `HTTPError` is a convenient alternative to calling `RequestHandler.send_e

r"""Socket-based `IOStream` implementation. This class supports the read and write methods from `BaseIOStream` plus a `connect` method.

A compiled template. We compile into Python from the given template_string. You can generate the template from variables with generate().

HTTP client request object.

A collection of options, a dictionary with object-like access. Normally accessed via static functions in the `tornado.options` module, which

Non-blocking HTTP client with no external dependencies. This class implements an HTTP 1.1 client on top of Tornado's IOStreams. Some features

An event blocks coroutines until its internal flag is set to True. Similar to `threading.Event`. A coroutine can wait for an event to be set

Log exception

An I/O event loop. As of Tornado 6.0, `IOLoop` is a wrapper around the `asyncio` event loop. Example usage for a simple TCP server: ..

A dictionary that maintains ``Http-Header-Case`` for all keys. Supports multiple values per key via a pair of new methods, `add()` and `get_l

A formatting error such as invalid format string. */

Schedules the given callback to be called periodically. The callback is called every ``callback_time`` milliseconds when ``callback_time`` is

Exception raised by errors in the options module.

Matches requests with paths specified by ``path_pattern`` regex.

A utility class to write to and read from a non-blocking SSL socket. If the socket passed to the constructor is already connected, it should

Wraps ``subprocess.Popen`` with IOStream support. The constructor is the same as ``subprocess.Popen`` with the following additions: * ``

An non-blocking HTTP client. Example usage:: async def f(): http_client = AsyncHTTPClient() try:

HTTP Response object. Attributes: * ``request``: HTTPRequest object * ``code``: numeric HTTP status code, e.g. 200 or 404 * ``reas

r"""A non-blocking, single-threaded HTTP server. A server is defined by a subclass of `.HTTPServerConnectionDelegate`, or, for backwards comp

A routing rule.

Combines an object with a dictionary of defaults. Used internally by AsyncHTTPClient implementations.

Raised by operations on a closed connection. .. versionadded:: 3.2

Used with the ``with`` statement when calling delegate methods to log any exceptions with the given logger. Any exceptions caught are convert

A handmade floating-point number f * pow(2, e).

Exception class for malformed HTTP requests or responses from remote sources. .. versionadded:: 4.0

Makes a dictionary behave like an object, with attribute-style access.

Pipe-based `IOStream` implementation. The constructor takes an integer file descriptor (such as one returned by `os.pipe`) rather than an ope

Default `Resolver` implementation, using `socket.getaddrinfo`. The `.IOLoop` will be blocked during the resolution, although the callback wil

Implements the HTTP/1.x protocol. This class can be on its own for clients, or via `HTTP1ServerConnection` for servers.

Parameters for `.HTTP1Connection` and `.HTTP1ServerConnection`.

Exception raised by `IOStream` methods when the stream is closed. Note that the close callback is scheduled to run *after* other callbacks on

A non-blocking TCP connection factory. .. versionchanged:: 5.0 The ``io_loop`` argument (deprecated since version 4.1) has been removed.

Routing implementation used internally by `Application`. Provides a binding between `Application` and `RequestHandler`. This implementation e

A Windows error. */

``AsyncIOLoop`` is an `.IOLoop` that runs on an ``asyncio`` event loop. This class follows the usual Tornado semantics for creating new ``IOLo

Generates an error response with ``status_code`` for all requests.

A blocking HTTP client. This interface is provided to make it easier to share code between synchronous and asynchronous applications. Applica

A single HTTP request. All attributes are type `str` unless otherwise noted. .. attribute:: method HTTP request method, e.g. "GET" o

Log formatter used in Tornado. Key features of this formatter are: * Color support when logging to a terminal that supports it. * Timest

Raised for template syntax errors. ``ParseError`` instances have ``filename`` and ``lineno`` attributes indicating the position of the error.

Configurable asynchronous DNS resolver interface. By default, a blocking implementation is used (which simply calls `socket.getaddrinfo`). A

Locale implementation using tornado's CSV translation format.

An exception that ends the request without producing an error response. When `Finish` is raised in a `RequestHandler`, the request will end (

Error raised by SimpleAsyncHTTPClient when the underlying stream is closed. When a more specific exception is available (such as `ConnectionReset

Error raised by SimpleAsyncHTTPClient on timeout. For historical reasons, this is a subclass of `.HTTPClientError` which simulates a response

Matches requests from hosts specified by ``host_pattern`` regex.

Wraps a resolver with a mapping of overrides. This can be used to make local DNS changes (e.g. for testing) without modifying system-wide set

Coordinate producer and consumer coroutines. If maxsize is 0 (the default) the queue size is unbounded. .. testcode:: import asynci

Exception raised by `IOStream` methods when the buffer is full.