Application factory pattern deep dive in Flask - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to define the Flask application factory function.

Flask

from flask import Flask

def create_app():
    app = Flask(__name__)
    return [1]

Drag options to blanks, or click blank then click option'

Acreate_app

BFlask

CNone

Dapp

Attempts:

3 left

💡 Hint

Common Mistakes

Returning the Flask class instead of the app instance.

Not returning anything from the function.

The application factory function must return the Flask app instance it creates. Here, app is the Flask app object.

2fill in blank

medium

Complete the code to register a blueprint inside the application factory.

Flask

from flask import Flask, Blueprint

bp = Blueprint('main', __name__)

def create_app():
    app = Flask(__name__)
    app.[1](bp)
    return app

Drag options to blanks, or click blank then click option'

Aadd_blueprint

Bregister_blueprint

Cinclude_blueprint

Dattach_blueprint

Attempts:

3 left

💡 Hint

Common Mistakes

Using non-existent methods like add_blueprint.

Forgetting to register the blueprint.

Flask apps use register_blueprint() to add blueprints for modular routes.

3fill in blank

hard

Fix the error in the application factory by completing the missing configuration line.

Flask

def create_app():
    app = Flask(__name__)
    app.config['SECRET_KEY'] = [1]
    return app

Drag options to blanks, or click blank then click option'

A'mysecretkey'

BNone

C12345

DSECRET_KEY

Attempts:

3 left

💡 Hint

Common Mistakes

Setting SECRET_KEY to None or a variable name instead of a string.

Using an integer without quotes.

The SECRET_KEY must be a string used for security purposes. Here, a simple string is used.

4fill in blank

hard

Fill both blanks to create a dictionary comprehension that maps blueprint names to their URLs inside the factory.

Flask

def create_app():
    app = Flask(__name__)
    blueprints = {'main': '/main', 'admin': '/admin'}
    urls = [1]: [2] for [1] in blueprints
    return app

Drag options to blanks, or click blank then click option'

Aname

Burl

Cblueprints[name]

Dblueprints

Attempts:

3 left

💡 Hint

Common Mistakes

Using the dictionary name as the key or value directly.

Mixing up keys and values in the comprehension.

The comprehension iterates over blueprint names and maps each name to its URL from the dictionary.

5fill in blank

hard

Fill all three blanks to complete the factory pattern that initializes extensions and registers blueprints.

Flask

from flask_sqlalchemy import SQLAlchemy

db = SQLAlchemy()

def create_app():
    app = Flask(__name__)
    app.config['SQLALCHEMY_DATABASE_URI'] = [1]
    db.[2](app)
    from .main import bp as main_bp
    app.[3](main_bp)
    return app

Drag options to blanks, or click blank then click option'

A'sqlite:///app.db'

Binit_app

Cregister_blueprint

D'postgresql://user@localhost/db'

Attempts:

3 left

💡 Hint

Common Mistakes

Using the wrong method to initialize the extension.

Forgetting to register the blueprint.

Setting the database URI incorrectly.

The database URI is set to a SQLite file. The extension is initialized with init_app. The blueprint is registered with register_blueprint.

Practice

1. What is the main purpose of using the application factory pattern in Flask?

easy

A. To create the Flask app inside a function for flexible configuration

B. To write all routes in a single file

C. To avoid using blueprints in the app

D. To disable debugging mode by default

Solution

1. Step 1: Understand the pattern purpose

   The application factory pattern creates the Flask app inside a function instead of at the global level.

2. Step 2: Identify benefits

   This allows flexible configuration and easier testing by creating multiple app instances with different settings.

3. Final Answer:

   To create the Flask app inside a function for flexible configuration -> Option A

4. Quick Check:

   Application factory = flexible app creation [OK]

Hint: Remember: factory means function creates app [OK]

Common Mistakes:

• Thinking it restricts routes to one file
• Believing it disables debugging automatically
• Confusing it with blueprint usage

2. Which of the following is the correct way to define an application factory function in Flask?

easy

A. app = Flask(__name__)\ndef create_app():\n return app

B. def create_app():\n return Flask

C. def create_app():\n app = Flask(__name__)\n return app

D. def create_app():\n app = Flask\n return app

Solution

1. Step 1: Check function definition

   The factory function must create a Flask instance inside it and return that instance.

2. Step 2: Validate syntax

   def create_app():\n app = Flask(__name__)\n return app correctly creates app = Flask(__name__) and returns it.

3. Final Answer:

   def create_app():\n app = Flask(__name__)\n return app -> Option C

4. Quick Check:

   Factory returns new Flask instance [OK]

Hint: Factory must create and return app inside function [OK]

Common Mistakes:

• Defining app globally outside function
• Returning Flask class instead of instance
• Missing parentheses when creating Flask instance

3. Given this factory function, what will print(app.config['DEBUG']) output?

def create_app():
    app = Flask(__name__)
    app.config.from_mapping(DEBUG=True)
    return app

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

medium

A. None

B. True

C. False

D. KeyError

Solution

1. Step 1: Analyze config setting

   The factory sets DEBUG=True using app.config.from_mapping().

2. Step 2: Check printed value

   After creating the app, printing app.config['DEBUG'] outputs the value set, which is True.

3. Final Answer:

   True -> Option B

4. Quick Check:

   Config DEBUG set True = True [OK]

Hint: Config values set in factory are accessible after app creation [OK]

Common Mistakes:

• Assuming default DEBUG is False
• Expecting KeyError if not set globally
• Confusing config keys with environment variables

4. Identify the error in this application factory code:

def create_app():
    app = Flask(__name__)
    @app.route('/')
    def home():
        return 'Hello'
    return app

app = create_app()
app.run()

medium

A. Missing parentheses in Flask constructor

B. Function home() missing return statement

C. Route decorator used incorrectly

D. Calling app.run() outside the main guard

Solution

1. Step 1: Review app.run() usage

   Calling app.run() directly without if __name__ == '__main__' can cause issues when importing.

2. Step 2: Check other code parts

   Flask constructor and route decorator are correct; home() returns a string properly.

3. Final Answer:

   Calling app.run() outside the main guard -> Option D

4. Quick Check:

   Run inside main guard to avoid import issues [OK]

Hint: Always run app inside if __name__ == '__main__' [OK]

Common Mistakes:

• Ignoring main guard for app.run()
• Thinking route decorator syntax is wrong
• Assuming missing return in home()

5. You want to create a Flask app using the application factory pattern that supports multiple configurations (development and production). Which approach correctly applies this pattern?

hard

A. def create_app(config_name):
app = Flask(__name__)
if config_name == 'dev':
app.config.from_object('config.DevConfig')
else:
app.config.from_object('config.ProdConfig')
return app

B. app = Flask(__name__)
if config_name == 'dev':
app.config.from_object('config.DevConfig')
else:
app.config.from_object('config.ProdConfig')

C. def create_app():
app = Flask(__name__)
app.config = {}
return app

D. def create_app(config_name):
app = Flask(__name__)
app.config = config_name
return app

Solution

1. Step 1: Understand configuration loading in factory

   The factory should accept a parameter to select configuration and load it properly using app.config.from_object().

2. Step 2: Evaluate options

   def create_app(config_name): app = Flask(__name__) if config_name == 'dev': app.config.from_object('config.DevConfig') else: app.config.from_object('config.ProdConfig') return app correctly uses a parameter and loads config classes conditionally inside the factory function.

3. Step 3: Identify incorrect options

   app = Flask(__name__) if config_name == 'dev': app.config.from_object('config.DevConfig') else: app.config.from_object('config.ProdConfig') defines app globally, breaking factory pattern. Options C and D do not load config properly.

4. Final Answer:

   def create_app(config_name): app = Flask(__name__) if config_name == 'dev': app.config.from_object('config.DevConfig') else: app.config.from_object('config.ProdConfig') return app -> Option A

5. Quick Check:

   Factory with config param loads correct settings [OK]

Hint: Pass config name to factory and load config inside [OK]

Common Mistakes:

• Creating app globally instead of inside factory
• Assigning config directly instead of loading
• Not using parameter to select config