Commits

ouxuedong  committed 25068fe

delete lib/

  • Participants
  • Parent commits de9cf8d

Comments (0)

Files changed (226)

File src/lib/debug/__init__.py

-

File src/lib/debug/__init__.pyc

Binary file removed.

File src/lib/debug/templates/console.html

-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
-  "http://www.w3.org/TR/html4/loose.dtd">
-<html>
-  <head>
-    <title>Console // Werkzeug Debugger</title>
-    <link rel="stylesheet" href="./__debugger__?cmd=resource&amp;f=style.css" type="text/css">
-    <script type="text/javascript" src="./__debugger__?cmd=resource&amp;f=jquery.js"></script>
-    <script type="text/javascript" src="./__debugger__?cmd=resource&amp;f=debugger.js"></script>
-    <script type="text/javascript">
-      var EVALEX = true,
-          CONSOLE_MODE = true;
-    </script>
-  </head>
-  <body>
-    <div class="debugger">
-      <h1>Interactive Console</h1>
-      <div class="explanation">
-        In this console you can execute Python expressions in the context of the
-        application.  The initial namespace was created by the debugger automatically.
-      </div>
-      <div class="console"><div class="inner">The Console requires JavaScript.</div></div>
-      <div class="footer">
-        Brought to you by <strong class="arthur">DON'T PANIC</strong>, your
-        friendly Werkzeug powered traceback interpreter.
-      </div>
-    </div>
-  </body>
-</html>

File src/lib/debug/templates/dump_object.html

-<div class="box">
-  <h3>{{ title|e }}</h3>
-  {% if repr %}
-    <div class="repr">{{ repr }}</div>
-  {% endif %}
-  <table>
-  {% for key, value in items %}
-    <tr>
-      <th>{{ key|e }}</th>
-      <td>{{ value }}</td>
-    </tr>
-  {% endfor %}
-  </table>
-</div>

File src/lib/debug/templates/frame.html

-<div class="frame" id="frame-{{ frame.id }}">
-  <h4>File <cite>"{{ frame.filename|e }}"</cite>, line <em>{{ frame.lineno }}</em>,
-      in <code>{{ frame.function_name|e }}</code></h4>
-  <pre>{{ frame.current_line.strip()|e }}</pre>
-</div>

File src/lib/debug/templates/help_command.html

-<%py missing = object() %>
-<div class="box">
-  <% if title and text %>
-    <h3>{{ title }}</h3>
-    <pre class="help">{{ text }}</pre>
-  <% else %>
-    <h3>Help</h3>
-    <p>Type help(object) for help about object.</p>
-  <% endif %>
-</div>

File src/lib/debug/templates/source.html

-<table class="source">
-{% for line in lines %}
-  <tr class="{{ ' '.join(line.classes) }}">
-    <td class="lineno">{{ line.lineno }}</td>
-    <td>{{ line.code|e }}</td>
-  </tr>
-{% endfor %}
-</table>

File src/lib/debug/templates/traceback_full.html

-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
-  "http://www.w3.org/TR/html4/loose.dtd">
-<html>
-  <head>
-    <title>{{ traceback.exception|e }} // Werkzeug Debugger</title>
-    <link rel="stylesheet" href="./__debugger__?cmd=resource&amp;f=style.css" type="text/css">
-    <script type="text/javascript" src="./__debugger__?cmd=resource&amp;f=jquery.js"></script>
-    <script type="text/javascript" src="./__debugger__?cmd=resource&amp;f=debugger.js"></script>
-    <script type="text/javascript">
-    var TRACEBACK = {{ traceback.id }},
-          CONSOLE_MODE = false,
-          EVALEX = {% if evalex %}'true'{% else %}'false'{% endif %};
-    </script>
-  </head>
-  <body>
-    <div class="debugger">
-      <h1>{{ traceback.exception_type|e }}</h1>
-      <div class="detail">
-        <p class="errormsg">{{ traceback.exception|e }}</p>
-      </div>
-      <h2 class="traceback">Traceback <em>(most recent call last)</em></h2>
-      {{ traceback.render_summary(include_title=False) }}
-      <div class="plain">
-        <form action="http://paste.pocoo.org/" method="post">
-          <p>
-            <input type="hidden" name="language" value="pytb">
-            This is the Copy/Paste friendly version of the traceback.  <span
-            class="pastemessage">You can also paste this traceback into the public
-            lodgeit pastebin: <input type="submit" value="create paste"></span>
-          </p>
-          <textarea cols="50" rows="10" name="code" readonly>{{ traceback.plaintext|e }}</textarea>
-        </form>
-      </div>
-      <div class="explanation">
-        The debugger caught an exception in your WSGI application.  You can now
-        look at the traceback which lead to the error.  <span class="nojavascript">
-        If you enable JavaScript you can also use additional features such as code
-        execution (if the evalex feature is enabled), automatic pasting of the
-        exceptions and much more.</span>
-      </div>
-      <div class="footer">
-        Brought to you by <strong class="arthur">DON'T PANIC</strong>, your
-        friendly Werkzeug powered traceback interpreter.
-      </div>
-    </div>
-  </body>
-</html>
-<!--
-
-{{ traceback.plaintext }}
-
--->

File src/lib/debug/templates/traceback_plaintext.html

-Traceback (most recent call last):
-{% for frame in traceback.frames %}
-  File "{{ frame.filename }}", line {{ frame.lineno }}, in {{ frame.function_name }}
-    {{ frame.current_line.strip() }}
-{% endfor %}
-{{ traceback.exception }}

File src/lib/debug/templates/traceback_summary.html

-<div class="traceback">
-  {% if traceback.is_syntax_error %}
-    {% if include_title %}
-      <h3>Syntax Error</h3>
-    {% endif %}
-    <ul>
-    {% for frame in traceback.frames %}
-      <li>{{ frame.render() }}</li>
-    {% endfor %}
-    </ul>
-    <pre>{{ traceback.exception|e }}</pre>
-  {% else %}
-    {% if include_title %}
-      <h3>Traceback <em>(most recent call last)</em>:</h3>
-    {% endif %}
-    <ul>
-    {% for frame in traceback.frames %}
-      <li{% if frame.info %} title="{{ frame.info|e }}"{% endif %}>{{ frame.render() }}</li>
-    {% endfor %}
-    </ul>
-    <blockquote>{{ traceback.exception|e }}</blockquote>
-  {% endif %}
-</div>

File src/lib/debug/utils.py

-# -*- coding: utf-8 -*-
-"""
-    werkzeug.debug.utils
-    ~~~~~~~~~~~~~~~~~~~~
-
-    Various other utilities.
-
-    :copyright: Copyright 2008 by Armin Ronacher.
-    :license: BSD.
-"""
-from os.path import join, dirname
-from jinja2 import Environment, FileSystemLoader
-
-env = Environment(loader = FileSystemLoader([join(dirname(__file__), 'templates')]))
-
-def get_template(filename):
-    return env.get_template(filename)
-
-def render_template(template_filename, **context):
-    return get_template(template_filename).render(**context)

File src/lib/debug/utils.pyc

Binary file removed.

File src/lib/flask/__init__.py

-# -*- coding: utf-8 -*-
-"""
-    flask
-    ~~~~~
-
-    A microframework based on Werkzeug.  It's extensively documented
-    and follows best practice patterns.
-
-    :copyright: (c) 2010 by Armin Ronacher.
-    :license: BSD, see LICENSE for more details.
-"""
-
-# utilities we import from Werkzeug and Jinja2 that are unused
-# in the module but are exported as public interface.
-from werkzeug import abort, redirect
-from jinja2 import Markup, escape
-
-from .app import Flask, Request, Response
-from .config import Config
-from .helpers import url_for, jsonify, json_available, flash, \
-    send_file, send_from_directory, get_flashed_messages, \
-    get_template_attribute, make_response
-from .globals import current_app, g, request, session, _request_ctx_stack
-from .module import Module
-from .templating import render_template, render_template_string
-from .session import Session
-
-# the signals
-from .signals import signals_available, template_rendered, request_started, \
-     request_finished, got_request_exception
-
-# only import json if it's available
-if json_available:
-    from .helpers import json

File src/lib/flask/__init__.pyc

Binary file removed.

File src/lib/flask/app.py

-# -*- coding: utf-8 -*-
-"""
-    flask.app
-    ~~~~~~~~~
-
-    This module implements the central WSGI application object.
-
-    :copyright: (c) 2010 by Armin Ronacher.
-    :license: BSD, see LICENSE for more details.
-"""
-
-from __future__ import with_statement
-
-from threading import Lock
-from datetime import timedelta, datetime
-from itertools import chain
-
-from jinja2 import Environment
-
-from werkzeug import ImmutableDict
-from werkzeug.routing import Map, Rule
-from werkzeug.exceptions import HTTPException, InternalServerError, \
-     MethodNotAllowed
-
-from .helpers import _PackageBoundObject, url_for, get_flashed_messages, \
-    _tojson_filter, _endpoint_from_view_func
-from .wrappers import Request, Response
-from .config import ConfigAttribute, Config
-from .ctx import _RequestContext
-from .globals import _request_ctx_stack, request
-from .session import Session, _NullSession
-from .module import _ModuleSetupState
-from .templating import _DispatchingJinjaLoader, \
-    _default_template_ctx_processor
-from .signals import request_started, request_finished, got_request_exception
-
-# a lock used for logger initialization
-_logger_lock = Lock()
-
-
-class Flask(_PackageBoundObject):
-    """The flask object implements a WSGI application and acts as the central
-    object.  It is passed the name of the module or package of the
-    application.  Once it is created it will act as a central registry for
-    the view functions, the URL rules, template configuration and much more.
-
-    The name of the package is used to resolve resources from inside the
-    package or the folder the module is contained in depending on if the
-    package parameter resolves to an actual python package (a folder with
-    an `__init__.py` file inside) or a standard module (just a `.py` file).
-
-    For more information about resource loading, see :func:`open_resource`.
-
-    Usually you create a :class:`Flask` instance in your main module or
-    in the `__init__.py` file of your package like this::
-
-        from flask import Flask
-        app = Flask(__name__)
-
-    .. admonition:: About the First Parameter
-
-        The idea of the first parameter is to give Flask an idea what
-        belongs to your application.  This name is used to find resources
-        on the file system, can be used by extensions to improve debugging
-        information and a lot more.
-
-        So it's important what you provide there.  If you are using a single
-        module, `__name__` is always the correct value.  If you however are
-        using a package, it's usually recommended to hardcode the name of
-        your package there.
-
-        For example if your application is defined in `yourapplication/app.py`
-        you should create it with one of the two versions below::
-
-            app = Flask('yourapplication')
-            app = Flask(__name__.split('.')[0])
-
-        Why is that?  The application will work even with `__name__`, thanks
-        to how resources are looked up.  However it will make debugging more
-        painful.  Certain extensions can make assumptions based on the
-        import name of your application.  For example the Flask-SQLAlchemy
-        extension will look for the code in your application that triggered
-        an SQL query in debug mode.  If the import name is not properly set
-        up, that debugging information is lost.  (For example it would only
-        pick up SQL queries in `yourapplicaiton.app` and not
-        `yourapplication.views.frontend`)
-
-    .. versionadded:: 0.5
-       The `static_path` parameter was added.
-
-    :param import_name: the name of the application package
-    :param static_path: can be used to specify a different path for the
-                        static files on the web.  Defaults to ``/static``.
-                        This does not affect the folder the files are served
-                        *from*.
-    """
-
-    #: The class that is used for request objects.  See :class:`~flask.Request`
-    #: for more information.
-    request_class = Request
-
-    #: The class that is used for response objects.  See
-    #: :class:`~flask.Response` for more information.
-    response_class = Response
-
-    #: Path for the static files.  If you don't want to use static files
-    #: you can set this value to `None` in which case no URL rule is added
-    #: and the development server will no longer serve any static files.
-    #:
-    #: This is the default used for application and modules unless a
-    #: different value is passed to the constructor.
-    static_path = '/static'
-
-    #: The debug flag.  Set this to `True` to enable debugging of the
-    #: application.  In debug mode the debugger will kick in when an unhandled
-    #: exception ocurrs and the integrated server will automatically reload
-    #: the application if changes in the code are detected.
-    #:
-    #: This attribute can also be configured from the config with the `DEBUG`
-    #: configuration key.  Defaults to `False`.
-    debug = ConfigAttribute('DEBUG')
-
-    #: The testing flask.  Set this to `True` to enable the test mode of
-    #: Flask extensions (and in the future probably also Flask itself).
-    #: For example this might activate unittest helpers that have an
-    #: additional runtime cost which should not be enabled by default.
-    #:
-    #: This attribute can also be configured from the config with the
-    #: `TESTING` configuration key.  Defaults to `False`.
-    testing = ConfigAttribute('TESTING')
-
-    #: If a secret key is set, cryptographic components can use this to
-    #: sign cookies and other things.  Set this to a complex random value
-    #: when you want to use the secure cookie for instance.
-    #:
-    #: This attribute can also be configured from the config with the
-    #: `SECRET_KEY` configuration key.  Defaults to `None`.
-    secret_key = ConfigAttribute('SECRET_KEY')
-
-    #: The secure cookie uses this for the name of the session cookie.
-    #:
-    #: This attribute can also be configured from the config with the
-    #: `SESSION_COOKIE_NAME` configuration key.  Defaults to ``'session'``
-    session_cookie_name = ConfigAttribute('SESSION_COOKIE_NAME')
-
-    #: A :class:`~datetime.timedelta` which is used to set the expiration
-    #: date of a permanent session.  The default is 31 days which makes a
-    #: permanent session survive for roughly one month.
-    #:
-    #: This attribute can also be configured from the config with the
-    #: `PERMANENT_SESSION_LIFETIME` configuration key.  Defaults to
-    #: ``timedelta(days=31)``
-    permanent_session_lifetime = ConfigAttribute('PERMANENT_SESSION_LIFETIME')
-
-    #: Enable this if you want to use the X-Sendfile feature.  Keep in
-    #: mind that the server has to support this.  This only affects files
-    #: sent with the :func:`send_file` method.
-    #:
-    #: .. versionadded:: 0.2
-    #:
-    #: This attribute can also be configured from the config with the
-    #: `USE_X_SENDFILE` configuration key.  Defaults to `False`.
-    use_x_sendfile = ConfigAttribute('USE_X_SENDFILE')
-
-    #: The name of the logger to use.  By default the logger name is the
-    #: package name passed to the constructor.
-    #:
-    #: .. versionadded:: 0.4
-    logger_name = ConfigAttribute('LOGGER_NAME')
-
-    #: The logging format used for the debug logger.  This is only used when
-    #: the application is in debug mode, otherwise the attached logging
-    #: handler does the formatting.
-    #:
-    #: .. versionadded:: 0.3
-    debug_log_format = (
-        '-' * 80 + '\n' +
-        '%(levelname)s in %(module)s [%(pathname)s:%(lineno)d]:\n' +
-        '%(message)s\n' +
-        '-' * 80
-    )
-
-    #: Options that are passed directly to the Jinja2 environment.
-    jinja_options = ImmutableDict(
-        extensions=['jinja2.ext.autoescape', 'jinja2.ext.with_']
-    )
-
-    #: Default configuration parameters.
-    default_config = ImmutableDict({
-        'DEBUG':                                False,
-        'TESTING':                              False,
-        'SECRET_KEY':                           None,
-        'SESSION_COOKIE_NAME':                  'session',
-        'PERMANENT_SESSION_LIFETIME':           timedelta(days=31),
-        'USE_X_SENDFILE':                       False,
-        'LOGGER_NAME':                          None,
-        'SERVER_NAME':                          None,
-        'MAX_CONTENT_LENGTH':                   None
-    })
-
-    def __init__(self, import_name, static_path=None):
-        _PackageBoundObject.__init__(self, import_name)
-        if static_path is not None:
-            self.static_path = static_path
-
-        #: The configuration dictionary as :class:`Config`.  This behaves
-        #: exactly like a regular dictionary but supports additional methods
-        #: to load a config from files.
-        self.config = Config(self.root_path, self.default_config)
-
-        #: Prepare the deferred setup of the logger.
-        self._logger = None
-        self.logger_name = self.import_name
-
-        #: A dictionary of all view functions registered.  The keys will
-        #: be function names which are also used to generate URLs and
-        #: the values are the function objects themselves.
-        #: To register a view function, use the :meth:`route` decorator.
-        self.view_functions = {}
-
-        #: A dictionary of all registered error handlers.  The key is
-        #: be the error code as integer, the value the function that
-        #: should handle that error.
-        #: To register a error handler, use the :meth:`errorhandler`
-        #: decorator.
-        self.error_handlers = {}
-
-        #: A dictionary with lists of functions that should be called at the
-        #: beginning of the request.  The key of the dictionary is the name of
-        #: the module this function is active for, `None` for all requests.
-        #: This can for example be used to open database connections or
-        #: getting hold of the currently logged in user.  To register a
-        #: function here, use the :meth:`before_request` decorator.
-        self.before_request_funcs = {}
-
-        #: A dictionary with lists of functions that should be called after
-        #: each request.  The key of the dictionary is the name of the module
-        #: this function is active for, `None` for all requests.  This can for
-        #: example be used to open database connections or getting hold of the
-        #: currently logged in user.  To register a function here, use the
-        #: :meth:`after_request` decorator.
-        self.after_request_funcs = {}
-
-        #: A dictionary with list of functions that are called without argument
-        #: to populate the template context.  The key of the dictionary is the
-        #: name of the module this function is active for, `None` for all
-        #: requests.  Each returns a dictionary that the template context is
-        #: updated with.  To register a function here, use the
-        #: :meth:`context_processor` decorator.
-        self.template_context_processors = {
-            None: [_default_template_ctx_processor]
-        }
-
-        #: all the loaded modules in a dictionary by name.
-        #:
-        #: .. versionadded:: 0.5
-        self.modules = {}
-
-        #: a place where extensions can store application specific state.  For
-        #: example this is where an extension could store database engines and
-        #: similar things.  For backwards compatibility extensions should register
-        #: themselves like this::
-        #:
-        #:      if not hasattr(app, 'extensions'):
-        #:          app.extensions = {}
-        #:      app.extensions['extensionname'] = SomeObject()
-        #:
-        #: The key must match the name of the `flaskext` module.  For example in
-        #: case of a "Flask-Foo" extension in `flaskext.foo`, the key would be
-        #: ``'foo'``.
-        #:
-        #: .. versionadded:: 0.7
-        self.extensions = {}
-
-        #: The :class:`~werkzeug.routing.Map` for this instance.  You can use
-        #: this to change the routing converters after the class was created
-        #: but before any routes are connected.  Example::
-        #:
-        #:    from werkzeug.routing import BaseConverter
-        #:
-        #:    class ListConverter(BaseConverter):
-        #:        def to_python(self, value):
-        #:            return value.split(',')
-        #:        def to_url(self, values):
-        #:            return ','.join(BaseConverter.to_url(value)
-        #:                            for value in values)
-        #:
-        #:    app = Flask(__name__)
-        #:    app.url_map.converters['list'] = ListConverter
-        self.url_map = Map()
-
-        # register the static folder for the application.  Do that even
-        # if the folder does not exist.  First of all it might be created
-        # while the server is running (usually happens during development)
-        # but also because google appengine stores static files somewhere
-        # else when mapped with the .yml file.
-        self.add_url_rule(self.static_path + '/<path:filename>',
-                          endpoint='static',
-                          view_func=self.send_static_file)
-
-        #: The Jinja2 environment.  It is created from the
-        #: :attr:`jinja_options`.
-        self.jinja_env = self.create_jinja_environment()
-        self.init_jinja_globals()
-
-    @property
-    def logger(self):
-        """A :class:`logging.Logger` object for this application.  The
-        default configuration is to log to stderr if the application is
-        in debug mode.  This logger can be used to (surprise) log messages.
-        Here some examples::
-
-            app.logger.debug('A value for debugging')
-            app.logger.warning('A warning ocurred (%d apples)', 42)
-            app.logger.error('An error occoured')
-
-        .. versionadded:: 0.3
-        """
-        if self._logger and self._logger.name == self.logger_name:
-            return self._logger
-        with _logger_lock:
-            if self._logger and self._logger.name == self.logger_name:
-                return self._logger
-            from flask.logging import create_logger
-            self._logger = rv = create_logger(self)
-            return rv
-
-    def create_jinja_environment(self):
-        """Creates the Jinja2 environment based on :attr:`jinja_options`
-        and :meth:`select_jinja_autoescape`.
-
-        .. versionadded:: 0.5
-        """
-        options = dict(self.jinja_options)
-        if 'autoescape' not in options:
-            options['autoescape'] = self.select_jinja_autoescape
-        return Environment(loader=_DispatchingJinjaLoader(self), **options)
-
-    def init_jinja_globals(self):
-        """Called directly after the environment was created to inject
-        some defaults (like `url_for`, `get_flashed_messages` and the
-        `tojson` filter.
-
-        .. versionadded:: 0.5
-        """
-        self.jinja_env.globals.update(
-            url_for=url_for,
-            get_flashed_messages=get_flashed_messages
-        )
-        self.jinja_env.filters['tojson'] = _tojson_filter
-
-    def select_jinja_autoescape(self, filename):
-        """Returns `True` if autoescaping should be active for the given
-        template name.
-
-        .. versionadded:: 0.5
-        """
-        if filename is None:
-            return False
-        return filename.endswith(('.html', '.htm', '.xml', '.xhtml'))
-
-    def update_template_context(self, context):
-        """Update the template context with some commonly used variables.
-        This injects request, session, config and g into the template
-        context as well as everything template context processors want
-        to inject.  Note that the as of Flask 0.6, the original values
-        in the context will not be overriden if a context processor
-        decides to return a value with the same key.
-
-        :param context: the context as a dictionary that is updated in place
-                        to add extra variables.
-        """
-        funcs = self.template_context_processors[None]
-        mod = _request_ctx_stack.top.request.module
-        if mod is not None and mod in self.template_context_processors:
-            funcs = chain(funcs, self.template_context_processors[mod])
-        orig_ctx = context.copy()
-        for func in funcs:
-            context.update(func())
-        # make sure the original values win.  This makes it possible to
-        # easier add new variables in context processors without breaking
-        # existing views.
-        context.update(orig_ctx)
-
-    def run(self, host='127.0.0.1', port=5000, **options):
-        """Runs the application on a local development server.  If the
-        :attr:`debug` flag is set the server will automatically reload
-        for code changes and show a debugger in case an exception happened.
-
-        If you want to run the application in debug mode, but disable the
-        code execution on the interactive debugger, you can pass
-        ``use_evalex=False`` as parameter.  This will keep the debugger's
-        traceback screen active, but disable code execution.
-
-        .. admonition:: Keep in Mind
-
-           Flask will suppress any server error with a generic error page
-           unless it is in debug mode.  As such to enable just the
-           interactive debugger without the code reloading, you have to
-           invoke :meth:`run` with ``debug=True`` and ``use_reloader=False``.
-           Setting ``use_debugger`` to `True` without being in debug mode
-           won't catch any exceptions because there won't be any to
-           catch.
-
-        :param host: the hostname to listen on.  set this to ``'0.0.0.0'``
-                     to have the server available externally as well.
-        :param port: the port of the webserver
-        :param options: the options to be forwarded to the underlying
-                        Werkzeug server.  See :func:`werkzeug.run_simple`
-                        for more information.
-        """
-        from werkzeug import run_simple
-        if 'debug' in options:
-            self.debug = options.pop('debug')
-        options.setdefault('use_reloader', self.debug)
-        options.setdefault('use_debugger', self.debug)
-        return run_simple(host, port, self, **options)
-
-    def test_client(self):
-        """Creates a test client for this application.  For information
-        about unit testing head over to :ref:`testing`.
-
-        The test client can be used in a `with` block to defer the closing down
-        of the context until the end of the `with` block.  This is useful if
-        you want to access the context locals for testing::
-
-            with app.test_client() as c:
-                rv = c.get('/?vodka=42')
-                assert request.args['vodka'] == '42'
-
-        .. versionchanged:: 0.4
-           added support for `with` block usage for the client.
-        """
-        from flask.testing import FlaskClient
-        return FlaskClient(self, self.response_class, use_cookies=True)
-
-    def open_session(self, request):
-        """Creates or opens a new session.  Default implementation stores all
-        session data in a signed cookie.  This requires that the
-        :attr:`secret_key` is set.
-
-        :param request: an instance of :attr:`request_class`.
-        """
-        key = self.secret_key
-        if key is not None:
-            return Session.load_cookie(request, self.session_cookie_name,
-                                       secret_key=key)
-
-    def save_session(self, session, response):
-        """Saves the session if it needs updates.  For the default
-        implementation, check :meth:`open_session`.
-
-        :param session: the session to be saved (a
-                        :class:`~werkzeug.contrib.securecookie.SecureCookie`
-                        object)
-        :param response: an instance of :attr:`response_class`
-        """
-        expires = domain = None
-        if session.permanent:
-            expires = datetime.utcnow() + self.permanent_session_lifetime
-        if self.config['SERVER_NAME'] is not None:
-            domain = '.' + self.config['SERVER_NAME']
-        session.save_cookie(response, self.session_cookie_name,
-                            expires=expires, httponly=True, domain=domain)
-
-    def register_module(self, module, **options):
-        """Registers a module with this application.  The keyword argument
-        of this function are the same as the ones for the constructor of the
-        :class:`Module` class and will override the values of the module if
-        provided.
-        """
-        options.setdefault('url_prefix', module.url_prefix)
-        options.setdefault('subdomain', module.subdomain)
-        state = _ModuleSetupState(self, **options)
-        for func in module._register_events:
-            func(state)
-
-    def add_url_rule(self, rule, endpoint=None, view_func=None, **options):
-        """Connects a URL rule.  Works exactly like the :meth:`route`
-        decorator.  If a view_func is provided it will be registered with the
-        endpoint.
-
-        Basically this example::
-
-            @app.route('/')
-            def index():
-                pass
-
-        Is equivalent to the following::
-
-            def index():
-                pass
-            app.add_url_rule('/', 'index', index)
-
-        If the view_func is not provided you will need to connect the endpoint
-        to a view function like so::
-
-            app.view_functions['index'] = index
-
-        .. versionchanged:: 0.2
-           `view_func` parameter added.
-
-        .. versionchanged:: 0.6
-           `OPTIONS` is added automatically as method.
-
-        :param rule: the URL rule as string
-        :param endpoint: the endpoint for the registered URL rule.  Flask
-                         itself assumes the name of the view function as
-                         endpoint
-        :param view_func: the function to call when serving a request to the
-                          provided endpoint
-        :param options: the options to be forwarded to the underlying
-                        :class:`~werkzeug.routing.Rule` object.  A change
-                        to Werkzeug is handling of method options.  methods
-                        is a list of methods this rule should be limited
-                        to (`GET`, `POST` etc.).  By default a rule
-                        just listens for `GET` (and implicitly `HEAD`).
-                        Starting with Flask 0.6, `OPTIONS` is implicitly
-                        added and handled by the standard request handling.
-        """
-        if endpoint is None:
-            endpoint = _endpoint_from_view_func(view_func)
-        options['endpoint'] = endpoint
-        methods = options.pop('methods', ('GET',))
-        provide_automatic_options = False
-        if 'OPTIONS' not in methods:
-            methods = tuple(methods) + ('OPTIONS',)
-            provide_automatic_options = True
-        rule = Rule(rule, methods=methods, **options)
-        rule.provide_automatic_options = provide_automatic_options
-        self.url_map.add(rule)
-        if view_func is not None:
-            self.view_functions[endpoint] = view_func
-
-    def route(self, rule, **options):
-        """A decorator that is used to register a view function for a
-        given URL rule.  Example::
-
-            @app.route('/')
-            def index():
-                return 'Hello World'
-
-        Variables parts in the route can be specified with angular
-        brackets (``/user/<username>``).  By default a variable part
-        in the URL accepts any string without a slash however a different
-        converter can be specified as well by using ``<converter:name>``.
-
-        Variable parts are passed to the view function as keyword
-        arguments.
-
-        The following converters are possible:
-
-        =========== ===========================================
-        `int`       accepts integers
-        `float`     like `int` but for floating point values
-        `path`      like the default but also accepts slashes
-        =========== ===========================================
-
-        Here some examples::
-
-            @app.route('/')
-            def index():
-                pass
-
-            @app.route('/<username>')
-            def show_user(username):
-                pass
-
-            @app.route('/post/<int:post_id>')
-            def show_post(post_id):
-                pass
-
-        An important detail to keep in mind is how Flask deals with trailing
-        slashes.  The idea is to keep each URL unique so the following rules
-        apply:
-
-        1. If a rule ends with a slash and is requested without a slash
-           by the user, the user is automatically redirected to the same
-           page with a trailing slash attached.
-        2. If a rule does not end with a trailing slash and the user request
-           the page with a trailing slash, a 404 not found is raised.
-
-        This is consistent with how web servers deal with static files.  This
-        also makes it possible to use relative link targets safely.
-
-        The :meth:`route` decorator accepts a couple of other arguments
-        as well:
-
-        :param rule: the URL rule as string
-        :param methods: a list of methods this rule should be limited
-                        to (`GET`, `POST` etc.).  By default a rule
-                        just listens for `GET` (and implicitly `HEAD`).
-                        Starting with Flask 0.6, `OPTIONS` is implicitly
-                        added and handled by the standard request handling.
-        :param subdomain: specifies the rule for the subdomain in case
-                          subdomain matching is in use.
-        :param strict_slashes: can be used to disable the strict slashes
-                               setting for this rule.  See above.
-        :param options: other options to be forwarded to the underlying
-                        :class:`~werkzeug.routing.Rule` object.
-        """
-        def decorator(f):
-            self.add_url_rule(rule, None, f, **options)
-            return f
-        return decorator
-
-    def errorhandler(self, code):
-        """A decorator that is used to register a function give a given
-        error code.  Example::
-
-            @app.errorhandler(404)
-            def page_not_found(error):
-                return 'This page does not exist', 404
-
-        You can also register a function as error handler without using
-        the :meth:`errorhandler` decorator.  The following example is
-        equivalent to the one above::
-
-            def page_not_found(error):
-                return 'This page does not exist', 404
-            app.error_handlers[404] = page_not_found
-
-        :param code: the code as integer for the handler
-        """
-        def decorator(f):
-            self.error_handlers[code] = f
-            return f
-        return decorator
-
-    def template_filter(self, name=None):
-        """A decorator that is used to register custom template filter.
-        You can specify a name for the filter, otherwise the function
-        name will be used. Example::
-
-          @app.template_filter()
-          def reverse(s):
-              return s[::-1]
-
-        :param name: the optional name of the filter, otherwise the
-                     function name will be used.
-        """
-        def decorator(f):
-            self.jinja_env.filters[name or f.__name__] = f
-            return f
-        return decorator
-
-    def before_request(self, f):
-        """Registers a function to run before each request."""
-        self.before_request_funcs.setdefault(None, []).append(f)
-        return f
-
-    def after_request(self, f):
-        """Register a function to be run after each request."""
-        self.after_request_funcs.setdefault(None, []).append(f)
-        return f
-
-    def context_processor(self, f):
-        """Registers a template context processor function."""
-        self.template_context_processors[None].append(f)
-        return f
-
-    def handle_http_exception(self, e):
-        """Handles an HTTP exception.  By default this will invoke the
-        registered error handlers and fall back to returning the
-        exception as response.
-
-        .. versionadded: 0.3
-        """
-        handler = self.error_handlers.get(e.code)
-        if handler is None:
-            return e
-        return handler(e)
-
-    def handle_exception(self, e):
-        """Default exception handling that kicks in when an exception
-        occours that is not catched.  In debug mode the exception will
-        be re-raised immediately, otherwise it is logged and the handler
-        for a 500 internal server error is used.  If no such handler
-        exists, a default 500 internal server error message is displayed.
-
-        .. versionadded: 0.3
-        """
-        got_request_exception.send(self, exception=e)
-        handler = self.error_handlers.get(500)
-        if self.debug:
-            raise
-        self.logger.exception('Exception on %s [%s]' % (
-            request.path,
-            request.method
-        ))
-        if handler is None:
-            return InternalServerError()
-        return handler(e)
-
-    def dispatch_request(self):
-        """Does the request dispatching.  Matches the URL and returns the
-        return value of the view or error handler.  This does not have to
-        be a response object.  In order to convert the return value to a
-        proper response object, call :func:`make_response`.
-        """
-        req = _request_ctx_stack.top.request
-        try:
-            if req.routing_exception is not None:
-                raise req.routing_exception
-            rule = req.url_rule
-            # if we provide automatic options for this URL and the
-            # request came with the OPTIONS method, reply automatically
-            if rule.provide_automatic_options and req.method == 'OPTIONS':
-                return self.make_default_options_response()
-            # otherwise dispatch to the handler for that endpoint
-            return self.view_functions[rule.endpoint](**req.view_args)
-        except HTTPException, e:
-            return self.handle_http_exception(e)
-
-    def make_default_options_response(self):
-        """This method is called to create the default `OPTIONS` response.
-        This can be changed through subclassing to change the default
-        behaviour of `OPTIONS` responses.
-
-        .. versionadded:: 0.7
-        """
-        # This would be nicer in Werkzeug 0.7, which however currently
-        # is not released.  Werkzeug 0.7 provides a method called
-        # allowed_methods() that returns all methods that are valid for
-        # a given path.
-        methods = []
-        try:
-            _request_ctx_stack.top.url_adapter.match(method='--')
-        except MethodNotAllowed, e:
-            methods = e.valid_methods
-        except HTTPException, e:
-            pass
-        rv = self.response_class()
-        rv.allow.update(methods)
-        return rv
-
-    def make_response(self, rv):
-        """Converts the return value from a view function to a real
-        response object that is an instance of :attr:`response_class`.
-
-        The following types are allowed for `rv`:
-
-        .. tabularcolumns:: |p{3.5cm}|p{9.5cm}|
-
-        ======================= ===========================================
-        :attr:`response_class`  the object is returned unchanged
-        :class:`str`            a response object is created with the
-                                string as body
-        :class:`unicode`        a response object is created with the
-                                string encoded to utf-8 as body
-        :class:`tuple`          the response object is created with the
-                                contents of the tuple as arguments
-        a WSGI function         the function is called as WSGI application
-                                and buffered as response object
-        ======================= ===========================================
-
-        :param rv: the return value from the view function
-        """
-        if rv is None:
-            raise ValueError('View function did not return a response')
-        if isinstance(rv, self.response_class):
-            return rv
-        if isinstance(rv, basestring):
-            return self.response_class(rv)
-        if isinstance(rv, tuple):
-            return self.response_class(*rv)
-        return self.response_class.force_type(rv, request.environ)
-
-    def create_url_adapter(self, request):
-        """Creates a URL adapter for the given request.  The URL adapter
-        is created at a point where the request context is not yet set up
-        so the request is passed explicitly.
-
-        .. versionadded:: 0.6
-        """
-        return self.url_map.bind_to_environ(request.environ,
-            server_name=self.config['SERVER_NAME'])
-
-    def preprocess_request(self):
-        """Called before the actual request dispatching and will
-        call every as :meth:`before_request` decorated function.
-        If any of these function returns a value it's handled as
-        if it was the return value from the view and further
-        request handling is stopped.
-        """
-        funcs = self.before_request_funcs.get(None, ())
-        mod = request.module
-        if mod and mod in self.before_request_funcs:
-            funcs = chain(funcs, self.before_request_funcs[mod])
-        for func in funcs:
-            rv = func()
-            if rv is not None:
-                return rv
-
-    def process_response(self, response):
-        """Can be overridden in order to modify the response object
-        before it's sent to the WSGI server.  By default this will
-        call all the :meth:`after_request` decorated functions.
-
-        .. versionchanged:: 0.5
-           As of Flask 0.5 the functions registered for after request
-           execution are called in reverse order of registration.
-
-        :param response: a :attr:`response_class` object.
-        :return: a new response object or the same, has to be an
-                 instance of :attr:`response_class`.
-        """
-        ctx = _request_ctx_stack.top
-        mod = ctx.request.module
-        if not isinstance(ctx.session, _NullSession):
-            self.save_session(ctx.session, response)
-        funcs = ()
-        if mod and mod in self.after_request_funcs:
-            funcs = reversed(self.after_request_funcs[mod])
-        if None in self.after_request_funcs:
-            funcs = chain(funcs, reversed(self.after_request_funcs[None]))
-        for handler in funcs:
-            response = handler(response)
-        return response
-
-    def request_context(self, environ):
-        """Creates a request context from the given environment and binds
-        it to the current context.  This must be used in combination with
-        the `with` statement because the request is only bound to the
-        current context for the duration of the `with` block.
-
-        Example usage::
-
-            with app.request_context(environ):
-                do_something_with(request)
-
-        The object returned can also be used without the `with` statement
-        which is useful for working in the shell.  The example above is
-        doing exactly the same as this code::
-
-            ctx = app.request_context(environ)
-            ctx.push()
-            try:
-                do_something_with(request)
-            finally:
-                ctx.pop()
-
-        The big advantage of this approach is that you can use it without
-        the try/finally statement in a shell for interactive testing:
-
-        >>> ctx = app.test_request_context()
-        >>> ctx.bind()
-        >>> request.path
-        u'/'
-        >>> ctx.unbind()
-
-        .. versionchanged:: 0.3
-           Added support for non-with statement usage and `with` statement
-           is now passed the ctx object.
-
-        :param environ: a WSGI environment
-        """
-        return _RequestContext(self, environ)
-
-    def test_request_context(self, *args, **kwargs):
-        """Creates a WSGI environment from the given values (see
-        :func:`werkzeug.create_environ` for more information, this
-        function accepts the same arguments).
-        """
-        from werkzeug import create_environ
-        environ_overrides = kwargs.setdefault('environ_overrides', {})
-        if self.config.get('SERVER_NAME'):
-            server_name = self.config.get('SERVER_NAME')
-            if ':' not in server_name:
-                http_host, http_port = server_name, '80'
-            else:
-                http_host, http_port = server_name.split(':', 1)
-
-            environ_overrides.setdefault('SERVER_NAME', server_name)
-            environ_overrides.setdefault('HTTP_HOST', server_name)
-            environ_overrides.setdefault('SERVER_PORT', http_port)
-        return self.request_context(create_environ(*args, **kwargs))
-
-    def wsgi_app(self, environ, start_response):
-        """The actual WSGI application.  This is not implemented in
-        `__call__` so that middlewares can be applied without losing a
-        reference to the class.  So instead of doing this::
-
-            app = MyMiddleware(app)
-
-        It's a better idea to do this instead::
-
-            app.wsgi_app = MyMiddleware(app.wsgi_app)
-
-        Then you still have the original application object around and
-        can continue to call methods on it.
-
-        .. versionchanged:: 0.4
-           The :meth:`after_request` functions are now called even if an
-           error handler took over request processing.  This ensures that
-           even if an exception happens database have the chance to
-           properly close the connection.
-
-        :param environ: a WSGI environment
-        :param start_response: a callable accepting a status code,
-                               a list of headers and an optional
-                               exception context to start the response
-        """
-        with self.request_context(environ):
-            try:
-                request_started.send(self)
-                rv = self.preprocess_request()
-                if rv is None:
-                    rv = self.dispatch_request()
-                response = self.make_response(rv)
-            except Exception, e:
-                response = self.make_response(self.handle_exception(e))
-            try:
-                response = self.process_response(response)
-            except Exception, e:
-                response = self.make_response(self.handle_exception(e))
-            request_finished.send(self, response=response)
-            return response(environ, start_response)
-
-    def __call__(self, environ, start_response):
-        """Shortcut for :attr:`wsgi_app`."""
-        return self.wsgi_app(environ, start_response)

File src/lib/flask/app.pyc

Binary file removed.

File src/lib/flask/config.py

-# -*- coding: utf-8 -*-
-"""
-    flask.config
-    ~~~~~~~~~~~~
-
-    Implements the configuration related objects.
-
-    :copyright: (c) 2010 by Armin Ronacher.
-    :license: BSD, see LICENSE for more details.
-"""
-
-from __future__ import with_statement
-
-import imp
-import os
-import sys
-
-from werkzeug import import_string
-
-
-class ConfigAttribute(object):
-    """Makes an attribute forward to the config"""
-
-    def __init__(self, name):
-        self.__name__ = name
-
-    def __get__(self, obj, type=None):
-        if obj is None:
-            return self
-        return obj.config[self.__name__]
-
-    def __set__(self, obj, value):
-        obj.config[self.__name__] = value
-
-
-class Config(dict):
-    """Works exactly like a dict but provides ways to fill it from files
-    or special dictionaries.  There are two common patterns to populate the
-    config.
-
-    Either you can fill the config from a config file::
-
-        app.config.from_pyfile('yourconfig.cfg')
-
-    Or alternatively you can define the configuration options in the
-    module that calls :meth:`from_object` or provide an import path to
-    a module that should be loaded.  It is also possible to tell it to
-    use the same module and with that provide the configuration values
-    just before the call::
-
-        DEBUG = True
-        SECRET_KEY = 'development key'
-        app.config.from_object(__name__)
-
-    In both cases (loading from any Python file or loading from modules),
-    only uppercase keys are added to the config.  This makes it possible to use
-    lowercase values in the config file for temporary values that are not added
-    to the config or to define the config keys in the same file that implements
-    the application.
-
-    Probably the most interesting way to load configurations is from an
-    environment variable pointing to a file::
-
-        app.config.from_envvar('YOURAPPLICATION_SETTINGS')
-
-    In this case before launching the application you have to set this
-    environment variable to the file you want to use.  On Linux and OS X
-    use the export statement::
-
-        export YOURAPPLICATION_SETTINGS='/path/to/config/file'
-
-    On windows use `set` instead.
-
-    :param root_path: path to which files are read relative from.  When the
-                      config object is created by the application, this is
-                      the application's :attr:`~flask.Flask.root_path`.
-    :param defaults: an optional dictionary of default values
-    """
-
-    def __init__(self, root_path, defaults=None):
-        dict.__init__(self, defaults or {})
-        self.root_path = root_path
-
-    def from_envvar(self, variable_name, silent=False):
-        """Loads a configuration from an environment variable pointing to
-        a configuration file.  This basically is just a shortcut with nicer
-        error messages for this line of code::
-
-            app.config.from_pyfile(os.environ['YOURAPPLICATION_SETTINGS'])
-
-        :param variable_name: name of the environment variable
-        :param silent: set to `True` if you want silent failing for missing
-                       files.
-        :return: bool. `True` if able to load config, `False` otherwise.
-        """
-        rv = os.environ.get(variable_name)
-        if not rv:
-            if silent:
-                return False
-            raise RuntimeError('The environment variable %r is not set '
-                               'and as such configuration could not be '
-                               'loaded.  Set this variable and make it '
-                               'point to a configuration file' %
-                               variable_name)
-        self.from_pyfile(rv)
-        return True
-
-    def from_pyfile(self, filename):
-        """Updates the values in the config from a Python file.  This function
-        behaves as if the file was imported as module with the
-        :meth:`from_object` function.
-
-        :param filename: the filename of the config.  This can either be an
-                         absolute filename or a filename relative to the
-                         root path.
-        """
-        filename = os.path.join(self.root_path, filename)
-        d = imp.new_module('config')
-        d.__file__ = filename
-        try:
-            execfile(filename, d.__dict__)
-        except IOError, e:
-            e.strerror = 'Unable to load configuration file (%s)' % e.strerror
-            raise
-        self.from_object(d)
-
-    def from_object(self, obj):
-        """Updates the values from the given object.  An object can be of one
-        of the following two types:
-
-        -   a string: in this case the object with that name will be imported
-        -   an actual object reference: that object is used directly
-
-        Objects are usually either modules or classes.
-
-        Just the uppercase variables in that object are stored in the config
-        after lowercasing.  Example usage::
-
-            app.config.from_object('yourapplication.default_config')
-            from yourapplication import default_config
-            app.config.from_object(default_config)
-
-        You should not use this function to load the actual configuration but
-        rather configuration defaults.  The actual config should be loaded
-        with :meth:`from_pyfile` and ideally from a location not within the
-        package because the package might be installed system wide.
-
-        :param obj: an import name or object
-        """
-        if isinstance(obj, basestring):
-            obj = import_string(obj)
-        for key in dir(obj):
-            if key.isupper():
-                self[key] = getattr(obj, key)
-
-    def __repr__(self):
-        return '<%s %s>' % (self.__class__.__name__, dict.__repr__(self))

File src/lib/flask/config.pyc

Binary file removed.

File src/lib/flask/ctx.py

-# -*- coding: utf-8 -*-
-"""
-    flask.ctx
-    ~~~~~~~~~
-
-    Implements the objects required to keep the context.
-
-    :copyright: (c) 2010 by Armin Ronacher.
-    :license: BSD, see LICENSE for more details.
-"""
-
-from werkzeug.exceptions import HTTPException
-
-from .globals import _request_ctx_stack
-from .session import _NullSession
-
-
-class _RequestGlobals(object):
-    pass
-
-
-class _RequestContext(object):
-    """The request context contains all request relevant information.  It is
-    created at the beginning of the request and pushed to the
-    `_request_ctx_stack` and removed at the end of it.  It will create the
-    URL adapter and request object for the WSGI environment provided.
-    """
-
-    def __init__(self, app, environ):
-        self.app = app
-        self.request = app.request_class(environ)
-        self.url_adapter = app.create_url_adapter(self.request)
-        self.session = app.open_session(self.request)
-        if self.session is None:
-            self.session = _NullSession()
-        self.g = _RequestGlobals()
-        self.flashes = None
-
-        try:
-            url_rule, self.request.view_args = \
-                self.url_adapter.match(return_rule=True)
-            self.request.url_rule = url_rule
-        except HTTPException, e:
-            self.request.routing_exception = e
-
-    def push(self):
-        """Binds the request context."""
-        _request_ctx_stack.push(self)
-
-    def pop(self):
-        """Pops the request context."""
-        _request_ctx_stack.pop()
-
-    def __enter__(self):
-        self.push()
-        return self
-
-    def __exit__(self, exc_type, exc_value, tb):
-        # do not pop the request stack if we are in debug mode and an
-        # exception happened.  This will allow the debugger to still
-        # access the request object in the interactive shell.  Furthermore
-        # the context can be force kept alive for the test client.
-        # See flask.testing for how this works.
-        if not self.request.environ.get('flask._preserve_context') and \
-           (tb is None or not self.app.debug):
-            self.pop()

File src/lib/flask/ctx.pyc

Binary file removed.

File src/lib/flask/globals.py

-# -*- coding: utf-8 -*-
-"""
-    flask.globals
-    ~~~~~~~~~~~~~
-
-    Defines all the global objects that are proxies to the current
-    active context.
-
-    :copyright: (c) 2010 by Armin Ronacher.
-    :license: BSD, see LICENSE for more details.
-"""
-
-from functools import partial
-from werkzeug import LocalStack, LocalProxy
-
-def _lookup_object(name):
-    top = _request_ctx_stack.top
-    if top is None:
-        raise RuntimeError('working outside of request context')
-    return getattr(top, name)
-
-# context locals
-_request_ctx_stack = LocalStack()
-current_app = LocalProxy(partial(_lookup_object, 'app'))
-request = LocalProxy(partial(_lookup_object, 'request'))
-session = LocalProxy(partial(_lookup_object, 'session'))
-g = LocalProxy(partial(_lookup_object, 'g'))

File src/lib/flask/globals.pyc

Binary file removed.

File src/lib/flask/helpers.py

-# -*- coding: utf-8 -*-
-"""
-    flask.helpers
-    ~~~~~~~~~~~~~
-
-    Implements various helpers.
-
-    :copyright: (c) 2010 by Armin Ronacher.
-    :license: BSD, see LICENSE for more details.
-"""
-
-import os
-import sys
-import posixpath
-import mimetypes
-from time import time
-from zlib import adler32
-
-# try to load the best simplejson implementation available.  If JSON
-# is not installed, we add a failing class.
-json_available = True
-json = None
-try:
-    import simplejson as json
-except ImportError:
-    try:
-        import json
-    except ImportError:
-        try:
-            # Google Appengine offers simplejson via django
-            from django.utils import simplejson as json
-        except ImportError:
-            json_available = False
-
-
-from werkzeug import Headers, wrap_file, cached_property
-from werkzeug.exceptions import NotFound
-
-from jinja2 import FileSystemLoader
-
-from .globals import session, _request_ctx_stack, current_app, request
-
-
-def _assert_have_json():
-    """Helper function that fails if JSON is unavailable."""
-    if not json_available:
-        raise RuntimeError('simplejson not installed')
-
-# figure out if simplejson escapes slashes.  This behaviour was changed
-# from one version to another without reason.
-if not json_available or '\\/' not in json.dumps('/'):
-
-    def _tojson_filter(*args, **kwargs):
-        if __debug__:
-            _assert_have_json()
-        return json.dumps(*args, **kwargs).replace('/', '\\/')
-else:
-    _tojson_filter = json.dumps
-
-
-def _endpoint_from_view_func(view_func):
-    """Internal helper that returns the default endpoint for a given
-    function.  This always is the function name.
-    """
-    assert view_func is not None, 'expected view func if endpoint ' \
-                                  'is not provided.'
-    return view_func.__name__
-
-
-def jsonify(*args, **kwargs):
-    """Creates a :class:`~flask.Response` with the JSON representation of
-    the given arguments with an `application/json` mimetype.  The arguments
-    to this function are the same as to the :class:`dict` constructor.
-
-    Example usage::
-
-        @app.route('/_get_current_user')
-        def get_current_user():
-            return jsonify(username=g.user.username,
-                           email=g.user.email,
-                           id=g.user.id)
-
-    This will send a JSON response like this to the browser::
-
-        {
-            "username": "admin",
-            "email": "admin@localhost",
-            "id": 42
-        }
-
-    This requires Python 2.6 or an installed version of simplejson.  For
-    security reasons only objects are supported toplevel.  For more
-    information about this, have a look at :ref:`json-security`.
-
-    .. versionadded:: 0.2
-    """
-    if __debug__:
-        _assert_have_json()
-    return current_app.response_class(json.dumps(dict(*args, **kwargs),
-        indent=None if request.is_xhr else 2), mimetype='application/json')
-
-
-def make_response(*args):
-    """Sometimes it is necessary to set additional headers in a view.  Because
-    views do not have to return response objects but can return a value that
-    is converted into a response object by Flask itself, it becomes tricky to
-    add headers to it.  This function can be called instead of using a return
-    and you will get a response object which you can use to attach headers.
-
-    If view looked like this and you want to add a new header::
-
-        def index():
-            return render_template('index.html', foo=42)
-
-    You can now do something like this::
-
-        def index():
-            response = make_response(render_template('index.html', foo=42))
-            response.headers['X-Parachutes'] = 'parachutes are cool'
-            return response
-
-    This function accepts the very same arguments you can return from a
-    view function.  This for example creates a response with a 404 error
-    code::
-
-        response = make_response(render_template('not_found.html'), 404)
-
-    Internally this function does the following things:
-
-    -   if no arguments are passed, it creates a new response argument
-    -   if one argument is passed, :meth:`flask.Flask.make_response`
-        is invoked with it.
-    -   if more than one argument is passed, the arguments are passed
-        to the :meth:`flask.Flask.make_response` function as tuple.
-
-    .. versionadded:: 0.6
-    """
-    if not args:
-        return current_app.response_class()
-    if len(args) == 1:
-        args = args[0]
-    return current_app.make_response(args)
-
-
-def url_for(endpoint, **values):
-    """Generates a URL to the given endpoint with the method provided.
-    The endpoint is relative to the active module if modules are in use.
-
-    Here are some examples:
-
-    ==================== ======================= =============================
-    Active Module        Target Endpoint         Target Function
-    ==================== ======================= =============================
-    `None`               ``'index'``             `index` of the application
-    `None`               ``'.index'``            `index` of the application
-    ``'admin'``          ``'index'``             `index` of the `admin` module
-    any                  ``'.index'``            `index` of the application
-    any                  ``'admin.index'``       `index` of the `admin` module
-    ==================== ======================= =============================
-
-    Variable arguments that are unknown to the target endpoint are appended
-    to the generated URL as query arguments.
-
-    For more information, head over to the :ref:`Quickstart <url-building>`.
-
-    :param endpoint: the endpoint of the URL (name of the function)
-    :param values: the variable arguments of the URL rule
-    :param _external: if set to `True`, an absolute URL is generated.
-    """
-    ctx = _request_ctx_stack.top
-    if '.' not in endpoint:
-        mod = ctx.request.module
-        if mod is not None:
-            endpoint = mod + '.' + endpoint
-    elif endpoint.startswith('.'):
-        endpoint = endpoint[1:]
-    external = values.pop('_external', False)
-    return ctx.url_adapter.build(endpoint, values, force_external=external)
-
-
-def get_template_attribute(template_name, attribute):
-    """Loads a macro (or variable) a template exports.  This can be used to
-    invoke a macro from within Python code.  If you for example have a
-    template named `_cider.html` with the following contents:
-
-    .. sourcecode:: html+jinja
-
-       {% macro hello(name) %}Hello {{ name }}!{% endmacro %}
-
-    You can access this from Python code like this::
-
-        hello = get_template_attribute('_cider.html', 'hello')
-        return hello('World')
-
-    .. versionadded:: 0.2
-
-    :param template_name: the name of the template
-    :param attribute: the name of the variable of macro to acccess
-    """
-    return getattr(current_app.jinja_env.get_template(template_name).module,
-                   attribute)
-
-
-def flash(message, category='message'):
-    """Flashes a message to the next request.  In order to remove the
-    flashed message from the session and to display it to the user,
-    the template has to call :func:`get_flashed_messages`.
-
-    .. versionchanged: 0.3
-       `category` parameter added.
-
-    :param message: the message to be flashed.
-    :param category: the category for the message.  The following values
-                     are recommended: ``'message'`` for any kind of message,
-                     ``'error'`` for errors, ``'info'`` for information
-                     messages and ``'warning'`` for warnings.  However any
-                     kind of string can be used as category.
-    """
-    session.setdefault('_flashes', []).append((category, message))
-
-
-def get_flashed_messages(with_categories=False):
-    """Pulls all flashed messages from the session and returns them.
-    Further calls in the same request to the function will return
-    the same messages.  By default just the messages are returned,
-    but when `with_categories` is set to `True`, the return value will
-    be a list of tuples in the form ``(category, message)`` instead.
-
-    Example usage:
-
-    .. sourcecode:: html+jinja
-
-        {% for category, msg in get_flashed_messages(with_categories=true) %}
-          <p class=flash-{{ category }}>{{ msg }}
-        {% endfor %}
-
-    .. versionchanged:: 0.3
-       `with_categories` parameter added.
-
-    :param with_categories: set to `True` to also receive categories.
-    """
-    flashes = _request_ctx_stack.top.flashes
-    if flashes is None:
-        _request_ctx_stack.top.flashes = flashes = session.pop('_flashes', [])
-    if not with_categories:
-        return [x[1] for x in flashes]
-    return flashes
-
-
-def send_file(filename_or_fp, mimetype=None, as_attachment=False,
-              attachment_filename=None, add_etags=True,
-              cache_timeout=60 * 60 * 12, conditional=False):
-    """Sends the contents of a file to the client.  This will use the
-    most efficient method available and configured.  By default it will
-    try to use the WSGI server's file_wrapper support.  Alternatively
-    you can set the application's :attr:`~Flask.use_x_sendfile` attribute
-    to ``True`` to directly emit an `X-Sendfile` header.  This however
-    requires support of the underlying webserver for `X-Sendfile`.
-
-    By default it will try to guess the mimetype for you, but you can
-    also explicitly provide one.  For extra security you probably want
-    to sent certain files as attachment (HTML for instance).  The mimetype
-    guessing requires a `filename` or an `attachment_filename` to be
-    provided.
-
-    Please never pass filenames to this function from user sources without
-    checking them first.  Something like this is usually sufficient to
-    avoid security problems::
-
-        if '..' in filename or filename.startswith('/'):
-            abort(404)
-
-    .. versionadded:: 0.2
-
-    .. versionadded:: 0.5
-       The `add_etags`, `cache_timeout` and `conditional` parameters were
-       added.  The default behaviour is now to attach etags.
-
-    .. versionchanged:: 0.7
-       mimetype guessing and etag support for file objects was
-       deprecated because it was unreliable.  Pass a filename if you are
-       able to, otherwise attach an etag yourself.  This functionality
-       will be removed in Flask 1.0
-
-    :param filename_or_fp: the filename of the file to send.  This is
-                           relative to the :attr:`~Flask.root_path` if a
-                           relative path is specified.
-                           Alternatively a file object might be provided
-                           in which case `X-Sendfile` might not work and
-                           fall back to the traditional method.  Make sure
-                           that the file pointer is positioned at the start
-                           of data to send before calling :func:`send_file`.
-    :param mimetype: the mimetype of the file if provided, otherwise
-                     auto detection happens.
-    :param as_attachment: set to `True` if you want to send this file with
-                          a ``Content-Disposition: attachment`` header.
-    :param attachment_filename: the filename for the attachment if it
-                                differs from the file's filename.
-    :param add_etags: set to `False` to disable attaching of etags.
-    :param conditional: set to `True` to enable conditional responses.
-    :param cache_timeout: the timeout in seconds for the headers.
-    """
-    mtime = None
-    if isinstance(filename_or_fp, basestring):
-        filename = filename_or_fp
-        file = None
-    else:
-        from warnings import warn
-        file = filename_or_fp
-        filename = getattr(file, 'name', None)
-
-        # XXX: this behaviour is now deprecated because it was unreliable.
-        # removed in Flask 1.0
-        if not attachment_filename and not mimetype \
-           and isinstance(filename, basestring):
-            warn(DeprecationWarning('The filename support for file objects '
-                'passed to send_file is not deprecated.  Pass an '
-                'attach_filename if you want mimetypes to be guessed.'),
-                stacklevel=2)
-        if add_etags:
-            warn(DeprecationWarning('In future flask releases etags will no '
-                'longer be generated for file objects passed to the send_file '
-                'function because this behaviour was unreliable.  Pass '
-                'filenames instead if possible, otherwise attach an etag '
-                'yourself based on another value'), stacklevel=2)
-
-    if filename is not None:
-        if not os.path.isabs(filename):
-            filename = os.path.join(current_app.root_path, filename)
-    if mimetype is None and (filename or attachment_filename):
-        mimetype = mimetypes.guess_type(filename or attachment_filename)[0]
-    if mimetype is None:
-        mimetype = 'application/octet-stream'
-
-    headers = Headers()
-    if as_attachment:
-        if attachment_filename is None:
-            if filename is None:
-                raise TypeError('filename unavailable, required for '
-                                'sending as attachment')
-            attachment_filename = os.path.basename(filename)
-        headers.add('Content-Disposition', 'attachment',
-                    filename=attachment_filename)
-
-    if current_app.use_x_sendfile and filename:
-        if file is not None:
-            file.close()
-        headers['X-Sendfile'] = filename
-        data = None
-    else:
-        if file is None:
-            file = open(filename, 'rb')
-            mtime = os.path.getmtime(filename)
-        data = wrap_file(request.environ, file)
-
-    rv = current_app.response_class(data, mimetype=mimetype, headers=headers,
-                                    direct_passthrough=True)
-
-    # if we know the file modification date, we can store it as the
-    # current time to better support conditional requests.  Werkzeug
-    # as of 0.6.1 will override this value however in the conditional
-    # response with the current time.  This will be fixed in Werkzeug
-    # with a new release, however many WSGI servers will still emit
-    # a separate date header.