Flask Version 0.7

Bug in Request Locals

Due to a bug in earlier implementations the request local proxies now raise a RuntimeError instead of an AttributeError when
they are unbound. If you caught these exceptions with AttributeError
before, you should catch them with RuntimeError now.

Additionally the send_file() function is now issuing deprecation warnings if you depend on functionality that will be removed in Flask 1.0. Previously it was possible to use etags
and mimetypes when file objects were passed. This was unreliable and caused issues for a few setups. If you get a deprecation warning, make sure to update your application to work with either filenames there or disable etag attaching and attach them yourself.

Old code:

return send_file(my_file_object)
return send_file(my_file_object)

New code:

return send_file(my_file_object, add_etags=False)

Upgrading to new Teardown Handling

We streamlined the behavior of the callbacks for request handling. For things that modify the response the after_request()
decorators continue to work as expected, but for things
that absolutely must happen at the end of request we introduced the new
teardown_request() decorator. Unfortunately that change also made after-request work differently under error
conditions. It’s not consistently skipped if exceptions happen whereas previously it might have been called twice to ensure it is executed at the end of the request.

If you have database connection code that looks like this:

@app.after_request
def after_request(response):
    g.db.close()
    return response

You are now encouraged to use this instead:

@app.teardown_request
def after_request(exception):
    if hasattr(g, 'db'):
        g.db.close()

On the upside this change greatly improves the internal code flow and makes it easier to customize the dispatching and error handling. This makes it now a lot easier to write unit tests as you can prevent closing down of database connections for a while.
You can take advantage of the fact that the teardown callbacks are called when the response context is removed from the stack so a test can query the database after request handling:

with app.test_client() as client:
    resp = client.get('/')
    # g.db is still bound if there is such a thing

# and here it's gone

Manual Error Handler Attaching

While it is still possible to attach error handlers to
Flask.error_handlers it’s discouraged to do so and in fact deprecated. In generaly we no longer recommend custom error handler
attaching via assignments to the underlying dictionary due to the more complex internal handling to support arbitrary exception classes and blueprints. See Flask.errorhandler() for
more information.

The proper upgrade is to change this:

app.error_handlers[403] = handle_error

Into this:

app.register_error_handler(403, handle_error)

Alternatively you should just attach the function with a decorator:

@app.errorhandler(403)
def handle_error(e):
    ...

(Note that register_error_handler() is new in Flask 0.7)

Blueprint Support

Blueprints replace the previous concept of “Modules” in Flask. They provide better semantics for various features and work better with large applications. The update script provided should be able to upgrade your applications automatically, but there
might be some cases where it fails to upgrade. What changed?

• Blueprints need explicit names. Modules had an automatic name guesssing scheme where the shortname for the module was taken from the last part of the import module. The upgrade script tries to guess that name but it might fail as this information could
  change at runtime.
• Blueprints have an inverse behavior for url_for(). Previously
  .foo told url_for() that
  it should look for the endpoint
  foo on the application. Now it means “relative to current module”. The script will inverse all calls to url_for() automatically for you.
  It will do this in a very eager way so you might end up with some unnecessary leading dots in your code if you’re not using modules.
• Blueprints do not automatically provide static folders. They will also no longer automatically export templates from a folder called
  templates next to their location however but it can be enabled from the constructor. Same with static files:
  if you want to continue serving static files you need to tell the constructor explicitly the path to the static folder (which can be relative to the blueprint’s module path).
• Rendering templates was simplified. Now the blueprints can provide template folders which are added to a general template searchpath. This means that you need to add another subfolder with the blueprint’s name into that folder if you want blueprintname/template.html as
  the template name.

If you continue to use the Module object which is deprecated, Flask will restore the previous behavior as good as possible. However we strongly recommend upgrading to the new blueprints as they provide a lot of useful improvement such as the
ability to attach a blueprint multiple times, blueprint specific error handlers and a lot more.