Application factory pattern deep dive in Flask - Mini Project: Build & Apply

Application factory pattern deep dive

📖 Scenario: You are building a Flask web application that needs to be scalable and testable. To achieve this, you will use the application factory pattern. This pattern helps you create multiple instances of the app with different configurations, which is useful for development, testing, and production environments.

🎯 Goal: Build a Flask application using the application factory pattern. You will create the app inside a function, configure it, register a simple route, and finally run the app.

📋 What You'll Learn

Create a function called create_app that returns a Flask app instance

Inside create_app, initialize the Flask app with __name__

Add a configuration variable DEBUG set to True

Register a route / that returns the text "Hello, Factory!"

Return the app instance from the create_app function

💡 Why This Matters

🌍 Real World

The application factory pattern is used in real Flask projects to create multiple app instances with different settings, which helps in testing and deploying.

💼 Career

Understanding this pattern is important for backend developers working with Flask, as it is a common best practice in professional Flask applications.

1

Create the application factory function

Write a function called create_app that creates a Flask app instance using Flask(__name__) and returns it.

Flask

from flask import Flask

# Define the create_app function
# Your code here

Hint

Remember to import Flask and define a function that returns the app instance.

2

Add configuration to the app

Inside the create_app function, set the app configuration variable DEBUG to True using app.config['DEBUG'] = True.

Flask

from flask import Flask

def create_app():
    app = Flask(__name__)
    # Set DEBUG configuration to True
    # Your code here
    return app

Hint

Use app.config['DEBUG'] = True to enable debug mode.

3

Register a simple route

Inside the create_app function, add a route / using @app.route('/') that returns the string 'Hello, Factory!'.

Flask

from flask import Flask

def create_app():
    app = Flask(__name__)
    app.config['DEBUG'] = True
    # Add a route '/' that returns 'Hello, Factory!'
    # Your code here
    return app

Hint

Use the @app.route decorator to define a route inside the factory function.

4

Run the app using the factory

Outside the create_app function, create an app instance by calling create_app() and run it with app.run().

Flask

from flask import Flask

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

    @app.route('/')
    def home():
        return 'Hello, Factory!'

    return app

# Create app instance and run it
# Your code here

Hint

Call create_app() to get the app instance and then run it.

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