Celery integration overview in Flask - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What happens when a Celery task is called with .delay() in Flask?

Consider a Flask app using Celery for background tasks. When you call a task with .delay(), what is the immediate behavior?

Flask

from celery import Celery

celery_app = Celery('tasks', broker='redis://localhost:6379/0')

@celery_app.task
def add(x, y):
    return x + y

result = add.delay(4, 6)

A The task is sent to the Celery worker queue and returns an AsyncResult immediately without blocking.

B The task raises an error because .delay() is not a valid method for Celery tasks.

C The task runs in a new thread inside the Flask app and blocks until completion.

D The task runs immediately in the current Flask process and returns the result synchronously.

💡 Hint

Think about how Celery handles tasks asynchronously.

Calling .delay() sends the task to the Celery worker queue and returns immediately with an AsyncResult object. The task runs asynchronously in a separate worker process, not blocking the Flask app.

📝 Syntax

intermediate

Which Celery configuration option sets the message broker URL in Flask?

In a Flask app integrating Celery, you need to configure the broker URL. Which option correctly sets the broker URL?

A celery_app.conf.broker_url = 'redis://localhost:6379/0'

B celery_app.config['BROKER'] = 'redis://localhost:6379/0'

C celery_app.broker = 'redis://localhost:6379/0'

D celery_app.set_broker('redis://localhost:6379/0')

💡 Hint

Look for the official Celery configuration attribute for the broker URL.

The correct way to set the broker URL in Celery is by assigning the URL string to celery_app.conf.broker_url. Other options are invalid or do not exist.

❓ state_output

advanced

What is the value of result.ready() immediately after calling a Celery task with .delay()?

Given the code below, what does result.ready() return immediately after add.delay(2, 3) is called?

Flask

from celery import Celery

celery_app = Celery('tasks', broker='redis://localhost:6379/0')

@celery_app.task
def add(x, y):
    return x + y

result = add.delay(2, 3)
ready_state = result.ready()

A None, because the task result is not available until .get() is called.

B True, because the task completes instantly in the same process.

C Raises an AttributeError because .ready() is not a valid method.

D False, because the task is queued and not completed immediately.

💡 Hint

Think about asynchronous task execution and when results become ready.

The result.ready() method returns False immediately after .delay() because the task is still queued or running asynchronously. It only returns True once the task finishes.

🔧 Debug

advanced

Why does this Flask app with Celery fail to execute tasks?

Examine the code below. Why will the Celery tasks never run?

Flask

from flask import Flask
from celery import Celery

app = Flask(__name__)
celery = Celery(app.name, broker='redis://localhost:6379/0')

@celery.task
def multiply(x, y):
    return x * y

@app.route('/start')
def start_task():
    multiply.delay(5, 6)
    return 'Task started'

A The Flask app must call celery.start() to run tasks, which is missing.

B The Celery worker process is not running, so tasks are never executed.

C The broker URL is incorrect and causes connection failure.

D The task function multiply is not decorated properly with @app.task.

💡 Hint

Think about what runs Celery tasks in the background.

Celery tasks require a separate worker process running to consume and execute tasks from the broker queue. Without starting the Celery worker, tasks remain queued and never run.

🧠 Conceptual

expert

How does Celery ensure task results are accessible after asynchronous execution in Flask?

In a Flask app using Celery, how are task results stored and retrieved after the task completes?

A Results are returned directly to the Flask route that called the task without any backend storage.

B Task results are stored in Flask's session object automatically after task completion.

C Celery stores results in a backend like Redis or a database configured as the result backend, accessible via AsyncResult.

D Celery writes results to local files on the worker machine, which Flask reads later.

💡 Hint

Consider how asynchronous systems keep track of results separately from the main app.

Celery uses a result backend like Redis, a database, or other supported stores to save task results. The Flask app can retrieve results asynchronously using the AsyncResult object linked to the task ID.

Practice

1. What is the main purpose of integrating Celery with a Flask application?

easy

A. To run tasks in the background without blocking the main app

B. To create HTML templates for the Flask app

C. To handle user authentication and sessions

D. To serve static files like images and CSS

Solution

1. Step 1: Understand Celery's role

   Celery is designed to run tasks asynchronously, meaning it handles work in the background.

2. Step 2: Connect to Flask app purpose

   Flask apps use Celery to keep the app responsive by offloading long tasks.

3. Final Answer:

   To run tasks in the background without blocking the main app -> Option A

4. Quick Check:

   Celery = background tasks [OK]

Hint: Celery = background task runner in Flask apps [OK]

Common Mistakes:

• Thinking Celery manages templates
• Confusing Celery with user login features
• Assuming Celery serves static files

2. Which of the following is the correct way to define a Celery task in a Flask app?

easy

A. @celery_app.task\ndef add(x, y): return x + y

B. celery_app.run_task(add)

C. @app.route('/task')\ndef task(): pass

D. def task(): pass

Solution

1. Step 1: Identify Celery task decorator

   Celery tasks are defined using the @celery_app.task decorator.

2. Step 2: Check syntax correctness

   @celery_app.task\ndef add(x, y): return x + y correctly decorates a function to become a Celery task.

3. Final Answer:

   @celery_app.task\ndef add(x, y): return x + y -> Option A

4. Quick Check:

   Celery task = @celery_app.task decorator [OK]

Hint: Use @celery_app.task to define tasks [OK]

Common Mistakes:

• Forgetting the @celery_app.task decorator
• Using Flask route decorators for tasks
• Calling celery_app.run_task which is invalid

3. Given this code snippet in a Flask app with Celery:

@celery_app.task
def multiply(x, y):
    return x * y

result = multiply.delay(3, 4)
print(result.get())

What will be printed?

medium

A. A task object reference

B. null

C. 12

D. An error because delay() is not valid

Solution

1. Step 1: Understand delay() usage

   Calling multiply.delay(3, 4) sends the task to Celery to run asynchronously.

2. Step 2: Using get() to wait for result

   result.get() waits for the task to finish and returns the output, which is 3 * 4 = 12.

3. Final Answer:

   12 -> Option C

4. Quick Check:

   delay() runs task, get() returns result [OK]

Hint: delay() runs task, get() fetches result [OK]

Common Mistakes:

• Thinking delay() returns the result immediately
• Confusing task object with result value
• Assuming delay() is invalid in Celery

4. You wrote this Celery task in your Flask app:

@celery_app.task
def add(x, y):
return x + y

But when you call add.delay(2, 3), it raises an IndentationError. What is the problem?

medium

A. delay() cannot be called on tasks

B. The function body is not indented properly

C. You forgot to import Celery

D. The decorator syntax is incorrect

Solution

1. Step 1: Check function indentation

   Python requires the function body to be indented under the def line.

2. Step 2: Identify error cause

   Here, return x + y is not indented, causing IndentationError.

3. Final Answer:

   The function body is not indented properly -> Option B

4. Quick Check:

   Python needs indented function bodies [OK]

Hint: Indent function body under def line [OK]

Common Mistakes:

• Ignoring Python indentation rules
• Assuming delay() is invalid
• Thinking decorator syntax is wrong

5. You want to integrate Celery with Flask using Redis as the broker. Which steps correctly describe the setup process?

hard

A. Install Celery only, define tasks without decorator, call tasks directly, no broker needed

B. Install Flask-Login, configure Celery with SQLite, define tasks with @app.route, call tasks with run()

C. Install Redis, configure Flask routes for tasks, use delay() without decorator, run Redis server

D. Install Redis, configure Celery with Redis URL, define tasks with @celery_app.task, call tasks with delay()

Solution

1. Step 1: Setup Redis broker

   Redis must be installed and running as the message broker for Celery.

2. Step 2: Configure Celery and define tasks

   Celery is configured with Redis URL, tasks use @celery_app.task, and are called with delay().

3. Final Answer:

   Install Redis, configure Celery with Redis URL, define tasks with @celery_app.task, call tasks with delay() -> Option D

4. Quick Check:

   Redis + @celery_app.task + delay() = correct setup [OK]

Hint: Use Redis broker, @celery_app.task, and delay() calls [OK]

Common Mistakes:

• Using wrong broker like SQLite
• Defining tasks without decorator
• Calling tasks with run() or no broker