Flask¶

ConsenSys-Utils defines many resources for working with Flask application. It is highly recommended you have some basic knowledge of Flask before using ConsenSys-Utils.

Application Factory¶

ConsenSys-Utils provides useful resources to implement the Flask application factory pattern

class consensys_utils.flask.FlaskFactory(import_name=None, yaml_config_loader=<cfg_loader.loader.YamlConfigLoader object>, default_config=None, config_path=None, middlewares=None, extensions=None, hook_setters=None, blueprints=None, **flask_kwargs)[source]¶

ConsenSys Flask factory. It inherits from BaseFlaskFactory()

By default it applies

Middlewares

consensys_utils.flask.wsgi.apply_request_id_middleware(): A middleware to inject a custom Request ID header

Extensions

consensys_utils.flask.extensions.initialize_health_extension(): Init a Flask extension for health check
consensys_utils.flask.extensions.initialize_web3_extension(): Init a FlaskWeb3 extension

Hooks

consensys_utils.flask.hooks.set_request_id_hook(): Hook injecting Request ID header on``flask.request``

class consensys_utils.flask.BaseFlaskFactory(import_name=None, yaml_config_loader=<cfg_loader.loader.YamlConfigLoader object>, default_config=None, config_path=None, middlewares=None, extensions=None, hook_setters=None, blueprints=None, **flask_kwargs)[source]¶

A factory to create Flask application

>>> app_factory = BaseFlaskFactory(__name__)

When creating an application a FlaskFactory accomplishes next steps

Initialize Flask application

By default it creates a consensys_utils.flask.Flask application
Set application configuration by using a .yml configuration loader

You can refer to consensys_utils.flask.config.set_app_config() for more information
Apply WSGI middlewares on the application

You can refer to consensys_utils.flask.wsgi.apply_middlewares() for more information
Initialize extensions on the application

You can refer to consensys_utils.flask.extensions.initialize_extensions() for more information
Set hooks on the application

You can refer to consensys_utils.flask.hooks.set_hooks() for more information
Register blueprints on the application

You can refer to consensys_utils.flask.blueprints.register_blueprints() for more information

It is possible to override default behavior by creating a new class that inherits from FlaskFactory

Example: Adding default hooks

>>> def set_foo_request_id_hook(app):
...     @app.before_request
...     def set_request_id():
...         request.id = 'foo'

>>> class CustomFlaskFactory(BaseFlaskFactory):
...     default_hook_setters = [set_foo_request_id_hook]


>>> app_factory = CustomFlaskFactory(__name__)

Parameters:

import_name (str) – The name of the application package
yaml_config_loader (cfg_loader.loader.YamlConfigLoader) – Optional config loader
middlewares (list) – Middlewares to apply on the application (c.f consensys_utils.flask.wsgi.apply_middlewares())
extensions (list) – Extensions to initiate on the application (c.f. consensys_utils.flask.extensions.initialize_extensions())
hook_setters (list) – Hooks to set on the application (c.f. consensys_utils.flask.hooks.set_hooks())
blueprints (list) – Blueprints to register on the application (c.f. consensys_utils.flask.blueprints.register_blueprints())

apply_middlewares()[source]¶: Apply middlewares on application

create_app(config_path=None, config=None, **kwargs)[source]¶

Create an application

Parameters:	config_path (str) – .yml configuration path config (dict) – Optional application config kwargs – Keyword arguments to provide to `flask_class` when instantiating the application object

flask_class¶: alias of Flask

init(**kwargs)[source]¶

Instantiate Flask application

Parameters:	kwargs (dict) – Keyword arguments to provide to the Flask application

initialize_extensions()[source]¶: Initialize extensions on application

load_config(config_path=None)[source]¶

Load configuration

Parameters:	config_path (str) – Configuration path

register_blueprints()[source]¶: Register blueprints on application

set_config(config=None)[source]¶

Set application config

Parameters:	raw_config (dict) – Optional application config

set_hooks()[source]¶: Set hooks on application

class consensys_utils.flask.Flask(import_name, static_url_path=None, static_folder='static', static_host=None, host_matching=False, subdomain_matching=False, template_folder='templates', instance_path=None, instance_relative_config=False, root_path=None)[source]¶

ConsenSys-Utils Flask class

It applies a light overriding on top of :class`flask.Flask` to enable

usage of a logger that can be configured from .yml file

WSGI¶

ConsenSys-Utils implements functions to facilitate Flask app decoration with WSGI middlewares

consensys_utils.flask.wsgi.apply_middlewares(app, middlewares=None)[source]¶

Apply WSGI middlewares to a Flasks application

Example:

>>> app = Flask(__name__)

>>> class AuthMiddleware:
...     def __init__(self, wsgi):
...         self.wsgi = wsgi
...
...     @staticmethod
...     def is_authenticated(header):
...         if not header:
...             return False
...         _, encoded = header.split(None, 1)
...         decoded = base64.b64decode(encoded).decode('UTF-8')
...         username, password = decoded.split(':', 1)
...         return username == password
...
...     def __call__(self, environ, start_response):
...         if self.is_authenticated(environ.get('HTTP_AUTHORIZATION')):
...             return self.wsgi(environ, start_response)
...         start_response('401 Authentication Required',
...             [('Content-Type', 'text/html'),
...              ('WWW-Authenticate', 'Basic realm="Login"')])
...         return [b'Login']

>>> middlewares = [AuthMiddleware]

>>> apply_middlewares(app, middlewares)

Parameters:	app (`flask.Flask`) – Flask application middlewares (list) – WSGI middleware to apply on the application. Expects a list of elements which are either A class taking a wsgi as an argument A function that takes a `flask.Flask` as argument and even eventually apply a middleware on it

consensys_utils.flask.wsgi.apply_request_id_middleware(app)[source]¶

Apply a consensys_utils.wsgi.RequestIDMiddleware() on a Flask application

Parameters:	app (`flask.Flask`) – Flask application

Extensions¶

ConsenSys-Utils implements functions to facilitate initialization of Flask extensions on an application

consensys_utils.flask.extensions.initialize_extensions(app, extensions=None)[source]¶

Initialize extensions on a Flask application

Example: Adding an extension

>>> app = Flask(__name__)

>>> swag = Swagger(template={'version': '0.3.4-dev'})

>>> my_extensions = [swag]

>>> initialize_extensions(app, my_extensions)

Parameters:	app (`flask.Flask`) – Flask application extensions (list) – Extensions to initialize on the application. Expects a list of elements which are either a Flask extension object (having a callable attribute `init_app`) a function that takes a `flask.Flask` as argument and eventually initialize an extension on it

consensys_utils.flask.extensions.initialize_health_extension(app)[source]¶

Initialize healthcheck extension

If health is missing in application configuration then this function has no effect

Parameters:	app (`flask.Flask`) – Flask application

consensys_utils.flask.extensions.initialize_web3_extension(app)[source]¶

Initialize Web3 extension

If web3 is missing in application configuration then this function has no effect

Parameters:	app (`flask.Flask`) – Flask application

ConsenSys-Utils defines a bench of Flask extensions that can be smoothly re-used.

Healthcheck¶

class consensys_utils.flask.extensions.health.HealthCheck(app=None, path=None, success_status=200, success_headers=None, success_handler=<function json_success_handler>, success_ttl=27, failed_status=500, failed_headers=None, failed_handler=<function json_failed_handler>, failed_ttl=9, exception_handler=<function basic_exception_handler>, checkers=None, log_on_failure=True, **options)[source]¶

Healthcheck extension that declares an health check route

Healthcheck URL can be set at application initialization by reading app configuration

Swagger¶

class consensys_utils.flask.extensions.swagger.Swagger(*args, template=None, openapi='3.0', version='0.1.0-dev', title='Base App', tags=None, **kwargs)[source]¶: Flask extension that allow integration with Swagger

Web3¶

class consensys_utils.flask.extensions.web3.FlaskWeb3(*args, app=None, create_provider=<function create_provider>, **kwargs)[source]¶

A Flask-Web3 class that supports initializing application with configuration in format consensys_utils.config.schema.flask.ConfigSchema()

You can customize this class the same you would do with flask_web3.FlaskWeb3

init_app(app)[source]¶

Initialize application

Parameters:	app (flask.Flask) – Flask application or blueprint object to extend

Config¶

consensys_utils.flask.config.set_app_config(app, config=None)[source]¶

Set application configuration

Parameters:	app (`flask.Flask`) – Flask application config (dict) – Optional Application configuration

Hooks¶

ConsenSys-Utils implements functions to facilitate setting Flask hooks on an application

consensys_utils.flask.hooks.set_hooks(app, hook_setters=None)[source]¶

Set hooks on a Flask application

Example: Adding a hook

>>> app = Flask(__name__)

>>> def set_log_request_hook(app):
...     @app.before_request
...     def log_request():
...         current_app.logger.debug(request)

>>> my_hook_setters = [set_log_request_hook]

>>> set_hooks(app, my_hook_setters)

Parameters:	app (`flask.Flask`) – Flask application hook_setters (list) – Hooks to set on the application. Expects a list of functions that takes a `flask.Flask` as argument

consensys_utils.flask.hooks.set_request_id_hook(app)[source]¶

Set a hook to inject request ID

It basis on application config to get the request header from which to retrieve request ID

Parameters:	app (`flask.Flask`) – Flask application

Blueprints¶

ConsenSys-Utils implements functions to facilitate registering blueprints on an application

consensys_utils.flask.blueprints.register_blueprints(app, blueprints=None)[source]¶

Register blueprints on a Flask application

Example:

>>> app = Flask(__name__)

>>> my_bp1 = Blueprint('my-bp1', __name__)
>>> my_bp2 = Blueprint('my-bp2', __name__)

>>> blueprints = [
...     lambda app: app.register_blueprint(my_bp1),
...     my_bp2,
... ]
>>> register_blueprints(app, blueprints)

Parameters:	app (`flask.Flask`) – Flask application blueprints (list) – Blueprints to register on the application. Expects a list of elements which elements are either a `flask.Blueprint` a function that takes a `flask.Flask` as argument and eventually register a blueprint on it

Logging¶

ConsenSys-Utils implements resources to facilitate logging blueprints on an application

class consensys_utils.flask.logging.RequestIDFilter(name='')[source]¶

Logging filter that allows to enrich log with Flask request ID

filter(record)[source]¶: Enrich log record with request ID

consensys_utils.flask.logging.create_logger(app, logger='app')[source]¶

Create logger for Flask app

Parameters:	config (dict) – Logging configuration logger (str) – Name of the logger