Calling tasks asynchronously in Flask - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What is the output when calling a Flask route that triggers a Celery task asynchronously?

Consider a Flask app with a Celery task defined as follows:

from flask import Flask, jsonify
from celery import Celery

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

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

@app.route('/add')
def call_add():
    task = add.delay(4, 5)
    return jsonify({'task_id': task.id})

What will the client receive when accessing the /add route?

Flask

from flask import Flask, jsonify
from celery import Celery

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

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

@app.route('/add')
def call_add():
    task = add.delay(4, 5)
    return jsonify({'task_id': task.id})

A A JSON response with the sum result, e.g., {'result': 9}

B A JSON response containing the task ID, e.g., {'task_id': 'some-uuid'}

C An immediate integer 9 as plain text

D A server error because the task is not awaited

💡 Hint

Remember that delay() queues the task and returns immediately with a task ID.

The delay() method triggers the Celery task asynchronously and returns a task object immediately. The Flask route returns the task ID in JSON format. The actual task runs in the background and its result is not returned directly in this response.

❓ state_output

intermediate

What is the state of a Celery task immediately after calling delay()?

Given a Celery task process_data and calling task = process_data.delay(), what is the initial state of task.state?

Flask

from celery import Celery

celery = Celery('app', broker='redis://localhost:6379/0')

@celery.task
def process_data():
    return 'done'

task = process_data.delay()

A 'PENDING'

B 'SUCCESS'

C 'FAILURE'

D 'STARTED'

💡 Hint

Think about what happens right after a task is queued but before it runs.

When a Celery task is first queued with delay(), its state is 'PENDING' because it has not started execution yet.

📝 Syntax

advanced

Which Flask route code correctly calls a Celery task asynchronously and returns the task result synchronously?

Choose the correct Flask route code that calls a Celery task asynchronously but waits for the result before returning it.

A

def route():
    task = add.delay(2, 3)
    return str(task.get())

B

def route():
    result = add(2, 3)
    return str(result)

C

def route():
    task = add.delay(2, 3)
    return jsonify({'result': task.state})

D

def route():
    task = add.apply_async((2, 3))
    return jsonify({'result': task.id})

💡 Hint

Look for the method that waits for the task result.

Calling task.get() waits for the Celery task to finish and returns the result. Using delay() queues the task asynchronously, but get() blocks until the result is ready.

🔧 Debug

advanced

Why does this Flask route never return a response when calling a Celery task asynchronously?

Given this Flask route:

@app.route('/longtask')
def longtask():
    result = long_running_task.delay()
    return result.get()

The route hangs and never returns. What is the most likely cause?

Flask

@app.route('/longtask')
def longtask():
    result = long_running_task.delay()
    return result.get()

A The delay() method raises a syntax error.

B The task is synchronous and blocks the Flask server.

C The route returns before the task is queued.

D The Celery worker is not running, so the task never completes.

💡 Hint

Check if the background worker is active.

If the Celery worker process is not running, the task stays queued and result.get() waits forever, causing the Flask route to hang.

🧠 Conceptual

expert

Which statement best describes the advantage of calling tasks asynchronously in Flask with Celery?

Why do developers use Celery to call tasks asynchronously in Flask applications?

A To make all Flask routes execute faster by running tasks synchronously.

B To avoid using message brokers and simplify deployment.

C To offload long-running or blocking tasks from the web server, improving responsiveness and scalability.

D To ensure tasks run only when the Flask app is restarted.

💡 Hint

Think about what happens when a web server handles slow tasks directly.

Calling tasks asynchronously with Celery allows the Flask app to delegate slow or blocking work to background workers. This keeps the web server responsive and able to handle more requests.