Tornado

https://tornado-doc.readthedocs.io/en/latest/
Admin
Tornado is a Python web framework and asynchronous networking library that uses non-blocking I/O to...
Tokens:150,085
Snippets:1,364
Trust Score:8.3
Update:2 months ago
Show doc for...
Tokens:
Raw
### Install Tornado from Source

Source: https://tornado-doc.readthedocs.io/en/latest/_sources/index.rst.txt

Manual installation steps for building and installing Tornado from a downloaded source tarball.

```bash
tar xvzf tornado-|version|.tar.gz
cd tornado-|version|
python setup.py build
sudo python setup.py install
```

--------------------------------

### Initialize TCPServer with bind and start

Source: https://tornado-doc.readthedocs.io/en/latest/_modules/tornado/tcpserver.html

Use bind and start for simple multi-process setups; do not pass an IOLoop to the constructor.

```python
server = TCPServer()
server.bind(8888)
server.start(0)  # Forks multiple sub-processes
IOLoop.instance().start()
```

--------------------------------

### Initialize and start a simple HTTPServer

Source: https://tornado-doc.readthedocs.io/en/latest/_modules/tornado/httpserver.html

Demonstrates the standard way to bind and start an HTTPServer, which forks multiple sub-processes.

```python
server = HTTPServer(app)
server.bind(8888)
server.start(0)  # Forks multiple sub-processes
IOLoop.instance().start()
```

--------------------------------

### Initialize and start a Tornado Application

Source: https://tornado-doc.readthedocs.io/en/latest/web.html

Create an Application instance with a list of handlers and start the HTTPServer.

```python
application = web.Application([
    (r"/", MainPageHandler),
])
http_server = httpserver.HTTPServer(application)
http_server.listen(8080)
ioloop.IOLoop.instance().start()
```

--------------------------------

### Application Configuration Examples

Source: https://tornado-doc.readthedocs.io/en/latest/_modules/tornado/web.html

Examples for initializing a Tornado Application, including basic routing, static file handling, and virtual host configuration.

```python
application = web.Application([
    (r"/", MainPageHandler),
])
http_server = httpserver.HTTPServer(application)
http_server.listen(8080)
ioloop.IOLoop.instance().start()
```

```python
application = web.Application([
    (r"/static/(.*)", web.StaticFileHandler, {"path": "/var/www"}),
])
```

```python
application.add_handlers(r"www\.myhost\.com", [
    (r"/article/([0-9]+)", ArticleHandler),
])
```

--------------------------------

### start()

Source: https://tornado-doc.readthedocs.io/en/latest/_modules/tornado/ioloop.html

Starts the periodic timer.

```APIDOC
### Method
start()

### Description
Begins the execution of the periodic callback. This must be called after the PeriodicCallback object is initialized.
```

--------------------------------

### HTTPServer initialization patterns

Source: https://tornado-doc.readthedocs.io/en/latest/httpserver.html

Demonstrates the three primary patterns for initializing and starting an HTTPServer.

```python
server = HTTPServer(app)
server.listen(8888)
IOLoop.instance().start()
```

```python
server = HTTPServer(app)
server.bind(8888)
server.start(0)  # Forks multiple sub-processes
IOLoop.instance().start()
```

```python
sockets = tornado.netutil.bind_sockets(8888)
tornado.process.fork_processes(0)
server = HTTPServer(app)
server.add_sockets(sockets)
IOLoop.instance().start()
```

--------------------------------

### Install TornadoReactor

Source: https://tornado-doc.readthedocs.io/en/latest/_sources/twisted.rst.txt

Initialize the TornadoReactor to run Twisted applications on top of the Tornado IOLoop.

```python
import tornado.platform.twisted
tornado.platform.twisted.install()
from twisted.internet import reactor
```

--------------------------------

### TCPServer.start

Source: https://tornado-doc.readthedocs.io/en/latest/_modules/tornado/tcpserver.html

Starts the server in the IOLoop.

```APIDOC
## start(num_processes=1)

### Description
Starts the server in the IOLoop. If num_processes is set to a value other than 1, the server will fork multiple child processes.

### Parameters
- **num_processes** (int) - Optional - The number of processes to fork. If <= 0, it defaults to the number of available CPU cores.
```

--------------------------------

### Install Tornado via Pip

Source: https://tornado-doc.readthedocs.io/en/latest/_sources/index.rst.txt

Standard command to install the Tornado package from PyPI.

```bash
pip install tornado
```

--------------------------------

### Configure HTTPServer with SSL

Source: https://tornado-doc.readthedocs.io/en/latest/_modules/tornado/httpserver.html

Example of initializing an HTTPServer with SSL options, including client certificate requirements.

```python
server = HTTPServer(app,
    ssl_options=dict(
        certfile="foo.crt",
        keyfile="foo.key",
        cert_reqs=ssl.CERT_REQUIRED,
        ca_certs="cacert.crt"))
```

--------------------------------

### Start HTTP Server

Source: https://tornado-doc.readthedocs.io/en/latest/_modules/tornado/web.html

Convenience method to start an HTTPServer. Requires a subsequent call to IOLoop.instance().start() to begin processing.

```python
    def listen(self, port, address="", **kwargs):
        """Starts an HTTP server for this application on the given port.

        This is a convenience alias for creating an `.HTTPServer`
        object and calling its listen method.  Keyword arguments not
        supported by `HTTPServer.listen <.TCPServer.listen>` are passed to the
        `.HTTPServer` constructor.  For advanced uses
        (e.g. multi-process mode), do not use this method; create an
        `.HTTPServer` and call its
        `.TCPServer.bind`/`.TCPServer.start` methods directly.

        Note that after calling this method you still need to call
        ``IOLoop.instance().start()`` to start the server.
        """
        # import is here rather than top level because HTTPServer
        # is not importable on appengine
        from tornado.httpserver import HTTPServer
        server = HTTPServer(self, **kwargs)
        server.listen(port, address)
```

--------------------------------

### Define Option Help Format

Source: https://tornado-doc.readthedocs.io/en/latest/options.html

Example of the automatically generated command line help string format.

```text
--name=METAVAR      help string

```

--------------------------------

### Template Inheritance Example

Source: https://tornado-doc.readthedocs.io/en/latest/_modules/tornado/template.html

Example of a base template and a child template extending it.

```html
### base.html
<html>
  <head>
    <title>{% block title %}Default title{% end %}</title>
  </head>
  <body>
    <ul>
      {% for student in students %}
        {% block student %}
          <li>{{ escape(student.name) }}</li>
        {% end %}
      {% end %}
    </ul>
  </body>
</html>
```

```html
### bold.html
{% extends "base.html" %}

{% block title %}A bolder title{% end %}

{% block student %}
  <li><span style="bold">{{ escape(student.name) }}</span></li>
{% end %}
```

--------------------------------

### Start the TCPServer

Source: https://tornado-doc.readthedocs.io/en/latest/_modules/tornado/tcpserver.html

Starts the server in the IOLoop, optionally forking multiple processes.

```python
    def start(self, num_processes=1):
        """Starts this server in the `.IOLoop`.

        By default, we run the server in this process and do not fork any
        additional child process.

        If num_processes is ``None`` or <= 0, we detect the number of cores
        available on this machine and fork that number of child
        processes. If num_processes is given and > 1, we fork that
        specific number of sub-processes.

        Since we use processes and not threads, there is no shared memory
        between any server code.

        Note that multiple processes are not compatible with the autoreload
        module (or the ``debug=True`` option to `tornado.web.Application`).
        When using multiple processes, no IOLoops can be created or
        referenced until after the call to ``TCPServer.start(n)``.
        """
        assert not self._started
        self._started = True
        if num_processes != 1:
            process.fork_processes(num_processes)
        sockets = self._pending_sockets
        self._pending_sockets = []
        self.add_sockets(sockets)
```

--------------------------------

### Install TwistedIOLoop

Source: https://tornado-doc.readthedocs.io/en/latest/_sources/twisted.rst.txt

Configure the Tornado IOLoop to run on top of the Twisted reactor.

```python
from tornado.platform.twisted import TwistedIOLoop
from twisted.internet import reactor
TwistedIOLoop().install()
# Set up your tornado application as usual using `IOLoop.instance`
reactor.run()
```

--------------------------------

### Initialize TCPServer with listen

Source: https://tornado-doc.readthedocs.io/en/latest/_modules/tornado/tcpserver.html

Use the listen method for simple single-process server setups.

```python
server = TCPServer()
server.listen(8888)
IOLoop.instance().start()
```

--------------------------------

### TCPServer.listen

Source: https://tornado-doc.readthedocs.io/en/latest/tcpserver.html

Starts accepting connections on the given port.

```APIDOC
## listen(port, address='')

### Description
Starts accepting connections on the specified port. This method takes effect immediately and does not require a subsequent call to start().

### Parameters
- **port** (int) - Required - The port to listen on.
- **address** (str) - Optional - The address to bind to.
```

--------------------------------

### Command-line HTTP client example

Source: https://tornado-doc.readthedocs.io/en/latest/_modules/tornado/httpclient.html

A script demonstrating how to use HTTPClient to fetch URLs from the command line with configurable options.

```python
def main():
    from tornado.options import define, options, parse_command_line
    define("print_headers", type=bool, default=False)
    define("print_body", type=bool, default=True)
    define("follow_redirects", type=bool, default=True)
    define("validate_cert", type=bool, default=True)
    args = parse_command_line()
    client = HTTPClient()
    for arg in args:
        try:
            response = client.fetch(arg,
                                    follow_redirects=options.follow_redirects,
                                    validate_cert=options.validate_cert,
                                    )
        except HTTPError as e:
            if e.response is not None:
                response = e.response
            else:
                raise
        if options.print_headers:
            print(response.headers)
        if options.print_body:
            print(response.body)
    client.close()

if __name__ == "__main__":
    main()
```

--------------------------------

### Initialize HTTPServer for single-process

Source: https://tornado-doc.readthedocs.io/en/latest/_modules/tornado/httpserver.html

Standard pattern for starting a single-process server using the listen method.

```python
server = HTTPServer(app)
server.listen(8888)
IOLoop.instance().start()
```

--------------------------------

### Task Equivalence Example

Source: https://tornado-doc.readthedocs.io/en/latest/_modules/tornado/gen.html

Demonstrates how a Task is equivalent to a Callback and Wait pair.

```python
result = yield gen.Task(func, args)

func(args, callback=(yield gen.Callback(key)))
result = yield gen.Wait(key)
```

--------------------------------

### IOLoop.start()

Source: https://tornado-doc.readthedocs.io/en/latest/_modules/tornado/ioloop.html

Starts the I/O loop. The loop will run until one of the callbacks calls stop().

```APIDOC
## IOLoop.start()

### Description
Starts the I/O loop. The loop will run until one of the callbacks calls stop(), which will make the loop stop after the current event iteration completes.
```

--------------------------------

### Example configuration file format

Source: https://tornado-doc.readthedocs.io/en/latest/_modules/tornado/options.html

Configuration files are standard Python files where global variable assignments define option values.

```python
myoption = "myvalue"
myotheroption = "myothervalue"
```

--------------------------------

### Facebook Graph Login Handler Example

Source: https://tornado-doc.readthedocs.io/en/latest/_modules/tornado/auth.html

Example implementation of a login handler using FacebookGraphMixin to authenticate users.

```python
class FacebookGraphLoginHandler(LoginHandler, tornado.auth.FacebookGraphMixin):
              @tornado.web.asynchronous
              @tornado.gen.coroutine
              def get(self):
                  if self.get_argument("code", False):
                      user = yield self.get_authenticated_user(
                          redirect_uri='/auth/facebookgraph/',
                          client_id=self.settings["facebook_api_key"],
                          client_secret=self.settings["facebook_secret"],
                          code=self.get_argument("code"))
                      # Save the user with e.g. set_secure_cookie
                  else:
                      yield self.authorize_redirect(
                          redirect_uri='/auth/facebookgraph/',
                          client_id=self.settings["facebook_api_key"],
                          extra_params={"scope": "read_stream,offline_access"})
```

--------------------------------

### tornado.platform.twisted.install()

Source: https://tornado-doc.readthedocs.io/en/latest/_sources/twisted.rst.txt

Installs the TornadoReactor as the global Twisted reactor, allowing Twisted applications to run on the Tornado IOLoop.

```APIDOC
## tornado.platform.twisted.install()

### Description
Installs the TornadoReactor as the global Twisted reactor. This must be called at the beginning of the application before importing the reactor.

### Usage
```python
import tornado.platform.twisted
tornado.platform.twisted.install()
from twisted.internet import reactor
```
```

--------------------------------

### IOLoop.run_sync(func, timeout=None)

Source: https://tornado-doc.readthedocs.io/en/latest/_modules/tornado/ioloop.html

Starts the IOLoop, runs the given function, and stops the loop.

```APIDOC
## IOLoop.run_sync(func, timeout=None)

### Description
Starts the IOLoop, runs the given function, and stops the loop. If the function returns a Future, the IOLoop will run until the future is resolved. If it raises an exception, the IOLoop will stop and the exception will be re-raised to the caller.

### Parameters
- **func** (callable) - Required - The function to run.
- **timeout** (float) - Optional - Maximum duration for the function in seconds.
```

--------------------------------

### Create a Hello World Web Application

Source: https://tornado-doc.readthedocs.io/en/latest/_sources/index.rst.txt

A minimal Tornado application that listens on port 8888 and responds to GET requests at the root URL.

```python
import tornado.ioloop
import tornado.web

class MainHandler(tornado.web.RequestHandler):
    def get(self):
        self.write("Hello, world")

application = tornado.web.Application([
    (r"/", MainHandler),
])

if __name__ == "__main__":
    application.listen(8888)
    tornado.ioloop.IOLoop.instance().start()
```

--------------------------------

### Configure RedirectHandler

Source: https://tornado-doc.readthedocs.io/en/latest/_modules/tornado/web.html

Example of mapping a path to a RedirectHandler in the Application configuration.

```python
application = web.Application([
    (r"/oldpath", web.RedirectHandler, {"url": "/newpath"}),
]);
```

--------------------------------

### Configure StaticFileHandler

Source: https://tornado-doc.readthedocs.io/en/latest/_modules/tornado/web.html

Example of mapping a path to a StaticFileHandler to serve files from a specific directory.

```python
application = web.Application([
    (r"/content/(.*)", web.StaticFileHandler, {"path": "/var/www"}),
]);
```

--------------------------------

### Wrap Socket for SSLIOStream

Source: https://tornado-doc.readthedocs.io/en/latest/_modules/tornado/iostream.html

Example of wrapping an existing connected socket before initializing SSLIOStream.

```python
ssl.wrap_socket(sock, do_handshake_on_connect=False, **kwargs)
```

--------------------------------

### Application.listen(port, address='', **kwargs)

Source: https://tornado-doc.readthedocs.io/en/latest/_modules/tornado/web.html

Starts an HTTP server for the application on the specified port. This is a convenience method that wraps the HTTPServer class.

```APIDOC
## Application.listen

### Description
Starts an HTTP server for this application on the given port. Note that after calling this method, you must call IOLoop.instance().start() to begin the event loop.

### Parameters
- **port** (int) - Required - The port number to listen on.
- **address** (str) - Optional - The address to bind to. Defaults to empty string (all interfaces).
- **kwargs** (dict) - Optional - Additional keyword arguments passed to the HTTPServer constructor.
```

--------------------------------

### Forking and Managing Child Processes

Source: https://tornado-doc.readthedocs.io/en/latest/_modules/tornado/process.html

Example logic for spawning multiple child processes and monitoring them for exit status or signals.

```python
def start_child(i):
    pid = os.fork()
    if pid == 0:
        # child process
        _reseed_random()
        global _task_id
        _task_id = i
        return i
    else:
        children[pid] = i
        return None
for i in range(num_processes):
    id = start_child(i)
    if id is not None:
        return id
num_restarts = 0
while children:
    try:
        pid, status = os.wait()
    except OSError as e:
        if e.errno == errno.EINTR:
            continue
        raise
    if pid not in children:
        continue
    id = children.pop(pid)
    if os.WIFSIGNALED(status):
        gen_log.warning("child %d (pid %d) killed by signal %d, restarting",
                        id, pid, os.WTERMSIG(status))
    elif os.WEXITSTATUS(status) != 0:
        gen_log.warning("child %d (pid %d) exited with status %d, restarting",
                        id, pid, os.WEXITSTATUS(status))
    else:
        gen_log.info("child %d (pid %d) exited normally", id, pid)
        continue
    num_restarts += 1
    if num_restarts > max_restarts:
        raise RuntimeError("Too many child restarts, giving up")
    new_id = start_child(id)
    if new_id is not None:
        return new_id
# All child processes exited cleanly, so exit the master process
# instead of just returning to right after the call to
# fork_processes (which will probably just start up another IOLoop
# unless the caller checks the return value).
sys.exit(0)
```

--------------------------------

### Implement Google OpenID Authentication

Source: https://tornado-doc.readthedocs.io/en/latest/_modules/tornado/auth.html

Example of using GoogleMixin to handle OpenID authentication within a RequestHandler.

```python
class GoogleLoginHandler(tornado.web.RequestHandler,
                         tornado.auth.GoogleMixin):
    @tornado.web.asynchronous
    @tornado.gen.coroutine
    def get(self):
        if self.get_argument("openid.mode", None):
            user = yield self.get_authenticated_user()
            # Save the user with e.g. set_secure_cookie()
        else:
            yield self.authenticate_redirect()
```

--------------------------------

### Start the IOLoop event loop

Source: https://tornado-doc.readthedocs.io/en/latest/_modules/tornado/ioloop.html

Initializes the event loop, configures logging if necessary, and manages signal wakeup file descriptors before entering the main execution loop.

```python
def start(self):
        if not logging.getLogger().handlers:
            # The IOLoop catches and logs exceptions, so it's
            # important that log output be visible.  However, python's
            # default behavior for non-root loggers (prior to python
            # 3.2) is to print an unhelpful "no handlers could be
            # found" message rather than the actual log entry, so we
            # must explicitly configure logging if we've made it this
            # far without anything.
            logging.basicConfig()
        if self._stopped:
            self._stopped = False
            return
        old_current = getattr(IOLoop._current, "instance", None)
        IOLoop._current.instance = self
        self._thread_ident = thread.get_ident()
        self._running = True

        # signal.set_wakeup_fd closes a race condition in event loops:
        # a signal may arrive at the beginning of select/poll/etc
        # before it goes into its interruptible sleep, so the signal
        # will be consumed without waking the select.  The solution is
        # for the (C, synchronous) signal handler to write to a pipe,
        # which will then be seen by select.
        #
        # In python's signal handling semantics, this only matters on the
        # main thread (fortunately, set_wakeup_fd only works on the main
        # thread and will raise a ValueError otherwise).
        #
        # If someone has already set a wakeup fd, we don't want to
        # disturb it.  This is an issue for twisted, which does its
        # SIGCHILD processing in response to its own wakeup fd being
        # written to.  As long as the wakeup fd is registered on the IOLoop,
        # the loop will still wake up and everything should work.
        old_wakeup_fd = None
        if hasattr(signal, 'set_wakeup_fd') and os.name == 'posix':
            # requires python 2.6+, unix.  set_wakeup_fd exists but crashes
            # the python process on windows.
            try:
                old_wakeup_fd = signal.set_wakeup_fd(self._waker.write_fileno())
                if old_wakeup_fd != -1:
                    # Already set, restore previous value.  This is a little racy,
                    # but there's no clean get_wakeup_fd and in real use the
                    # IOLoop is just started once at the beginning.
                    signal.set_wakeup_fd(old_wakeup_fd)
                    old_wakeup_fd = None
            except ValueError:  # non-main thread
                pass

        while True:
            poll_timeout = 3600.0

            # Prevent IO event starvation by delaying new callbacks
            # to the next iteration of the event loop.
            with self._callback_lock:
                callbacks = self._callbacks
                self._callbacks = []
            for callback in callbacks:
                self._run_callback(callback)

            if self._timeouts:
                now = self.time()
                while self._timeouts:
                    if self._timeouts[0].callback is None:
                        # the timeout was cancelled
                        heapq.heappop(self._timeouts)
                        self._cancellations -= 1
                    elif self._timeouts[0].deadline <= now:
                        timeout = heapq.heappop(self._timeouts)
                        self._run_callback(timeout.callback)
                    else:
                        seconds = self._timeouts[0].deadline - now
                        poll_timeout = min(seconds, poll_timeout)
                        break
                if (self._cancellations > 512
                        and self._cancellations > (len(self._timeouts) >> 1)):
                    # Clean up the timeout queue when it gets large and it's
                    # more than half cancellations.
                    self._cancellations = 0
                    self._timeouts = [x for x in self._timeouts
                                      if x.callback is not None]
                    heapq.heapify(self._timeouts)

            if self._callbacks:
                # If any callbacks or timeouts called add_callback,
                # we don't want to wait in poll() before we run them.
                poll_timeout = 0.0

            if not self._running:
                break
```

--------------------------------

### Define a Tornado template structure

Source: https://tornado-doc.readthedocs.io/en/latest/overview.html

Example of an HTML file using Tornado template syntax for loops and variable output.

```html
<html>
   <head>
      <title>{{ title }}</title>
   </head>
   <body>
     <ul>
       {% for item in items %}
         <li>{{ escape(item) }}</li>
       {% end %}
     </ul>
   </body>
 </html>
```

--------------------------------

### TCPServer.listen(port, address="")

Source: https://tornado-doc.readthedocs.io/en/latest/_modules/tornado/tcpserver.html

Starts accepting connections on the specified port and address. This method can be called multiple times to listen on different ports.

```APIDOC
## TCPServer.listen

### Description
Starts accepting connections on the given port. This method may be called more than once to listen on multiple ports. It takes effect immediately; it is not necessary to call TCPServer.start afterwards, but the IOLoop must be started.

### Parameters
- **port** (int) - Required - The port number to listen on.
- **address** (str) - Optional - The address to bind to. Defaults to "" (all interfaces).
```

--------------------------------

### Basic Template Usage

Source: https://tornado-doc.readthedocs.io/en/latest/_modules/tornado/template.html

Demonstrates creating a Template instance and generating output with variables.

```python
t = template.Template("<html>{{ myvalue }}</html>")
print t.generate(myvalue="XXX")
```

--------------------------------

### Initialize Application with Static File Support

Source: https://tornado-doc.readthedocs.io/en/latest/_modules/tornado/web.html

The Application constructor handles static file routing and UI module loading based on provided settings.

```python
    def __init__(self, handlers=None, default_host="", transforms=None,
                 wsgi=False, **settings):
        if transforms is None:
            self.transforms = []
            if settings.get("gzip"):
                self.transforms.append(GZipContentEncoding)
            self.transforms.append(ChunkedTransferEncoding)
        else:
            self.transforms = transforms
        self.handlers = []
        self.named_handlers = {}
        self.default_host = default_host
        self.settings = settings
        self.ui_modules = {'linkify': _linkify,
                           'xsrf_form_html': _xsrf_form_html,
                           'Template': TemplateModule,
                           }
        self.ui_methods = {}
        self._wsgi = wsgi
        self._load_ui_modules(settings.get("ui_modules", {}))
        self._load_ui_methods(settings.get("ui_methods", {}))
        if self.settings.get("static_path"):
            path = self.settings["static_path"]
            handlers = list(handlers or [])
            static_url_prefix = settings.get("static_url_prefix",
                                             "/static/")
            static_handler_class = settings.get("static_handler_class",
                                                StaticFileHandler)
            static_handler_args = settings.get("static_handler_args", {})
            static_handler_args['path'] = path
            for pattern in [re.escape(static_url_prefix) + r"(.*)",
                            r"/(favicon\.ico)", r"/(robots\.txt)"]:
                handlers.insert(0, (pattern, static_handler_class,
                                    static_handler_args))
        if handlers:
            self.add_handlers(".*$", handlers)

        # Automatically reload modified modules
        if self.settings.get("debug") and not wsgi:
            from tornado import autoreload
            autoreload.start()
```

--------------------------------

### tornado.testing.get_async_test_timeout

Source: https://tornado-doc.readthedocs.io/en/latest/testing.html

Get the global timeout setting for async tests.

```APIDOC
## tornado.testing.get_async_test_timeout()

### Description
Get the global timeout setting for async tests.

### Returns
- **float** - The timeout in seconds.
```

--------------------------------

### Create a basic echo HTTP server

Source: https://tornado-doc.readthedocs.io/en/latest/_modules/tornado/httpserver.html

Demonstrates initializing an HTTPServer with a request callback to echo the requested URI.

```python
import tornado.httpserver
import tornado.ioloop

def handle_request(request):
   message = "You requested %s\n" % request.uri
   request.write("HTTP/1.1 200 OK\r\nContent-Length: %d\r\n\r\n%s" % (
                 len(message), message))
   request.finish()

http_server = tornado.httpserver.HTTPServer(handle_request)
http_server.listen(8888)
tornado.ioloop.IOLoop.instance().start()
```

--------------------------------

### Implement a simple TCP server with IOLoop

Source: https://tornado-doc.readthedocs.io/en/latest/_modules/tornado/ioloop.html

Demonstrates setting up a non-blocking TCP server and registering it with the IOLoop instance to handle incoming connections.

```python
import errno
import functools
import ioloop
import socket

def connection_ready(sock, fd, events):
    while True:
        try:
            connection, address = sock.accept()
        except socket.error, e:
            if e.args[0] not in (errno.EWOULDBLOCK, errno.EAGAIN):
                raise
            return
        connection.setblocking(0)
        handle_connection(connection, address)

sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM, 0)
sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
sock.setblocking(0)
sock.bind(("", port))
sock.listen(128)

io_loop = ioloop.IOLoop.instance()
callback = functools.partial(connection_ready, sock)
io_loop.add_handler(sock.fileno(), callback, io_loop.READ)
io_loop.start()
```

--------------------------------

### Configure HTTPServer with SSL

Source: https://tornado-doc.readthedocs.io/en/latest/_modules/tornado/httpserver.html

Shows how to enable SSL traffic by passing an ssl_options dictionary containing certificate and key file paths.

```python
HTTPServer(applicaton, ssl_options={
    "certfile": os.path.join(data_dir, "mydomain.crt"),
    "keyfile": os.path.join(data_dir, "mydomain.key"),
})
```

--------------------------------

### TCPServer.__init__

Source: https://tornado-doc.readthedocs.io/en/latest/tcpserver.html

Initializes a new TCPServer instance.

```APIDOC
## TCPServer(io_loop=None, ssl_options=None, max_buffer_size=None)

### Description
Initializes the TCPServer. To use, define a subclass and override the handle_stream method.

### Parameters
- **io_loop** (IOLoop) - Optional - The IOLoop instance to use.
- **ssl_options** (dict) - Optional - Dictionary containing arguments for ssl.wrap_socket (e.g., certfile, keyfile).
- **max_buffer_size** (int) - Optional - Maximum buffer size for incoming data.
```

--------------------------------

### HTTPServer.__init__

Source: https://tornado-doc.readthedocs.io/en/latest/_modules/tornado/httpserver.html

Initializes a new HTTPServer instance to handle HTTP requests.

```APIDOC
## HTTPServer.__init__

### Description
Initializes the HTTPServer with a request callback and optional configuration for keep-alive, headers, and SSL.

### Parameters
- **request_callback** (callable) - Required - Function called for each request.
- **no_keep_alive** (bool) - Optional - If True, disables keep-alive connections.
- **io_loop** (IOLoop) - Optional - The IOLoop instance to use.
- **xheaders** (bool) - Optional - If True, supports X-Real-IP and X-Scheme headers.
- **ssl_options** (dict) - Optional - SSL configuration options.
- **protocol** (str) - Optional - The protocol to use (e.g., 'http' or 'https').
```

--------------------------------

### tornado.options.print_help

Source: https://tornado-doc.readthedocs.io/en/latest/options.html

Prints all command line options to a file.

```APIDOC
## tornado.options.print_help(file=sys.stderr)

### Description
Prints all the command line options to the specified file, defaulting to stderr.

### Parameters
- **file** (file-like) - Optional - The file object to print help to.
```

--------------------------------

### IOLoop.stop()

Source: https://tornado-doc.readthedocs.io/en/latest/_modules/tornado/ioloop.html

Stops the I/O loop. If the loop is not running, the next call to start() will return immediately.

```APIDOC
## IOLoop.stop()

### Description
Stop the I/O loop. If the event loop is not currently running, the next call to start() will return immediately.
```

--------------------------------

### TCPServer.add_sockets(sockets)

Source: https://tornado-doc.readthedocs.io/en/latest/_modules/tornado/tcpserver.html

Configures the server to start accepting connections on a provided list of pre-bound sockets.

```APIDOC
## TCPServer.add_sockets

### Description
Makes this server start accepting connections on the given sockets.

### Parameters
- **sockets** (list) - Required - A list of socket objects to be used by the server.
```

--------------------------------

### FallbackHandler Usage

Source: https://tornado-doc.readthedocs.io/en/latest/_modules/tornado/web.html

Example of using FallbackHandler to integrate WSGI applications within a Tornado server.

```python
wsgi_app = tornado.wsgi.WSGIContainer(
    django.core.handlers.wsgi.WSGIHandler())
application = tornado.web.Application([
    (r"/foo", FooHandler),
    (r".*", FallbackHandler, dict(fallback=wsgi_app),
])
```

```python
def initialize(self, fallback):
    self.fallback = fallback

def prepare(self):
    self.fallback(self.request)
    self._finished = True
```

--------------------------------

### print_help(file=None)

Source: https://tornado-doc.readthedocs.io/en/latest/_modules/tornado/options.html

Prints all defined command line options to the specified file or stderr.

```APIDOC
### print_help(file=None)

Prints all the command line options to stderr (or another file if provided).
```

--------------------------------

### Twitter Authentication Handler

Source: https://tornado-doc.readthedocs.io/en/latest/_modules/tornado/auth.html

Example implementation of a login handler using TwitterMixin to authenticate users.

```python
class TwitterLoginHandler(tornado.web.RequestHandler,
                          tornado.auth.TwitterMixin):
    @tornado.web.asynchronous
    @tornado.gen.coroutine
    def get(self):
        if self.get_argument("oauth_token", None):
            user = yield self.get_authenticated_user()
            # Save the user using e.g. set_secure_cookie()
        else:
            yield self.authorize_redirect()
```

--------------------------------

### Run a Tornado application with WSGI

Source: https://tornado-doc.readthedocs.io/en/latest/_modules/tornado/wsgi.html

Demonstrates how to use WSGIApplication to serve a Tornado application using wsgiref.simple_server. Note that asynchronous methods are not supported in this mode.

```python
import tornado.web
import tornado.wsgi
import wsgiref.simple_server

class MainHandler(tornado.web.RequestHandler):
    def get(self):
        self.write("Hello, world")

if __name__ == "__main__":
    application = tornado.wsgi.WSGIApplication([
        (r"/", MainHandler),
    ])
    server = wsgiref.simple_server.make_server('', 8888, application)
    server.serve_forever()
```

--------------------------------

### print_help(file=None)

Source: https://tornado-doc.readthedocs.io/en/latest/_modules/tornado/options.html

Prints all the command line options to the specified file (defaults to stderr).

```APIDOC
## print_help(file=None)

### Description
Prints all the command line options to stderr or the provided file object.

### Parameters
- **file** (file object) - Optional - The file object to print the help message to. Defaults to sys.stderr.
```

--------------------------------

### Get Template Namespace

Source: https://tornado-doc.readthedocs.io/en/latest/_modules/tornado/web.html

Returns a dictionary of default variables available in templates, which can be overridden by subclasses.

```python
    def get_template_namespace(self):
        """Returns a dictionary to be used as the default template namespace.

        May be overridden by subclasses to add or modify values.

        The results of this method will be combined with additional
        defaults in the `tornado.template` module and keyword arguments
        to `render` or `render_string`.
        """
        namespace = dict(
            handler=self,
            request=self.request,
            current_user=self.current_user,
            locale=self.locale,
            _=self.locale.translate,
            static_url=self.static_url,
            xsrf_form_html=self.xsrf_form_html,
            reverse_url=self.reverse_url
        )
        namespace.update(self.ui)
        return namespace
```

--------------------------------

### Bind TCPServer to a port

Source: https://tornado-doc.readthedocs.io/en/latest/_modules/tornado/tcpserver.html

Binds the server to a specific port and address, supporting multiple calls before starting.

```python
    def bind(self, port, address=None, family=socket.AF_UNSPEC, backlog=128):
        """Binds this server to the given port on the given address.

        To start the server, call `start`. If you want to run this server
        in a single process, you can call `listen` as a shortcut to the
        sequence of `bind` and `start` calls.

        Address may be either an IP address or hostname.  If it's a hostname,
        the server will listen on all IP addresses associated with the
        name.  Address may be an empty string or None to listen on all
        available interfaces.  Family may be set to either `socket.AF_INET`
        or `socket.AF_INET6` to restrict to IPv4 or IPv6 addresses, otherwise
        both will be used if available.

        The ``backlog`` argument has the same meaning as for
        `socket.listen <socket.socket.listen>`.

        This method may be called multiple times prior to `start` to listen
        on multiple ports or interfaces.
        """
        sockets = bind_sockets(port, address=address, family=family,
                               backlog=backlog)
        if self._started:
            self.add_sockets(sockets)
        else:
            self._pending_sockets.extend(sockets)
```

--------------------------------

### Parse command line or config files

Source: https://tornado-doc.readthedocs.io/en/latest/_modules/tornado/options.html

Applications can initialize options by parsing command-line arguments or loading a Python configuration file.

```python
tornado.options.parse_command_line()
# or
tornado.options.parse_config_file("/etc/server.conf")
```

--------------------------------

### Returning values from a coroutine

Source: https://tornado-doc.readthedocs.io/en/latest/_modules/tornado/gen.html

Example of using gen.Return to return a value from a coroutine in older Python versions.

```python
@gen.coroutine
def fetch_json(url):
    response = yield AsyncHTTPClient().fetch(url)
    raise gen.Return(json_decode(response.body))
```

--------------------------------

### Initialize and access HTTPHeaders

Source: https://tornado-doc.readthedocs.io/en/latest/httputil.html

Demonstrates creating an HTTPHeaders object and accessing keys in a case-insensitive manner.

```python
>>> h = HTTPHeaders({"content-type": "text/html"})
>>> list(h.keys())
['Content-Type']
>>> h["Content-Type"]
'text/html'
```

--------------------------------

### Get Absolute Path

Source: https://tornado-doc.readthedocs.io/en/latest/_modules/tornado/web.html

Resolves the absolute filesystem path for a given relative path and root directory.

```python
    @classmethod
    def get_absolute_path(cls, root, path):
        """Returns the absolute location of ``path`` relative to ``root``.

        ``root`` is the path configured for this `StaticFileHandler`
        (in most cases the ``static_path`` `Application` setting).

        This class method may be overridden in subclasses.  By default
        it returns a filesystem path, but other strings may be used
        as long as they are unique and understood by the subclass's
        overridden `get_content`.

        .. versionadded:: 3.1
        """
        abspath = os.path.abspath(os.path.join(root, path))
        return abspath
```

--------------------------------

### FriendFeed Authentication Handler

Source: https://tornado-doc.readthedocs.io/en/latest/_modules/tornado/auth.html

Example of implementing a login handler using FriendFeedMixin to authenticate users via OAuth.

```python
class FriendFeedLoginHandler(tornado.web.RequestHandler,
                             tornado.auth.FriendFeedMixin):
    @tornado.web.asynchronous
    @tornado.gen.coroutine
    def get(self):
        if self.get_argument("oauth_token", None):
            user = yield self.get_authenticated_user()
            # Save the user using e.g. set_secure_cookie()
        else:
            yield self.authorize_redirect()
```

--------------------------------

### Authenticated Twitter API Request

Source: https://tornado-doc.readthedocs.io/en/latest/_modules/tornado/auth.html

Example of making an authenticated POST request to the Twitter API using twitter_request.

```python
class MainHandler(tornado.web.RequestHandler,
                  tornado.auth.TwitterMixin):
    @tornado.web.authenticated
    @tornado.web.asynchronous
    @tornado.gen.coroutine
    def get(self):
        new_entry = yield self.twitter_request(
            "/statuses/update",
            post_args={"status": "Testing Tornado Web Server"},
            access_token=self.current_user["access_token"])
        if not new_entry:
            # Call failed; perhaps missing permission?
            yield self.authorize_redirect()
            return
        self.finish("Posted a message!")
```

--------------------------------

### Manage HTTP headers with HTTPHeaders

Source: https://tornado-doc.readthedocs.io/en/latest/_modules/tornado/httputil.html

Demonstrates initializing, adding, and retrieving multiple values for HTTP headers while maintaining consistent casing.

```python
>>> h = HTTPHeaders({"content-type": "text/html"})
>>> list(h.keys())
['Content-Type']
>>> h["Content-Type"]
'text/html'

>>> h.add("Set-Cookie", "A=B")
>>> h.add("Set-Cookie", "C=D")
>>> h["set-cookie"]
'A=B,C=D'
>>> h.get_list("set-cookie")
['A=B', 'C=D']

>>> for (k,v) in sorted(h.get_all()):
...    print('%s: %s' % (k,v))
...
Content-Type: text/html
Set-Cookie: A=B
Set-Cookie: C=D
```

--------------------------------

### Asynchronous Test Case Example

Source: https://tornado-doc.readthedocs.io/en/latest/_modules/tornado/testing.html

Demonstrates using AsyncTestCase with the gen_test decorator to perform asynchronous HTTP requests.

```python
# This test uses coroutine style.
class MyTestCase(AsyncTestCase):
    @tornado.testing.gen_test
    def test_http_fetch(self):
        client = AsyncHTTPClient(self.io_loop)
        response = yield client.fetch("http://www.tornadoweb.org")
        # Test contents of response
        self.assertIn("FriendFeed", response.body)
```

--------------------------------

### tornado.autoreload.start

Source: https://tornado-doc.readthedocs.io/en/latest/autoreload.html

Initializes the file monitoring process using the specified IOLoop.

```APIDOC
## tornado.autoreload.start(io_loop=None, check_time=500)

### Description
Begins watching source files for changes using the given IOLoop.

### Parameters
- **io_loop** (IOLoop) - Optional - The IOLoop instance to use for monitoring.
- **check_time** (int) - Optional - The interval in milliseconds to check for file changes.
```

--------------------------------

### Configure RedirectHandler

Source: https://tornado-doc.readthedocs.io/en/latest/web.html

Map a URL pattern to RedirectHandler to automatically redirect GET requests to a specified destination URL.

```python
application = web.Application([
    (r"/oldpath", web.RedirectHandler, {"url": "/newpath"}),
])
```

--------------------------------

### Facebook API Request Method

Source: https://tornado-doc.readthedocs.io/en/latest/_modules/tornado/auth.html

Fetches a relative API path from Facebook, supporting both GET and POST requests.

```python
def facebook_request(self, path, callback, access_token=None,
                         post_args=None, **args):
```

--------------------------------

### tornado.process.fork_processes(num_processes, max_restarts=100)

Source: https://tornado-doc.readthedocs.io/en/latest/process.html

Starts multiple worker processes. If num_processes is None or <= 0, it detects the number of cores available.

```APIDOC
## tornado.process.fork_processes(num_processes, max_restarts=100)

### Description
Starts multiple worker processes. In child processes, it returns the task id. In the parent process, it returns None if all children exit normally.

### Parameters
- **num_processes** (int/None) - The number of processes to fork.
- **max_restarts** (int) - The maximum number of times a process can be restarted.
```

--------------------------------

### Main execution entry point

Source: https://tornado-doc.readthedocs.io/en/latest/_modules/tornado/autoreload.html

Standard entry point for the module execution.

```python
if __name__ == "__main__":
    # See also the other __main__ block at the top of the file, which modifies
    # sys.path before our imports
    main()
```

--------------------------------

### Start and Stop IOLoop for Asynchronous Methods

Source: https://tornado-doc.readthedocs.io/en/latest/_modules/tornado/ioloop.html

Use this pattern to run asynchronous methods from synchronous code, such as in unit tests.

```python
ioloop = IOLoop()
async_method(ioloop=ioloop, callback=ioloop.stop)
ioloop.start()
```

--------------------------------

### Parse HTTP Range Headers

Source: https://tornado-doc.readthedocs.io/en/latest/_modules/tornado/httputil.html

Parses a Range header string into start and end byte indexes suitable for slicing.

```python
>>> start, end = _parse_request_range("bytes=1-2")
>>> start, end
(1, 3)
>>> [0, 1, 2, 3, 4][start:end]
[1, 2]
>>> _parse_request_range("bytes=6-")
(6, None)
>>> _parse_request_range("bytes=-6")
(-6, None)
>>> _parse_request_range("bytes=-0")
(None, 0)
>>> _parse_request_range("bytes=")
(None, None)
>>> _parse_request_range("foo=42")
>>> _parse_request_range("bytes=1-2,6-10")
```

--------------------------------

### tornado.httpserver.HTTPServer

Source: https://tornado-doc.readthedocs.io/en/latest/httpserver.html

Initializes a new HTTPServer instance. The server uses a request_callback to process incoming HTTP requests.

```APIDOC
## HTTPServer(request_callback, no_keep_alive=False, io_loop=None, xheaders=False, ssl_options=None, protocol=None, **kwargs)

### Description
Initializes a non-blocking, single-threaded HTTP server. The server parses headers and bodies, delegating response generation to the provided request_callback.

### Parameters
- **request_callback** (callable) - Required - A function that takes an HTTPRequest instance as an argument.
- **no_keep_alive** (bool) - Optional - If True, disables keep-alive connections.
- **io_loop** (IOLoop) - Optional - The IOLoop instance to use.
- **xheaders** (bool) - Optional - If True, supports X-Real-Ip/X-Forwarded-For headers.
- **ssl_options** (dict/SSLContext) - Optional - SSL configuration for HTTPS support.
- **protocol** (str) - Optional - Overrides the protocol (e.g., 'https').
```

--------------------------------

### Facebook Graph API Request Handler

Source: https://tornado-doc.readthedocs.io/en/latest/_modules/tornado/auth.html

Example of using FacebookGraphMixin to post to a user's feed within a RequestHandler.

```python
class MainHandler(tornado.web.RequestHandler,
                  tornado.auth.FacebookGraphMixin):
    @tornado.web.authenticated
    @tornado.web.asynchronous
    @tornado.gen.coroutine
    def get(self):
        new_entry = yield self.facebook_request(
            "/me/feed",
            post_args={"message": "I am posting from my Tornado application!"},
            access_token=self.current_user["access_token"])

        if not new_entry:
            # Call failed; perhaps missing permission?
            yield self.authorize_redirect()
            return
        self.finish("Posted a message!")
```

--------------------------------

### Command-line HTTP client usage

Source: https://tornado-doc.readthedocs.io/en/latest/_sources/httpclient.rst.txt

Use the command-line interface to fetch URLs and control output options like headers and body printing.

```bash
# Fetch the url and print its body
python -m tornado.httpclient http://www.google.com

# Just print the headers
python -m tornado.httpclient --print_headers --print_body=false http://www.google.com
```

--------------------------------

### Configure Asynchronous HTTP Client

Source: https://tornado-doc.readthedocs.io/en/latest/_sources/overview.rst.txt

Set the global asynchronous HTTP client implementation at application startup.

```python
AsyncHTTPClient.configure('tornado.curl_httpclient.CurlAsyncHTTPClient')
```

--------------------------------

### WebSocket Client Connection Initialization

Source: https://tornado-doc.readthedocs.io/en/latest/_modules/tornado/websocket.html

Class definition and initialization for WebSocket client connections, including header setup for the handshake.

```python
class WebSocketClientConnection(simple_httpclient._HTTPConnection):
    """WebSocket client connection."""
    def __init__(self, io_loop, request):
        self.connect_future = Future()
        self.read_future = None
        self.read_queue = collections.deque()
        self.key = base64.b64encode(os.urandom(16))

        scheme, sep, rest = request.url.partition(':')
        scheme = {'ws': 'http', 'wss': 'https'}[scheme]
        request.url = scheme + sep + rest
        request.headers.update({
            'Upgrade': 'websocket',
            'Connection': 'Upgrade',
            'Sec-WebSocket-Key': self.key,
            'Sec-WebSocket-Version': '13',
        })

        self.resolver = Resolver(io_loop=io_loop)
        super(WebSocketClientConnection, self).__init__(
            io_loop, None, request, lambda: None, self._on_http_response,
            104857600, self.resolver)

    def _on_close(self):
        self.on_message(None)
        self.resolver.close()
```

--------------------------------

### Implement a simple HTTP client with IOStream

Source: https://tornado-doc.readthedocs.io/en/latest/_modules/tornado/iostream.html

Demonstrates a basic HTTP request flow using IOStream to write data and read responses asynchronously.

```python
import tornado.ioloop
import tornado.iostream
import socket

def send_request():
    stream.write(b"GET / HTTP/1.0\r\nHost: friendfeed.com\r\n\r\n")
    stream.read_until(b"\r\n\r\n", on_headers)

def on_headers(data):
    headers = {}
    for line in data.split(b"\r\n"):
       parts = line.split(b":")
       if len(parts) == 2:
           headers[parts[0].strip()] = parts[1].strip()
    stream.read_bytes(int(headers[b"Content-Length"]), on_body)

def on_body(data):
    print data
    stream.close()
    tornado.ioloop.IOLoop.instance().stop()

s = socket.socket(socket.AF_INET, socket.SOCK_STREAM, 0)
stream = tornado.iostream.IOStream(s)
stream.connect(("friendfeed.com", 80), send_request)
tornado.ioloop.IOLoop.instance().start()
```
Tokens:
Raw