Open Source Projects Europe

#!/usr/bin/env python

# -*- coding: utf-8 -*-

"""

Bottle is a fast and simple micro-framework for small web applications. It

offers request dispatching (Routes) with url parameter support, templates,

a built-in HTTP Server and adapters for many third party WSGI/HTTP-server and

template engines - all in a single file and with no dependencies other than the

Python Standard Library.

Homepage and documentation: http://bottlepy.org/

Copyright (c) 2014, Marcel Hellkamp.

License: MIT (see LICENSE for details)

"""

from __future__ import with_statement

__author__ = 'Marcel Hellkamp'

__version__ = '0.13-dev'

__license__ = 'MIT'

# The gevent and eventlet server adapters need to patch some modules before

# they are imported. This is why we parse the commandline parameters here but

# handle them later

if __name__ == '__main__':

    from optparse import OptionParser

    _cmd_parser = OptionParser(

        usage="usage: %prog [options] package.module:app")

    _opt = _cmd_parser.add_option

    _opt("--version", action="store_true", help="show version number.")

    _opt("-b", "--bind", metavar="ADDRESS", help="bind socket to ADDRESS.")

    _opt("-s", "--server", default='wsgiref', help="use SERVER as backend.")

    _opt("-p", "--plugin",

         action="append",

         help="install additional plugin/s.")

    _opt("--debug", action="store_true", help="start server in debug mode.")

    _opt("--reload", action="store_true", help="auto-reload on file changes.")

    _cmd_options, _cmd_args = _cmd_parser.parse_args()

    if _cmd_options.server:

        if _cmd_options.server.startswith('gevent'):

            import gevent.monkey

            gevent.monkey.patch_all()

        elif _cmd_options.server.startswith('eventlet'):

            import eventlet

            eventlet.monkey_patch()

import base64, cgi, email.utils, functools, hmac, imp, itertools, mimetypes,\

        os, re, sys, tempfile, threading, time, warnings

from types import FunctionType

from datetime import date as datedate, datetime, timedelta

from tempfile import TemporaryFile

from traceback import format_exc, print_exc

from inspect import getargspec

from unicodedata import normalize

try:

    from simplejson import dumps as json_dumps, loads as json_lds

except ImportError:  # pragma: no cover

    try:

        from json import dumps as json_dumps, loads as json_lds

    except ImportError:

        try:

            from django.utils.simplejson import dumps as json_dumps, loads as json_lds

        except ImportError:

            def json_dumps(data):

                raise ImportError(

                    "JSON support requires Python 2.6 or simplejson.")

            json_lds = json_dumps

# We now try to fix 2.5/2.6/3.1/3.2 incompatibilities.

# It ain't pretty but it works... Sorry for the mess.

py = sys.version_info

py3k = py >= (3, 0, 0)

py25 = py <  (2, 6, 0)

py31 = (3, 1, 0) <= py < (3, 2, 0)

# Workaround for the missing "as" keyword in py3k.

def _e():

    return sys.exc_info()[1]

# Workaround for the "print is a keyword/function" Python 2/3 dilemma

# and a fallback for mod_wsgi (resticts stdout/err attribute access)

try:

    _stdout, _stderr = sys.stdout.write, sys.stderr.write

except IOError:

    _stdout = lambda x: sys.stdout.write(x)

    _stderr = lambda x: sys.stderr.write(x)

# Lots of stdlib and builtin differences.

if py3k:

    import http.client as httplib

    import _thread as thread

    from urllib.parse import urljoin, SplitResult as UrlSplitResult

    from urllib.parse import urlencode, quote as urlquote, unquote as urlunquote

    urlunquote = functools.partial(urlunquote, encoding='latin1')

    from http.cookies import SimpleCookie

    from collections import MutableMapping as DictMixin

    import pickle

    from io import BytesIO

    from configparser import ConfigParser

    basestring = str

    unicode = str

    json_loads = lambda s: json_lds(touni(s))

    callable = lambda x: hasattr(x, '__call__')

    imap = map

    def _raise(*a):

        raise a[0](a[1]).with_traceback(a[2])

else:  # 2.x

    import httplib

    import thread

    from urlparse import urljoin, SplitResult as UrlSplitResult

    from urllib import urlencode, quote as urlquote, unquote as urlunquote

    from Cookie import SimpleCookie

    from itertools import imap

    import cPickle as pickle

    from StringIO import StringIO as BytesIO

    from ConfigParser import SafeConfigParser as ConfigParser

    if py25:

        msg = "Python 2.5 support may be dropped in future versions of Bottle."

        warnings.warn(msg, DeprecationWarning)

        from UserDict import DictMixin

        def next(it):

            return it.next()

        bytes = str

    else:  # 2.6, 2.7

        from collections import MutableMapping as DictMixin

    unicode = unicode

    json_loads = json_lds

    eval(compile('def _raise(*a): raise a[0], a[1], a[2]', '<py3fix>', 'exec'))

# Some helpers for string/byte handling

def tob(s, enc='utf8'):

    return s.encode(enc) if isinstance(s, unicode) else bytes(s)

def touni(s, enc='utf8', err='strict'):

    if isinstance(s, bytes):

        return s.decode(enc, err)

    else:

        return unicode(s or ("" if s is None else s))

tonat = touni if py3k else tob

# 3.2 fixes cgi.FieldStorage to accept bytes (which makes a lot of sense).

# 3.1 needs a workaround.

if py31:

    from io import TextIOWrapper

    class NCTextIOWrapper(TextIOWrapper):

        def close(self):

            pass  # Keep wrapped buffer open.

# A bug in functools causes it to break if the wrapper is an instance method

def update_wrapper(wrapper, wrapped, *a, **ka):

    try:

        functools.update_wrapper(wrapper, wrapped, *a, **ka)

    except AttributeError:

        pass

# These helpers are used at module level and need to be defined first.

# And yes, I know PEP-8, but sometimes a lower-case classname makes more sense.

def depr(message, strict=False):

    warnings.warn(message, DeprecationWarning, stacklevel=3)

def makelist(data):  # This is just too handy

    if isinstance(data, (tuple, list, set, dict)):

        return list(data)

    elif data:

        return [data]

    else:

        return []

class DictProperty(object):

    """ Property that maps to a key in a local dict-like attribute. """

    def __init__(self, attr, key=None, read_only=False):

        self.attr, self.key, self.read_only = attr, key, read_only

    def __call__(self, func):

        functools.update_wrapper(self, func, updated=[])

        self.getter, self.key = func, self.key or func.__name__

        return self

    def __get__(self, obj, cls):

        if obj is None: return self

        key, storage = self.key, getattr(obj, self.attr)

        if key not in storage: storage[key] = self.getter(obj)

        return storage[key]

    def __set__(self, obj, value):

        if self.read_only: raise AttributeError("Read-Only property.")

        getattr(obj, self.attr)[self.key] = value

    def __delete__(self, obj):

        if self.read_only: raise AttributeError("Read-Only property.")

        del getattr(obj, self.attr)[self.key]

class cached_property(object):

    """ A property that is only computed once per instance and then replaces

        itself with an ordinary attribute. Deleting the attribute resets the

        property. """

    def __init__(self, func):

        self.__doc__ = getattr(func, '__doc__')

        self.func = func

    def __get__(self, obj, cls):

        if obj is None: return self

        value = obj.__dict__[self.func.__name__] = self.func(obj)

        return value

class lazy_attribute(object):

    """ A property that caches itself to the class object. """

    def __init__(self, func):

        functools.update_wrapper(self, func, updated=[])

        self.getter = func

    def __get__(self, obj, cls):

        value = self.getter(cls)

        setattr(cls, self.__name__, value)

        return value

###############################################################################

# Exceptions and Events ########################################################

###############################################################################

class BottleException(Exception):

    """ A base class for exceptions used by bottle. """

    pass

###############################################################################

# Routing ######################################################################

###############################################################################

class RouteError(BottleException):

    """ This is a base class for all routing related exceptions """

class RouteReset(BottleException):

    """ If raised by a plugin or request handler, the route is reset and all

        plugins are re-applied. """

class RouterUnknownModeError(RouteError):

    pass

class RouteSyntaxError(RouteError):

    """ The route parser found something not supported by this router. """

class RouteBuildError(RouteError):

    """ The route could not be built. """

def _re_flatten(p):

    """ Turn all capturing groups in a regular expression pattern into

        non-capturing groups. """

    if '(' not in p:

        return p

    return re.sub(r'(\\*)(\(\?P<[^>]+>|\((?!\?))', lambda m: m.group(0) if

                  len(m.group(1)) % 2 else m.group(1) + '(?:', p)

class Router(object):

    """ A Router is an ordered collection of route->target pairs. It is used to

        efficiently match WSGI requests against a number of routes and return

        the first target that satisfies the request. The target may be anything,

        usually a string, ID or callable object. A route consists of a path-rule

        and a HTTP method.

        The path-rule is either a static path (e.g. `/contact`) or a dynamic

        path that contains wildcards (e.g. `/wiki/<page>`). The wildcard syntax

        and details on the matching order are described in docs:`routing`.

    """

    default_pattern = '[^/]+'

    default_filter = 're'

    #: The current CPython regexp implementation does not allow more

    #: than 99 matching groups per regular expression.

    _MAX_GROUPS_PER_PATTERN = 99

    def __init__(self, strict=False):

        self.rules = []  # All rules in order

        self._groups = {}  # index of regexes to find them in dyna_routes

        self.builder = {}  # Data structure for the url builder

        self.static = {}  # Search structure for static routes

        self.dyna_routes = {}

        self.dyna_regexes = {}  # Search structure for dynamic routes

        #: If true, static routes are no longer checked first.

        self.strict_order = strict

        self.filters = {

            're': lambda conf: (_re_flatten(conf or self.default_pattern),

                                None, None),

            'int': lambda conf: (r'-?\d+', int, lambda x: str(int(x))),

            'float': lambda conf: (r'-?[\d.]+', float, lambda x: str(float(x))),

            'path': lambda conf: (r'.+?', None, None)

        }

    def add_filter(self, name, func):

        """ Add a filter. The provided function is called with the configuration

        string as parameter and must return a (regexp, to_python, to_url) tuple.

        The first element is a string, the last two are callables or None. """

        self.filters[name] = func

    rule_syntax = re.compile('(\\\\*)'

        '(?:(?::([a-zA-Z_][a-zA-Z_0-9]*)?()(?:#(.*?)#)?)'

          '|(?:<([a-zA-Z_][a-zA-Z_0-9]*)?(?::([a-zA-Z_]*)'

            '(?::((?:\\\\.|[^\\\\>]+)+)?)?)?>))')

    def _itertokens(self, rule):

        offset, prefix = 0, ''

        for match in self.rule_syntax.finditer(rule):

            prefix += rule[offset:match.start()]

            g = match.groups()

            if len(g[0]) % 2:  # Escaped wildcard

                prefix += match.group(0)[len(g[0]):]

                offset = match.end()

                continue

            if prefix:

                yield prefix, None, None

            name, filtr, conf = g[4:7] if g[2] is None else g[1:4]

            yield name, filtr or 'default', conf or None

            offset, prefix = match.end(), ''

        if offset <= len(rule) or prefix:

            yield prefix + rule[offset:], None, None

    def add(self, rule, method, target, name=None):

        """ Add a new rule or replace the target for an existing rule. """

        anons = 0  # Number of anonymous wildcards found

        keys = []  # Names of keys

        pattern = ''  # Regular expression pattern with named groups

        filters = []  # Lists of wildcard input filters

        builder = []  # Data structure for the URL builder

        is_static = True

        for key, mode, conf in self._itertokens(rule):

            if mode:

                is_static = False

                if mode == 'default': mode = self.default_filter

                mask, in_filter, out_filter = self.filters[mode](conf)

                if not key:

                    pattern += '(?:%s)' % mask

                    key = 'anon%d' % anons

                    anons += 1

                else:

                    pattern += '(?P<%s>%s)' % (key, mask)

                    keys.append(key)

                if in_filter: filters.append((key, in_filter))

                builder.append((key, out_filter or str))

            elif key:

                pattern += re.escape(key)

                builder.append((None, key))

        self.builder[rule] = builder

        if name: self.builder[name] = builder

        if is_static and not self.strict_order:

            self.static.setdefault(method, {})

            self.static[method][self.build(rule)] = (target, None)

            return

        try:

            re_pattern = re.compile('^(%s)$' % pattern)

            re_match = re_pattern.match

        except re.error:

            raise RouteSyntaxError("Could not add Route: %s (%s)" %

                                   (rule, _e()))

        if filters:

            def getargs(path):

                url_args = re_match(path).groupdict()

                for name, wildcard_filter in filters:

                    try:

                        url_args[name] = wildcard_filter(url_args[name])

                    except ValueError:

                        raise HTTPError(400, 'Path has wrong format.')

                return url_args

        elif re_pattern.groupindex:

            def getargs(path):

                return re_match(path).groupdict()

        else:

            getargs = None

        flatpat = _re_flatten(pattern)

        whole_rule = (rule, flatpat, target, getargs)

        if (flatpat, method) in self._groups:

            if DEBUG:

                msg = 'Route <%s %s> overwrites a previously defined route'

                warnings.warn(msg % (method, rule), RuntimeWarning)

            self.dyna_routes[method][

                self._groups[flatpat, method]] = whole_rule

        else:

            self.dyna_routes.setdefault(method, []).append(whole_rule)

            self._groups[flatpat, method] = len(self.dyna_routes[method]) - 1

        self._compile(method)

    def _compile(self, method):

        all_rules = self.dyna_routes[method]

        comborules = self.dyna_regexes[method] = []

        maxgroups = self._MAX_GROUPS_PER_PATTERN

        for x in range(0, len(all_rules), maxgroups):

            some = all_rules[x:x + maxgroups]

            combined = (flatpat for (_, flatpat, _, _) in some)

            combined = '|'.join('(^%s$)' % flatpat for flatpat in combined)

            combined = re.compile(combined).match

            rules = [(target, getargs) for (_, _, target, getargs) in some]

            comborules.append((combined, rules))

    def build(self, _name, *anons, **query):

        """ Build an URL by filling the wildcards in a rule. """

        builder = self.builder.get(_name)

        if not builder:

            raise RouteBuildError("No route with that name.", _name)

        try:

            for i, value in enumerate(anons):

                query['anon%d' % i] = value

            url = ''.join([f(query.pop(n)) if n else f for (n, f) in builder])

            return url if not query else url + '?' + urlencode(query)

        except KeyError:

            raise RouteBuildError('Missing URL argument: %r' % _e().args[0])

    def match(self, environ):

        """ Return a (target, url_args) tuple or raise HTTPError(400/404/405). """

        verb = environ['REQUEST_METHOD'].upper()

        path = environ['PATH_INFO'] or '/'

        if verb == 'HEAD':

            methods = ['PROXY', verb, 'GET', 'ANY']

        else:

            methods = ['PROXY', verb, 'ANY']

        for method in methods:

            if method in self.static and path in self.static[method]:

                target, getargs = self.static[method][path]

                return target, getargs(path) if getargs else {}

            elif method in self.dyna_regexes:

                for combined, rules in self.dyna_regexes[method]:

                    match = combined(path)

                    if match:

                        target, getargs = rules[match.lastindex - 1]

                        return target, getargs(path) if getargs else {}

        # No matching route found. Collect alternative methods for 405 response

        allowed = set([])

        nocheck = set(methods)

        for method in set(self.static) - nocheck:

            if path in self.static[method]:

                allowed.add(verb)

        for method in set(self.dyna_regexes) - allowed - nocheck:

            for combined, rules in self.dyna_regexes[method]:

                match = combined(path)

                if match:

                    allowed.add(method)

        if allowed:

            allow_header = ",".join(sorted(allowed))

            raise HTTPError(405, "Method not allowed.", Allow=allow_header)

        # No matching route and no alternative method found. We give up

        raise HTTPError(404, "Not found: " + repr(path))

class Route(object):

    """ This class wraps a route callback along with route specific metadata and

        configuration and applies Plugins on demand. It is also responsible for

        turing an URL path rule into a regular expression usable by the Router.

    """

    def __init__(self, app, rule, method, callback,

                 name=None,

                 plugins=None,

                 skiplist=None, **config):

        #: The application this route is installed to.

        self.app = app

        #: The path-rule string (e.g. ``/wiki/<page>``).

        self.rule = rule

        #: The HTTP method as a string (e.g. ``GET``).

        self.method = method

        #: The original callback with no plugins applied. Useful for introspection.

        self.callback = callback

        #: The name of the route (if specified) or ``None``.

        self.name = name or None

        #: A list of route-specific plugins (see :meth:`Bottle.route`).

        self.plugins = plugins or []

        #: A list of plugins to not apply to this route (see :meth:`Bottle.route`).

        self.skiplist = skiplist or []

        #: Additional keyword arguments passed to the :meth:`Bottle.route`

        #: decorator are stored in this dictionary. Used for route-specific

        #: plugin configuration and meta-data.

        self.config = ConfigDict().load_dict(config)

    @cached_property

    def call(self):

        """ The route callback with all plugins applied. This property is

            created on demand and then cached to speed up subsequent requests."""

        return self._make_callback()

    def reset(self):

        """ Forget any cached values. The next time :attr:`call` is accessed,

            all plugins are re-applied. """

        self.__dict__.pop('call', None)

    def prepare(self):

        """ Do all on-demand work immediately (useful for debugging)."""

        self.call

    def all_plugins(self):

        """ Yield all Plugins affecting this route. """

        unique = set()

        for p in reversed(self.app.plugins + self.plugins):

            if True in self.skiplist: break

            name = getattr(p, 'name', False)

            if name and (name in self.skiplist or name in unique): continue

            if p in self.skiplist or type(p) in self.skiplist: continue

            if name: unique.add(name)

            yield p

    def _make_callback(self):

        callback = self.callback

        for plugin in self.all_plugins():

            try:

                if hasattr(plugin, 'apply'):

                    callback = plugin.apply(callback, self)

                else:

                    callback = plugin(callback)

            except RouteReset:  # Try again with changed configuration.

                return self._make_callback()

            if not callback is self.callback:

                update_wrapper(callback, self.callback)

        return callback

    def get_undecorated_callback(self):

        """ Return the callback. If the callback is a decorated function, try to

            recover the original function. """

        func = self.callback

        func = getattr(func, '__func__' if py3k else 'im_func', func)

        closure_attr = '__closure__' if py3k else 'func_closure'

        while hasattr(func, closure_attr) and getattr(func, closure_attr):

            attributes = getattr(func, closure_attr)

            func = attributes[0].cell_contents

            # in case of decorators with multiple arguments

            if not isinstance(func, FunctionType):

                # pick first FunctionType instance from multiple arguments

                func = filter(lambda x: isinstance(x, FunctionType),

                              map(lambda x: x.cell_contents, attributes))

                func = list(func)[0]  # py3 support

        return func

    def get_callback_args(self):

        """ Return a list of argument names the callback (most likely) accepts

            as keyword arguments. If the callback is a decorated function, try

            to recover the original function before inspection. """

        return getargspec(self.get_undecorated_callback())[0]

    def get_config(self, key, default=None):

        """ Lookup a config field and return its value, first checking the

            route.config, then route.app.config."""

        for conf in (self.config, self.app.config):

            if key in conf: return conf[key]

        return default

    def __repr__(self):

        cb = self.get_undecorated_callback()

        return '<%s %r %r>' % (self.method, self.rule, cb)

###############################################################################

# Application Object ###########################################################

###############################################################################

class Bottle(object):

    """ Each Bottle object represents a single, distinct web application and

        consists of routes, callbacks, plugins, resources and configuration.

        Instances are callable WSGI applications.

        :param catchall: If true (default), handle all exceptions. Turn off to

                         let debugging middleware handle exceptions.

    """

    def __init__(self, catchall=True, autojson=True):

        #: A :class:`ConfigDict` for app specific configuration.

        self.config = ConfigDict()

        self.config._on_change = functools.partial(self.trigger_hook, 'config')

        self.config.meta_set('autojson', 'validate', bool)

        self.config.meta_set('catchall', 'validate', bool)

        self.config['catchall'] = catchall

        self.config['autojson'] = autojson

        #: A :class:`ResourceManager` for application files

        self.resources = ResourceManager()

        self.routes = []  # List of installed :class:`Route` instances.

        self.router = Router()  # Maps requests to :class:`Route` instances.

        self.error_handler = {}

        # Core plugins

        self.plugins = []  # List of installed plugins.

        if self.config['autojson']:

            self.install(JSONPlugin())

        self.install(TemplatePlugin())

    #: If true, most exceptions are caught and returned as :exc:`HTTPError`

    catchall = DictProperty('config', 'catchall')

    __hook_names = 'before_request', 'after_request', 'app_reset', 'config'

    __hook_reversed = 'after_request'

    @cached_property

    def _hooks(self):

        return dict((name, []) for name in self.__hook_names)

    def add_hook(self, name, func):

        """ Attach a callback to a hook. Three hooks are currently implemented:

            before_request

                Executed once before each request. The request context is

                available, but no routing has happened yet.

            after_request

                Executed once after each request regardless of its outcome.

            app_reset

                Called whenever :meth:`Bottle.reset` is called.

        """

        if name in self.__hook_reversed:

            self._hooks[name].insert(0, func)

        else:

            self._hooks[name].append(func)

    def remove_hook(self, name, func):

        """ Remove a callback from a hook. """

        if name in self._hooks and func in self._hooks[name]:

            self._hooks[name].remove(func)

            return True

    def trigger_hook(self, __name, *args, **kwargs):

        """ Trigger a hook and return a list of results. """

        return [hook(*args, **kwargs) for hook in self._hooks[__name][:]]

    def hook(self, name):

        """ Return a decorator that attaches a callback to a hook. See

            :meth:`add_hook` for details."""

        def decorator(func):

            self.add_hook(name, func)

            return func

        return decorator

    def mount(self, prefix, app, **options):

        """ Mount an application (:class:`Bottle` or plain WSGI) to a specific

            URL prefix. Example::

                root_app.mount('/admin/', admin_app)

            :param prefix: path prefix or `mount-point`. If it ends in a slash,

                that slash is mandatory.

            :param app: an instance of :class:`Bottle` or a WSGI application.

            All other parameters are passed to the underlying :meth:`route` call.

        """

        segments = [p for p in prefix.split('/') if p]

        if not segments: raise ValueError('Empty path prefix.')

        path_depth = len(segments)

        def mountpoint_wrapper():

            try:

                request.path_shift(path_depth)

                rs = HTTPResponse([])

                def start_response(status, headerlist, exc_info=None):

                    if exc_info:

                        _raise(*exc_info)

                    rs.status = status

                    for name, value in headerlist:

                        rs.add_header(name, value)

                    return rs.body.append

                body = app(request.environ, start_response)

                if body and rs.body: body = itertools.chain(rs.body, body)

                rs.body = body or rs.body

                return rs

            finally:

                request.path_shift(-path_depth)

        options.setdefault('skip', True)

        options.setdefault('method', 'PROXY')

        options.setdefault('mountpoint', {'prefix': prefix, 'target': app})

        options['callback'] = mountpoint_wrapper

        self.route('/%s/<:re:.*>' % '/'.join(segments), **options)

        if not prefix.endswith('/'):

            self.route('/' + '/'.join(segments), **options)

    def merge(self, routes):

        """ Merge the routes of another :class:`Bottle` application or a list of

            :class:`Route` objects into this application. The routes keep their

            'owner', meaning that the :data:`Route.app` attribute is not

            changed. """

        if isinstance(routes, Bottle):

            routes = routes.routes

        for route in routes:

            self.add_route(route)

    def install(self, plugin):

        """ Add a plugin to the list of plugins and prepare it for being

            applied to all routes of this application. A plugin may be a simple

            decorator or an object that implements the :class:`Plugin` API.

        """

        if hasattr(plugin, 'setup'): plugin.setup(self)

        if not callable(plugin) and not hasattr(plugin, 'apply'):

            raise TypeError("Plugins must be callable or implement .apply()")

        self.plugins.append(plugin)

        self.reset()

        return plugin

    def uninstall(self, plugin):

        """ Uninstall plugins. Pass an instance to remove a specific plugin, a type

            object to remove all plugins that match that type, a string to remove

            all plugins with a matching ``name`` attribute or ``True`` to remove all

            plugins. Return the list of removed plugins. """

        removed, remove = [], plugin

        for i, plugin in list(enumerate(self.plugins))[::-1]:

            if remove is True or remove is plugin or remove is type(plugin) \

            or getattr(plugin, 'name', True) == remove:

                removed.append(plugin)

                del self.plugins[i]

                if hasattr(plugin, 'close'): plugin.close()

        if removed: self.reset()

        return removed

    def reset(self, route=None):

        """ Reset all routes (force plugins to be re-applied) and clear all

            caches. If an ID or route object is given, only that specific route

            is affected. """

        if route is None: routes = self.routes

        elif isinstance(route, Route): routes = [route]

        else: routes = [self.routes[route]]

        for route in routes:

            route.reset()

        if DEBUG:

            for route in routes:

                route.prepare()

        self.trigger_hook('app_reset')

    def close(self):

        """ Close the application and all installed plugins. """

        for plugin in self.plugins:

            if hasattr(plugin, 'close'): plugin.close()

    def run(self, **kwargs):

        """ Calls :func:`run` with the same parameters. """

        run(self, **kwargs)

    def match(self, environ):

        """ Search for a matching route and return a (:class:`Route` , urlargs)

            tuple. The second value is a dictionary with parameters extracted

            from the URL. Raise :exc:`HTTPError` (404/405) on a non-match."""

        return self.router.match(environ)

    def get_url(self, routename, **kargs):

        """ Return a string that matches a named route """

        scriptname = request.environ.get('SCRIPT_NAME', '').strip('/') + '/'

        location = self.router.build(routename, **kargs).lstrip('/')

        return urljoin(urljoin('/', scriptname), location)

    def add_route(self, route):

        """ Add a route object, but do not change the :data:`Route.app`

            attribute."""

        self.routes.append(route)

        self.router.add(route.rule, route.method, route, name=route.name)

        if DEBUG: route.prepare()

    def route(self,

              path=None,

              method='GET',

              callback=None,

              name=None,

              apply=None,

              skip=None, **config):

        """ A decorator to bind a function to a request URL. Example::

                @app.route('/hello/<name>')

                def hello(name):

                    return 'Hello %s' % name

            The ``:name`` part is a wildcard. See :class:`Router` for syntax

            details.

            :param path: Request path or a list of paths to listen to. If no

              path is specified, it is automatically generated from the

              signature of the function.

            :param method: HTTP method (`GET`, `POST`, `PUT`, ...) or a list of

              methods to listen to. (default: `GET`)

            :param callback: An optional shortcut to avoid the decorator

              syntax. ``route(..., callback=func)`` equals ``route(...)(func)``

            :param name: The name for this route. (default: None)

            :param apply: A decorator or plugin or a list of plugins. These are

              applied to the route callback in addition to installed plugins.

            :param skip: A list of plugins, plugin classes or names. Matching

              plugins are not installed to this route. ``True`` skips all.

            Any additional keyword arguments are stored as route-specific

            configuration and passed to plugins (see :meth:`Plugin.apply`).

        """

        if callable(path): path, callback = None, path

        plugins = makelist(apply)

        skiplist = makelist(skip)

        def decorator(callback):

            if isinstance(callback, basestring): callback = load(callback)

            for rule in makelist(path) or yieldroutes(callback):

                for verb in makelist(method):

                    verb = verb.upper()

                    route = Route(self, rule, verb, callback,

                                  name=name,

                                  plugins=plugins,

                                  skiplist=skiplist, **config)

                    self.add_route(route)

            return callback

        return decorator(callback) if callback else decorator

    def get(self, path=None, method='GET', **options):

        """ Equals :meth:`route`. """

        return self.route(path, method, **options)

    def post(self, path=None, method='POST', **options):

        """ Equals :meth:`route` with a ``POST`` method parameter. """

        return self.route(path, method, **options)

    def put(self, path=None, method='PUT', **options):

        """ Equals :meth:`route` with a ``PUT`` method parameter. """

        return self.route(path, method, **options)

    def delete(self, path=None, method='DELETE', **options):

        """ Equals :meth:`route` with a ``DELETE`` method parameter. """

        return self.route(path, method, **options)

    def patch(self, path=None, method='PATCH', **options):

        """ Equals :meth:`route` with a ``PATCH`` method parameter. """

        return self.route(path, method, **options)

    def error(self, code=500):

        """ Decorator: Register an output handler for a HTTP error code"""

        def wrapper(handler):

            self.error_handler[int(code)] = handler

            return handler

        return wrapper

    def default_error_handler(self, res):

        return tob(template(ERROR_PAGE_TEMPLATE, e=res))

    def _handle(self, environ):

        path = environ['bottle.raw_path'] = environ['PATH_INFO']

        if py3k:

            try:

                environ['PATH_INFO'] = path.encode('latin1').decode('utf8')

            except UnicodeError:

                return HTTPError(400, 'Invalid path string. Expected UTF-8')

        try:

            environ['bottle.app'] = self

            request.bind(environ)

            response.bind()

            try:

                self.trigger_hook('before_request')

                route, args = self.router.match(environ)

                environ['route.handle'] = route

                environ['bottle.route'] = route

                environ['route.url_args'] = args

                return route.call(**args)

            finally:

                self.trigger_hook('after_request')

        except HTTPResponse:

            return _e()

        except RouteReset:

            route.reset()

            return self._handle(environ)

        except (KeyboardInterrupt, SystemExit, MemoryError):

            raise

        except Exception:

            if not self.catchall: raise

            stacktrace = format_exc()

            environ['wsgi.errors'].write(stacktrace)

            return HTTPError(500, "Internal Server Error", _e(), stacktrace)

    def _cast(self, out, peek=None):

        """ Try to convert the parameter into something WSGI compatible and set

        correct HTTP headers when possible.

        Support: False, str, unicode, dict, HTTPResponse, HTTPError, file-like,

        iterable of strings and iterable of unicodes

        """

        # Empty output is done here

        if not out:

            if 'Content-Length' not in response:

                response['Content-Length'] = 0

            return []

        # Join lists of byte or unicode strings. Mixed lists are NOT supported

        if isinstance(out, (tuple, list))\

        and isinstance(out[0], (bytes, unicode)):

            out = out[0][0:0].join(out)  # b'abc'[0:0] -> b''

        # Encode unicode strings

        if isinstance(out, unicode):

            out = out.encode(response.charset)

        # Byte Strings are just returned

        if isinstance(out, bytes):

            if 'Content-Length' not in response:

                response['Content-Length'] = len(out)

            return [out]

        # HTTPError or HTTPException (recursive, because they may wrap anything)

        # TODO: Handle these explicitly in handle() or make them iterable.

        if isinstance(out, HTTPError):

            out.apply(response)

            out = self.error_handler.get(out.status_code,

                                         self.default_error_handler)(out)

            return self._cast(out)

        if isinstance(out, HTTPResponse):

            out.apply(response)

            return self._cast(out.body)

        # File-like objects.

        if hasattr(out, 'read'):

            if 'wsgi.file_wrapper' in request.environ:

                return request.environ['wsgi.file_wrapper'](out)

            elif hasattr(out, 'close') or not hasattr(out, '__iter__'):

                return WSGIFileWrapper(out)

        # Handle Iterables. We peek into them to detect their inner type.

        try:

            iout = iter(out)

            first = next(iout)

            while not first:

                first = next(iout)

        except StopIteration:

            return self._cast('')

        except HTTPResponse:

            first = _e()

        except (KeyboardInterrupt, SystemExit, MemoryError):

            raise

        except:

            if not self.catchall: raise

            first = HTTPError(500, 'Unhandled exception', _e(), format_exc())

        # These are the inner types allowed in iterator or generator objects.

        if isinstance(first, HTTPResponse):

            return self._cast(first)

        elif isinstance(first, bytes):

            new_iter = itertools.chain([first], iout)

        elif isinstance(first, unicode):

            encoder = lambda x: x.encode(response.charset)

            new_iter = imap(encoder, itertools.chain([first], iout))

        else:

            msg = 'Unsupported response type: %s' % type(first)

            return self._cast(HTTPError(500, msg))

        if hasattr(out, 'close'):

            new_iter = _closeiter(new_iter, out.close)

        return new_iter

    def wsgi(self, environ, start_response):

        """ The bottle WSGI-interface. """

        try:

            out = self._cast(self._handle(environ))

            # rfc2616 section 4.3

            if response._status_code in (100, 101, 204, 304)\

            or environ['REQUEST_METHOD'] == 'HEAD':

                if hasattr(out, 'close'): out.close()

                out = []

            start_response(response._status_line, response.headerlist)

            return out

        except (KeyboardInterrupt, SystemExit, MemoryError):

            raise

        except:

            if not self.catchall: raise

            err = '<h1>Critical error while processing request: %s</h1>' \

                  % html_escape(environ.get('PATH_INFO', '/'))

            if DEBUG:

                err += '<h2>Error:</h2>\n<pre>\n%s\n</pre>\n' \

                       '<h2>Traceback:</h2>\n<pre>\n%s\n</pre>\n' \

                       % (html_escape(repr(_e())), html_escape(format_exc()))

            environ['wsgi.errors'].write(err)

            headers = [('Content-Type', 'text/html; charset=UTF-8')]

            start_response('500 INTERNAL SERVER ERROR', headers, sys.exc_info())

            return [tob(err)]

    def __call__(self, environ, start_response):

        """ Each instance of :class:'Bottle' is a WSGI application. """

        return self.wsgi(environ, start_response)

    def __enter__(self):

        """ Use this application as default for all module-level shortcuts. """

        default_app.push(self)

        return self

    def __exit__(self, exc_type, exc_value, traceback):

        default_app.pop()

###############################################################################

# HTTP and WSGI Tools ##########################################################

###############################################################################

class BaseRequest(object):

    """ A wrapper for WSGI environment dictionaries that adds a lot of

        convenient access methods and properties. Most of them are read-only.

        Adding new attributes to a request actually adds them to the environ

        dictionary (as 'bottle.request.ext.<name>'). This is the recommended

        way to store and access request-specific data.

    """

    __slots__ = ('environ', )

    #: Maximum size of memory buffer for :attr:`body` in bytes.

    MEMFILE_MAX = 102400

    def __init__(self, environ=None):

        """ Wrap a WSGI environ dictionary. """

        #: The wrapped WSGI environ dictionary. This is the only real attribute.

        #: All other attributes actually are read-only properties.

        self.environ = {} if environ is None else environ

        self.environ['bottle.request'] = self

    @DictProperty('environ', 'bottle.app', read_only=True)

    def app(self):

        """ Bottle application handling this request. """

        raise RuntimeError('This request is not connected to an application.')

    @DictProperty('environ', 'bottle.route', read_only=True)

    def route(self):

        """ The bottle :class:`Route` object that matches this request. """

        raise RuntimeError('This request is not connected to a route.')

    @DictProperty('environ', 'route.url_args', read_only=True)

    def url_args(self):

        """ The arguments extracted from the URL. """

        raise RuntimeError('This request is not connected to a route.')

    @property

    def path(self):

        """ The value of ``PATH_INFO`` with exactly one prefixed slash (to fix

            broken clients and avoid the "empty path" edge case). """

        return '/' + self.environ.get('PATH_INFO', '').lstrip('/')

    @property

    def method(self):

        """ The ``REQUEST_METHOD`` value as an uppercase string. """

        return self.environ.get('REQUEST_METHOD', 'GET').upper()

    @DictProperty('environ', 'bottle.request.headers', read_only=True)

    def headers(self):

        """ A :class:`WSGIHeaderDict` that provides case-insensitive access to

            HTTP request headers. """

        return WSGIHeaderDict(self.environ)

    def get_header(self, name, default=None):

        """ Return the value of a request header, or a given default value. """

        return self.headers.get(name, default)

    @DictProperty('environ', 'bottle.request.cookies', read_only=True)

    def cookies(self):

        """ Cookies parsed into a :class:`FormsDict`. Signed cookies are NOT

            decoded. Use :meth:`get_cookie` if you expect signed cookies. """

        cookies = SimpleCookie(self.environ.get('HTTP_COOKIE', '')).values()

        return FormsDict((c.key, c.value) for c in cookies)

    def get_cookie(self, key, default=None, secret=None):

        """ Return the content of a cookie. To read a `Signed Cookie`, the

            `secret` must match the one used to create the cookie (see

            :meth:`BaseResponse.set_cookie`). If anything goes wrong (missing

            cookie or wrong signature), return a default value. """

        value = self.cookies.get(key)

        if secret and value:

            dec = cookie_decode(value, secret)  # (key, value) tuple or None

            return dec[1] if dec and dec[0] == key else default

        return value or default

    @DictProperty('environ', 'bottle.request.query', read_only=True)

    def query(self):

        """ The :attr:`query_string` parsed into a :class:`FormsDict`. These

            values are sometimes called "URL arguments" or "GET parameters", but

            not to be confused with "URL wildcards" as they are provided by the

            :class:`Router`. """

        get = self.environ['bottle.get'] = FormsDict()

        pairs = _parse_qsl(self.environ.get('QUERY_STRING', ''))

        for key, value in pairs:

            get[key] = value

        return get

    @DictProperty('environ', 'bottle.request.forms', read_only=True)

    def forms(self):

        """ Form values parsed from an `url-encoded` or `multipart/form-data`

            encoded POST or PUT request body. The result is returned as a

            :class:`FormsDict`. All keys and values are strings. File uploads

            are stored separately in :attr:`files`. """

        forms = FormsDict()

        for name, item in self.POST.allitems():

            if not isinstance(item, FileUpload):

                forms[name] = item

        return forms

    @DictProperty('environ', 'bottle.request.params', read_only=True)

    def params(self):

        """ A :class:`FormsDict` with the combined values of :attr:`query` and

            :attr:`forms`. File uploads are stored in :attr:`files`. """

        params = FormsDict()

        for key, value in self.query.allitems():

            params[key] = value

        for key, value in self.forms.allitems():

            params[key] = value