Application Setup

A Flask application is an instance of the Flask class.Everything about the application, such as configuration and URLs, willbe registered with this class.

The most straightforward way to create a Flask application is to createa global Flask instance directly at the top of your code, likehow the “Hello, World!” example did on the previous page. While this issimple and useful in some cases, it can cause some tricky issues as theproject grows.

Instead of creating a Flask instance globally, you will createit inside a function. This function is known as the applicationfactory. Any configuration, registration, and other setup theapplication needs will happen inside the function, then the applicationwill be returned.

The Application Factory

It’s time to start coding! Create the flaskr directory and add theinit.py file. The init.py serves double duty: it willcontain the application factory, and it tells Python that the flaskrdirectory should be treated as a package.

  1. $ mkdir flaskr

flaskr/init.py

  1. import os
  2.  
  3. from flask import Flask
  4.  
  5.  
  6. def create_app(test_config=None):
  7.     # create and configure the app
  8.     app = Flask(__name__, instance_relative_config=True)
  9.     app.config.from_mapping(
  10.         SECRET_KEY='dev',
  11.         DATABASE=os.path.join(app.instance_path, 'flaskr.sqlite'),
  12.     )
  13.  
  14.     if test_config is None:
  15.         # load the instance config, if it exists, when not testing
  16.         app.config.from_pyfile('config.py', silent=True)
  17.     else:
  18.         # load the test config if passed in
  19.         app.config.from_mapping(test_config)
  20.  
  21.     # ensure the instance folder exists
  22.     try:
  23.         os.makedirs(app.instance_path)
  24.     except OSError:
  25.         pass
  26.  
  27.     # a simple page that says hello
  28.     @app.route('/hello')
  29.     def hello():
  30.         return 'Hello, World!'
  31.  
  32.     return app

create_app is the application factory function. You’ll add to itlater in the tutorial, but it already does a lot.

  • app = Flask(name, instance_relative_config=True) creates theFlask instance.

    • name is the name of the current Python module. The appneeds to know where it’s located to set up some paths, andname is a convenient way to tell it that.

    • instance_relative_config=True tells the app thatconfiguration files are relative to theinstance folder. The instance folderis located outside the flaskr package and can hold localdata that shouldn’t be committed to version control, such asconfiguration secrets and the database file.

  • app.config.from_mapping() setssome default configuration that the app will use:

    • SECRET_KEY is used by Flask and extensions to keep datasafe. It’s set to 'dev' to provide a convenient valueduring development, but it should be overridden with a randomvalue when deploying.

    • DATABASE is the path where the SQLite database file will besaved. It’s underapp.instance_path, which is thepath that Flask has chosen for the instance folder. You’ll learnmore about the database in the next section.

  • app.config.from_pyfile() overridesthe default configuration with values taken from the config.pyfile in the instance folder if it exists. For example, whendeploying, this can be used to set a real SECRET_KEY.

    • test_config can also be passed to the factory, and will beused instead of the instance configuration. This is so the testsyou’ll write later in the tutorial can be configuredindependently of any development values you have configured.

  • os.makedirs() ensures thatapp.instance_path exists. Flaskdoesn’t create the instance folder automatically, but it needs to becreated because your project will create the SQLite database filethere.

  • @app.route() creates a simple route so you cansee the application working before getting into the rest of thetutorial. It creates a connection between the URL /hello and afunction that returns a response, the string 'Hello, World!' inthis case.

Run The Application

Now you can run your application using the flask command. From theterminal, tell Flask where to find your application, then run it indevelopment mode. Remember, you should still be in the top-levelflask-tutorial directory, not the flaskr package.

Development mode shows an interactive debugger whenever a page raises anexception, and restarts the server whenever you make changes to thecode. You can leave it running and just reload the browser page as youfollow the tutorial.

For Linux and Mac:

  1. $ export FLASK_APP=flaskr
  2. $ export FLASK_ENV=development
  3. $ flask run

For Windows cmd, use set instead of export:

  1. > set FLASK_APP=flaskr
  2. > set FLASK_ENV=development
  3. > flask run

For Windows PowerShell, use $env: instead of export:

  1. > $env:FLASK_APP = "flaskr"
  2. > $env:FLASK_ENV = "development"
  3. > flask run

You’ll see output similar to this:

  1. * Serving Flask app "flaskr"
  2. * Environment: development
  3. * Debug mode: on
  4. * Running on http://127.0.0.1:5000/ (Press CTRL+C to quit)
  5. * Restarting with stat
  6. * Debugger is active!
  7. * Debugger PIN: 855-212-761

Visit http://127.0.0.1:5000/hello in a browser and you should see the“Hello, World!” message. Congratulations, you’re now running your Flaskweb application!

Continue to Define and Access the Database.