API

flask_via

class flask_via.RoutesImporter

Bases: object

Handles the import of routes module and obtaining a list of routes from that module as well as loading each route onto the application

New in version 2014.05.06.

include(routes_module, routes_name)

Imports a routes module and gets the routes from within that module and returns them.

Parameters:

• routes_module (str) – Python dotted path to routes module
• routes_name (str) – Module attribute name to use when attempted to get the routes

Returns:

List of routes in the module

Return type:

list

Raises:

• ImportError – If the route module cannot be imported
• AttributeError – If routes do not exist in the moduke

load(app, routes, **kwargs)

Loads passed routes onto the application by calling each routes add_to_app method which must be implemented by the route class.

class flask_via.Via(app=None, *args, **kwargs)

Bases: flask_via.RoutesImporter

Flask-VIa integration into Flask applications. Flask-Via can be integrated in two different ways depending on how you have setup your Flask application.

New in version 2014.05.06.

You can bind to a specific flask application:

from flask import Flask
from flask.ext.via import Via
from flask.ext.via.routers.flask import Functional

app = Flask(__name__)

def foo(bar=None):
    return 'Foo View!'

routes = [
    Functional('/foo', foo),
    Functional('/foo/<bar>', foo, endpoint='foo2'),
]

via = Via(app, routes_module='path.to.here')

if __name__ == "__main__":
    app.run(debug=True)

Or if you use an application factory you can use flask_via.Via.init_app():

from flask import Flask
from flask.ext.via import Via
from flask.ext.via.routers.flask import Functional

via = Via()

def foo(bar=None):
    return 'Foo View!'

routes = [
    Functional('/foo', foo),
    Functional('/foo/<bar>', foo, endpoint='foo2'),
]

def create_app():
    app = Flask(__name__)
    via.init_app(app)
    return app

app = create_app()

if __name__ == "__main__":
    app.run(debug=True)

init_app(app, routes_module=None, routes_name=None, **kwargs)

Initialises Flask extension. Bootstraps the automatic route registration process.

Changed in version 2014.05.19:

• Replace NotImplementedError with ImproperlyConfigured

• routes_name keyword argument default value set to None

• routes_name can now be configured using VIA_ROUTES_NAME app configuration variable. If routes_name keyword argument and VIA_ROUTES_NAME are not configured the default will be routes.

Changed in version 2014.05.19.2:

• Improved init_app method

Parameters:

app (flask.app.Flask) – Flask application instance

Keyword Arguments:  

• route_module (str, optional) – Python dotted path to where routes are defined, defaults to None
• routes_name (str, optional) – Within the routes module look for a variable of this name, defaults to None
• **kwargs – Arbitrary keyword arguments passed to add_url_rule

Raises:

ImproperlyConfigured – If VIA_ROUTES_MODULE is not configured in appluication config and route_module keyword argument has not been provided.

flask_via.exceptions

Custom exceptions which can be thrown by Flask-Via.

exception flask_via.exceptions.ImproperlyConfigured

Bases: exceptions.Exception

Raised in the event Flask-Via has not been properly configured

flask_via.routers

Base router classes and utilities.

class flask_via.routers.BaseRouter

Bases: object

Base router class all routers should inherit from providing common router functionality.

New in version 2014.05.06.

Example

from flask.ext.via.routers import BaseRouter

class MyRouter(BaseRouter):

    def __init__(self, arg):
        ...

    def add_to_app(self, app):
        ...

__init__()

Constructor should be overridden to accept specific arguments for the router.

Raises:NotImplementedError – If method not implemented

add_to_app(app, **kwargs)

Method all routers require, which handles adding the route to the application instance.

Raises:NotImplementedError – If method not implemented

class flask_via.routers.Include(routes_module, routes_name=None, url_prefix=None, endpoint=None)

Bases: flask_via.routers.BaseRouter, flask_via.RoutesImporter

Adds the ability to include routes from other modules, this can be handy when you want to break out your routes into separate files for sanity.

New in version 2014.05.06.

Note

This is not a implementation of Flask blueprints

__init__(routes_module, routes_name=None, url_prefix=None, endpoint=None)

Constructor for Include router, taking the passed arguments and storing them on the instance.

Changed in version 2014.05.08:

• url_prefix argument added

Changed in version 2014.05.19:

• routes_name keyword argument default value set to None

• endpoint keyword argument added

Parameters:

routes_module (str) – Python dotted path to the routes module

Keyword Arguments:  

• routes_name (str, optional) – Name of the variable holding the routes in the module, defaults to routes
• url_prefix (str, optional) – Adds a url prefix to all routes included by the router, defaults to None
• endpoint (str, optional) – Prefix an endpoint to all routes included, defaults to None

add_to_app(app, **kwargs)

Instead of adding a route to the flask application this will include and load routes similar, same as in the flask_via.Via class.abs

Changed in version 2014.05.08:

• url_prefix now injected into kwargs when loading in routes

Changed in version 2014.05.19:

• endpoint now injects into kwargs when loading in routes

Parameters:

• app (flask.app.Flask) – Flask application instance
• **kwargs – Arbitrary keyword arguments passed in to init_app

flask_via.routers.default

A set of flask specific router classes to be used when defining routes.

Example

from flask.ext.via.routes.flask import Basic, Pluggable
from yourapp.views import BarView, foo_view

routes = [
    Basic('/foo', 'foo', foo_view),
    Pluggable('/bar', BarView, 'bar'),
]

class flask_via.routers.default.Basic(*args, **kwargs)

Bases: flask_via.routers.default.Functional

This is deprecated and will be removed in the next release. Please use Functional.

New in version 2014.05.06.

Deprecated since version 2014.05.19.

__init__(*args, **kwargs)

Issues DeprecationWarning as this is deprecated and will be removed in a later version.

class flask_via.routers.default.Blueprint(name_or_instance, module=None, routes_module_name='routes', routes_name=None, static_folder=None, static_url_path=None, template_folder=None, url_prefix=None, subdomain=None, url_defaults=None)

Bases: flask_via.routers.BaseRouter, flask_via.RoutesImporter

Registers a flask blueprint and registers routes to that blueprint, similar to flask_via.routers.Include.

New in version 2014.05.06.

Example

Auto creates Blueprint instance*

from flask.ext.via.routers import default

routes = [
    default.Blueprint('foo', 'flask_via.examples.blueprints.foo')
]

Pass existing Blueprint instance*

from flask import Blueprint
from flask.ext.via.routers import default

blueprint = Blueprint('foo', __name__)

routes = [
    default.Blueprint(blueprint)
]

__init__(name_or_instance, module=None, routes_module_name='routes', routes_name=None, static_folder=None, static_url_path=None, template_folder=None, url_prefix=None, subdomain=None, url_defaults=None)

Constructor for blueprint router.

Changed in version 2014.05.19:

• Replaced name with name_or_instance argument which allows the router to take an already instantiated blueprint instance.

• module argument optional when instance is passed as the first argument

• routes_name keyword argument default value set to None

Parameters:

name (str, flask.blueprints.Blueprint) – Blueprint name or a Blueprint class instance

Keyword Arguments:  

• module (str) – Python dotted path to the blueprint module
• routes_module_name (str, optional) – The module Flask-Via will look for within the blueprint module which contains the routes, defaults to routes
• routes_name (str, optional) – Name of the variable holding the routes in the module, defaults to None
• static_folder (str, optional) – Path to static files for blueprint, defaults to None
• static_url_path (str, optional) – URL path for blueprint static files, defaults to None
• template_folder (str, optional) – Templates folder name, defaults to None
• url_prefix (str, optional) – URL prefix for routes served within the blueprint, defaults to None
• subdomain (str, optional) – Sub domain for blueprint, defaults to None
• url_defaults (function, optional) – Callback function for URL defaults for this blueprint. It’s called with the endpoint and values and should update the values passed in place, defaults to None.

add_to_app(app, **kwargs)

Creates a Flask blueprint and registers routes with that blueprint, this means any routes defined will be added to the blueprint rather than the application.

Parameters:

• app (flask.app.Flask) – Flask application instance
• **kwargs – Arbitrary keyword arguments passed in to init_app

blueprint(**kwargs)

Returns a Flask Blueprint instance, either one provided or created here.

Changed in version 2014.05.19:

• Renamed method from create_blueprint to blueprint

• If instance attribute exists, use this is as the blueprint else create the blueprint.

• Support for endpoint prefixing

Returns:An instantiated Flask Blueprint instance Return type:flask.blueprints.Blueprint

routes_module

Generates the routes module path, this is built from self.module and self.routes_module_name.

Returns:Python dotted path to the routes module containing routes. Return type:str

class flask_via.routers.default.Functional(url, func, endpoint=None)

Bases: flask_via.routers.BaseRouter

A basic Flask router, used for the most basic form of flask routes, namely functionally based views which would normally use the @route decorator.

New in version 2014.05.19.

Example

from flask.ext.via.routes import default
from yourapp.views import foo_view, bar_view

routes = [
    default.Functional('/foo', 'foo', foo_view),
    default.Functional('/bar', 'bar', bar_view),
]

__init__(url, func, endpoint=None)

Basic router constructor, stores passed arguments on the instance.

Parameters:

• url (str) – The url to use for the route
• func (function) – The view function to connect the route with

Keyword Arguments:  

endpoint (str, optional) – Optional endpoint string, by default flask will use the view function name as the endpoint name, use this argument to change the endpoint name.

add_to_app(app, **kwargs)

Adds the url route to the flask application object.mro

Changed in version 2014.05.08:

• url_prefix can now be prefixed if present in kwargs

Changed in version 2014.05.19:

• endpoint can now be prefixed if present in kwargs

Parameters:

• app (flask.app.Flask) – Flask application instance
• **kwargs – Arbitrary keyword arguments passed in to init_app

class flask_via.routers.default.Pluggable(url, view, endpoint, **kwargs)

Bases: flask_via.routers.BaseRouter

Pluggable View router class, allows Flask pluggable view routes to be added to the flask application.

New in version 2014.05.06.

Example

from flask.ext.via.routers import flask
from flask.views import MethodView

class FooView(MethodView):
    def get(self):
        return 'foo view'

class BarView(MethodView):
    def get(self):
        return 'bar view'

routes = [
    flask.Pluggable('/', FooView, 'foo')
    flask.Pluggable('/', BarView, 'bar')
]

__init__(url, view, endpoint, **kwargs)

Pluggable router constructor, stores passed arguments on instance.

Changed in version 2014.05.19:

• Added view argument

• Added endpoint argument

Parameters:

• url (str) – The url to use for the route
• view (class) – The Flask pluggable view class, for example: * flask.views.View * flask.views.MethodView
• endpoint (str) – The Flask endpoint name for the view, this is required for Flask pluggable views.
• **kwargs – Arbitrary keyword arguments for add_url_rule

add_to_app(app, **kwargs)

Adds the url route to the flask application object.

Changed in version 2014.05.19: Updated add_url_rule to support endpoint prefixing and support new way of defining Pluggable views

Parameters:

• app (flask.app.Flask) – Flask application instance
• **kwargs – Arbitrary keyword arguments passed in to init_app

flask_via.routers.restful

Routers for the Flask-Restful framework.

class flask_via.routers.restful.Resource(url, resource, endpoint=None)

Bases: flask_via.routers.BaseRouter

The Resource router allows you to define Flask-Restful routes and have those API resources added to the application automatically. For this to work you must at init_app time pass a optional keyword argument restful_api to init_app with its value being the restful api extension instance.

New in version 2014.05.06.

Example

app = Flask(__name__)
api = restful.Api(app)

class FooResource(restful.Resource):

    def get(self):
        return {'hello': 'world'}

routes = [
    Resource('/foo', FooResource)
]

via = Via()
via.init_app(
    app,
    routes_module='flask_via.examples.restful',
    restful_api=api)

if __name__ == '__main__':
    app.run(debug=True)

__init__(url, resource, endpoint=None)

Constructor for flask restful resource router.

Parameters:

• url (str) – The url to use for the route
• resource – A flask restful.Resource resource class

Keyword Arguments:  

endpoint (str, optional) – Optional, override Flask-Restful automatic endpoint naming

add_to_app(app, **kwargs)

Adds the restul api resource route to the application.

Parameters:

• app (flask.app.Flask) – Flask application instance, this is ignored.
• **kwargs – Arbitrary keyword arguments

Raises:

NotImplementedError – If restful_api is not provided

flask_via.routers.admin

Routers for the Flask-Admin framework.

class flask_via.routers.admin.AdminRoute(view)

Bases: flask_via.routers.BaseRouter

The Admin router allows you to define Flask-Admin routes and have those views added to the application automatically. For this to work you must at init_app time pass a optional keyword argument flask_admin to init_app with its value being the Flask-Aadmin extension instance.

New in version 2014.05.08.

Note

Flask-Admin has its own way of handling defining urls so this router literally only requires the Flask-Admin view class.

Example

app = Flask(__name__)

admin = Admin(name='Admin')
admin.init_app(app)

class FooAdminView(BaseView):

    @expose('/')
    def index(self):
        return 'foo'

routes = [
    AdminRoute(FooAdminView(name='Foo'))
]

via = Via()
via.init_app(
    app,
    routes_module='flask_via.examples.admin',
    flask_admin=admin)

if __name__ == '__main__':
    app.run(debug=True)

__init__(view)

Admin route constructor, this router handles adding Flask-admin views to the application.

Parameters:view (flask_admin.base.AdminViewMeta) – The Flask Admin View Class

add_to_app(app, **kwargs)

Adds the Flask-Admin View to the Flask the application.

Parameters:

• app (flask.app.Flask) – Flask application instance, this is ignored.
• **kwargs – Arbitrary keyword arguments

Raises:

NotImplementedError – If flask_admin is not provided