Calling tasks asynchronously in Django - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to call the Celery task asynchronously.

Django

from tasks import send_email

send_email.[1]()

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

Acall

Brun

Cexecute

Ddelay

Attempts:

3 left

💡 Hint

Common Mistakes

Using run() instead of delay() causes the task to run synchronously.

Using call() or execute() are not valid Celery task methods.

In Django with Celery, calling delay() on a task sends it to the queue to run asynchronously.

2fill in blank

medium

Complete the code to import the Celery app instance correctly.

Django

from [1] import app as celery_app

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

Amyproject.celery

Bdjango_celery

Ccelery_app

Dtasks

Attempts:

3 left

💡 Hint

Common Mistakes

Importing from 'tasks' instead of the celery app module.

Using a non-existent module like 'django_celery'.

In Django projects, the Celery app is usually defined in myproject/celery.py. Importing it as myproject.celery is the correct way.

3fill in blank

hard

Fix the error in the code to schedule a task with arguments asynchronously.

Django

send_email.[1](user_id=42, subject='Hello')

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

Asend

Bapply_async

Crun

Dexecute

Attempts:

3 left

💡 Hint

Common Mistakes

Using run() runs the task immediately and synchronously.

Using send() or execute() are invalid Celery task methods.

The apply_async() method schedules a task with arguments asynchronously in Celery.

4fill in blank

hard

Fill both blanks to create a periodic task using Celery beat.

Django

from celery.schedules import [1]

app.conf.beat_schedule = {
    'send-report-every-day': {
        'task': 'tasks.send_report',
        'schedule': [2](hours=24),
    },
}

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

Acrontab

Btimedelta

Cinterval

Dperiodic

Attempts:

3 left

💡 Hint

Common Mistakes

Using crontab without proper syntax.

Using periodic which is not a valid import.

To schedule periodic tasks, Celery beat uses interval imported from celery.schedules for repeating intervals, e.g., interval(hours=24).

5fill in blank

hard

Fill all three blanks to retry a failed task after 10 seconds.

Django

@app.task(bind=True, max_retries=3)
def send_notification(self, user_id):
    try:
        # send notification logic
        pass
    except Exception as exc:
        raise self.[1](exc, countdown=[2]) from exc

# Call the task
send_notification.[3](user_id=5)

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

Aretry

B10

Cdelay

Dapply_async

Attempts:

3 left

💡 Hint

Common Mistakes

Using apply_async instead of delay to call the task.

Not using retry method inside the except block.

The retry method retries the task after a delay specified by countdown. The task is called asynchronously with delay().

Practice

1. What is the main purpose of calling tasks asynchronously in a Django app using Celery?

easy

A. To avoid using any external libraries

B. To make the app run slower by adding extra steps

C. To run time-consuming tasks in the background without blocking the main app

D. To run tasks only when the server restarts

Solution

1. Step 1: Understand asynchronous task calling

   Calling tasks asynchronously means running them in the background so the main app can continue working without waiting.

2. Step 2: Identify the benefit in Django apps

   This helps keep the app fast and responsive by not blocking user requests with long tasks.

3. Final Answer:

   To run time-consuming tasks in the background without blocking the main app -> Option C

4. Quick Check:

   Async tasks = background work = To run time-consuming tasks in the background without blocking the main app [OK]

Hint: Async tasks run in background, keeping app responsive [OK]

Common Mistakes:

• Thinking async tasks slow down the app
• Believing async tasks run only on server restart
• Confusing async with avoiding external libraries

2. Which of the following is the correct way to call a Celery task named send_email asynchronously?

easy

A. send_email.delay()

B. send_email()

C. send_email.async()

D. send_email.run()

Solution

1. Step 1: Recall Celery task calling syntax

   Celery tasks are called asynchronously using the .delay() method.

2. Step 2: Match the correct method to the task name

   Calling send_email.delay() queues the task to run in the background.

3. Final Answer:

   send_email.delay() -> Option A

4. Quick Check:

   Use .delay() to call async tasks [OK]

Hint: Use .delay() to call Celery tasks asynchronously [OK]

Common Mistakes:

• Calling the task like a normal function without .delay()
• Using .async() which is not a Celery method
• Using .run() which executes task synchronously

3. Given the following Celery task and call:

@shared_task
def add(x, y):
    return x + y

result = add.delay(4, 5)

What will result.get() return after the task completes?

medium

A. 9

B. None

C. An error because .get() is not valid

D. A task ID string

Solution

1. Step 1: Understand what add.delay(4, 5) does

   This queues the add task with arguments 4 and 5 to run asynchronously.

2. Step 2: Understand result.get() usage

   Calling result.get() waits for the task to finish and returns the result, which is 4 + 5 = 9.

3. Final Answer:

   9 -> Option A

4. Quick Check:

   Task result = 4 + 5 = 9 [OK]

Hint: Use .get() to fetch async task result after completion [OK]

Common Mistakes:

• Thinking .get() returns task ID instead of result
• Believing .get() is invalid for Celery AsyncResult
• Expecting None because task runs asynchronously

4. What is wrong with this Celery task call?

@shared_task
def multiply(x, y):
    return x * y

result = multiply(3, 7)

medium

A. The arguments 3 and 7 are invalid types

B. The task is missing the @app.task decorator

C. The function multiply should not return a value

D. The task is called synchronously, not asynchronously

Solution

1. Step 1: Check how the task is called

   The task is called directly as multiply(3, 7), which runs it immediately and blocks.

2. Step 2: Identify correct async call method

   To call asynchronously, it should be multiply.delay(3, 7).

3. Final Answer:

   The task is called synchronously, not asynchronously -> Option D

4. Quick Check:

   Direct call runs sync, use .delay() for async [OK]

Hint: Use .delay() to call tasks async, not direct function call [OK]

Common Mistakes:

• Calling task function directly instead of using .delay()
• Confusing @shared_task with @app.task (both valid but different)
• Thinking return values are disallowed in tasks

5. You want to send a welcome email asynchronously after a user registers. Which approach correctly combines Django signals and Celery tasks to achieve this?

hard

A. Call send_welcome_email(user.id) directly inside the signal handler

B. Connect a signal handler that calls send_welcome_email.delay(user.id) after user creation

C. Use a signal to call send_welcome_email.run(user.id) synchronously

D. Call send_welcome_email.delay() before the user is saved

Solution

1. Step 1: Understand the goal

   We want to send the email asynchronously after the user is created to avoid slowing registration.

2. Step 2: Use Django signals with Celery correctly

   Connect a signal (like post_save) to call send_welcome_email.delay(user.id) after user creation, queuing the task.

3. Final Answer:

   Connect a signal handler that calls send_welcome_email.delay(user.id) after user creation -> Option B

4. Quick Check:

   Signal + .delay() after save = async email send [OK]

Hint: Use signals to trigger .delay() after user save [OK]

Common Mistakes:

• Calling task directly inside signal, blocking request
• Calling .run() which is synchronous
• Calling .delay() before user exists in DB