Application factory pattern preview in Flask - Step-by-Step Execution

Concept Flow - Application factory pattern preview

Define create_app() function

↓

Inside create_app: Create Flask app instance

↓

Configure app settings

↓

Register blueprints and extensions

↓

Return app instance

↓

Call create_app() to get app

↓

Run app

This flow shows how the application factory function creates and configures the Flask app, then returns it for running.

Execution Sample

Flask

from flask import Flask

def create_app():
    app = Flask(__name__)
    app.config['DEBUG'] = True
    @app.route('/')
    def home():
        return 'Hello, Flask!'
    return app

Defines a function that creates and configures a Flask app, then returns it.

Execution Table

Step	Action	Evaluation	Result
1	Call create_app()	Function starts	Enter create_app function
2	Create Flask app instance	app = Flask(__name__)	app object created
3	Set config DEBUG=True	app.config['DEBUG'] = True	app config updated
4	Define route '/'	@app.route('/')	Route registered
5	Define home() function	def home(): return 'Hello, Flask!'	Route handler ready
6	Return app	return app	app instance returned
7	Assign app = create_app()	app = create_app()	app variable holds Flask app
8	Run app	app.run()	Flask server starts
9	Exit	App running, waiting for requests	Execution stops here until interrupted

💡 Execution stops after app.run() starts the server and waits for requests.

Variable Tracker

Variable	Start	After Step 2	After Step 3	After Step 6	After Step 7
app	undefined	Flask app instance	Config DEBUG=True set	Returned from create_app	Assigned to app variable

Key Moments - 2 Insights

Why do we define the app inside a function instead of globally?

Defining app inside create_app delays creation until called, allowing flexible configuration and testing. See execution_table steps 1-6.

What happens if we call app.run() outside create_app?

app.run() starts the server and blocks further code. It is called after create_app returns the app, as shown in steps 7-8.

Visual Quiz - 3 Questions

Look at the execution_table, what is the state of 'app' after step 3?

A Undefined

B Flask app instance with DEBUG=True in config

C Function create_app itself

D Route '/' registered

💡 Hint

Check variable_tracker column 'After Step 3' and execution_table step 3

At which step is the route '/' registered?

A Step 2

B Step 6

C Step 4

D Step 8

💡 Hint

Look at execution_table step descriptions for route registration

If we did not return 'app' from create_app, what would happen at step 7?

A app variable would be None or undefined

B app would be a Flask instance anyway

C app.run() would start normally

D The server would start twice

💡 Hint

Refer to execution_table step 6 and 7 about returning and assigning app

Concept Snapshot

Application Factory Pattern in Flask:
- Define a function create_app() that creates and configures the app.
- Inside, create Flask instance, set config, register routes.
- Return the app instance.
- Call create_app() to get the app and run it.
- Enables flexible app setup and testing.

Full Transcript

The Application Factory Pattern in Flask means we write a function called create_app that builds and configures the Flask app. When we call this function, it creates the app instance, sets configuration like DEBUG mode, registers routes such as '/' with their handlers, and then returns the app. After that, we assign the returned app to a variable and run it. This pattern helps us create the app only when needed, making it easier to configure differently for testing or production. The execution steps show calling create_app, creating the app, setting config, registering routes, returning the app, assigning it, and running the server. Variables like 'app' change from undefined to a Flask instance with config set. Key points include why the app is created inside a function and when the server starts running.