Extension initialization pattern in Flask - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What is the output of this Flask extension initialization code?

Consider this Flask app using the extension initialization pattern. What will be printed when the app runs?

Flask

from flask import Flask
from flask_sqlalchemy import SQLAlchemy

db = SQLAlchemy()

def create_app():
    app = Flask(__name__)
    app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///:memory:'
    db.init_app(app)

    @app.route('/')
    def index():
        return 'Hello, Flask!'

    with app.app_context():
        print(type(db.engine))

    return app

app = create_app()

A <class 'flask_sqlalchemy.SQLAlchemy'>

B <class 'sqlalchemy.engine.base.Engine'>

C None

D AttributeError: 'SQLAlchemy' object has no attribute 'engine'

💡 Hint

Think about when the database engine is created in the extension initialization pattern.

The db.init_app(app) call binds the SQLAlchemy extension to the Flask app. Inside the app context, db.engine is available and is an instance of SQLAlchemy's engine class.

❓ state_output

intermediate

What is the value of app.config['DEBUG'] after initialization?

Given this Flask app using the extension initialization pattern, what is the value of app.config['DEBUG'] after create_app() is called?

Flask

from flask import Flask
from flask_mail import Mail

mail = Mail()

def create_app():
    app = Flask(__name__)
    app.config['DEBUG'] = True
    mail.init_app(app)
    return app

app = create_app()
value = app.config['DEBUG']

A None

B False

C True

D KeyError

💡 Hint

Extension initialization does not change existing config values.

The DEBUG config is set before calling mail.init_app(app). The extension does not modify this config, so it remains True.

📝 Syntax

advanced

Which option correctly initializes a Flask extension with the factory pattern?

Choose the correct way to initialize a Flask extension using the extension initialization pattern (factory pattern).

A

db = SQLAlchemy()

app = Flask(__name__)
db.init_app(app)

B

db = SQLAlchemy(app)

app = Flask(__name__)

# extension initialized inline

C

app = Flask(__name__)
db = SQLAlchemy(app)

# extension initialized after app creation

D

app = Flask(__name__)
db = SQLAlchemy()

# extension initialized without init_app

💡 Hint

Extension initialization pattern separates extension creation and app binding.

Option A correctly creates the extension instance first, then binds it to the app using init_app. This supports the factory pattern.

🔧 Debug

advanced

Why does this Flask app raise an error when accessing db.session?

Given this code, why does accessing db.session raise an error?

Flask

from flask import Flask
from flask_sqlalchemy import SQLAlchemy

db = SQLAlchemy()

app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///:memory:'

@app.route('/')
def index():
    return str(db.session)

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

A Flask app context is missing when accessing db.session

B SQLALCHEMY_DATABASE_URI is invalid, causing session error

C db.session requires manual creation before use

D db.init_app(app) was not called, so db.session is uninitialized

💡 Hint

Check if the extension was properly linked to the app.

The extension instance db was created but never initialized with app via init_app. Without this, db.session is not set up and accessing it raises an error.

🧠 Conceptual

expert

What is the main advantage of the Flask extension initialization pattern?

Why do Flask developers use the extension initialization pattern (creating extension instances outside the app and calling init_app later)?

A It allows creating multiple Flask apps sharing the same extension instance without re-instantiating it

B It improves runtime performance by caching extension objects globally

C It automatically configures extensions without needing app context

D It prevents extensions from being used outside the Flask app

💡 Hint

Think about app factories and multiple app instances.

The pattern allows creating extension instances once and initializing them with different Flask app instances later. This supports app factories and multiple apps sharing extensions.