Handling basic configurations

One of the beauties of Flask is that it is very easy to configure a Flask application according to the needs of the project. In this recipe, we will try to understand the different ways in which a Flask application can be configured, including how to load a configuration from environment variables, Python files, or even a config object.

Getting ready

In Flask, configuration variables are stored on a dictionary-like attribute named config of the Flask object. The config attribute is a subclass of the Python dictionary, and we can modify it just like any dictionary.

How to do it...

To run our application in debug mode, for instance, we can write the following:

app = Flask(__name__)
app.config['DEBUG'] = True

Tip

The debug Boolean can also be set at the Flask object level rather than at the config level, as follows:

app.debug = True

Alternatively, we can pass debug as a named argument to app.run, as follows:

app.run(debug=True)

In new versions of Flask, the debug mode can also be set on an environment variable, FLASK_DEBUG=1. Then, we can run the app using flask run or Python’s -m switch:

$ export FLASK_DEBUG=1

Enabling debug mode will make the server reload itself in the event of any code changes, and it also provides the very helpful Werkzeug debugger when something goes wrong.

There are a bunch of configuration values provided by Flask. We will come across them in relevant recipes throughout this chapter.

As an application becomes larger, there is a need to manage the application’s configuration in a separate file, as shown in the following example. In most operating systems and development environments that you use, it is unlikely that this file will be a part of the version control system. Thus, Flask provides us with multiple ways to fetch configurations. The most frequently used methods are as follows:

• From a Python configuration file (*.cfg), where the configuration can be fetched using the following statement:

  app.config.from_pyfile('myconfig.cfg')

• From an object, where the configuration can be fetched using the following statement:

  app.config.from_object('myapplication.default_settings')

• Alternatively, to load from the same file from which this command is run, we can use the following statement:

  app.config.from_object(__name__)

• From an environment variable, the configuration can be fetched using the following statement:

  app.config.from_envvar('PATH_TO_CONFIG_FILE')

• New in Flask version 2.0 is a capability to load from generic configuration file formats such as JSON or TOML:

  app.config.from_file('config.json', load=json.load)

Alternatively, we can do the following:
app.config.from_file('config.toml', load=toml.load)

How it works...

Flask is designed to only pick up configuration variables that are written in uppercase. This allows us to define any local variables in our configuration files and objects and leave the rest to Flask.

The best practice when using configurations is to have a bunch of default settings in app.py, or via any object in the application itself, and then override the same by loading it from the configuration file. So, the code will look as follows:

app = Flask(__name__)
DEBUG = True
TESTING = True
app.config.from_object(__name__)
app.config.from_pyfile('/path/to/config/file')