Handling ORM Calls in ASGI Mode with Django

The issue you're encountering is related to Django's asynchronous context awareness introduced in Django 3.0 with ASGI support. When running under ASGI, Django blocks direct ORM operations from asynchronous contexts, which is what's happening in your ready() method.

The Problem

As mentioned in the Django 3.0 release notes, Django is now aware of asynchronous event loops and will block you from calling code marked as "async unsafe" (such as ORM operations) from an asynchronous context. This is what's causing your SynchronousOnlyOperation error during startup.

Solutions

Here are a few approaches to solve this issue:

1. Use a Synchronous Wrapper

The most straightforward solution is to move your database operations to a synchronous context using Django's sync_to_async utility with thread_sensitive=True:

PYTHONCopied
from django.apps import AppConfig
from django.db import OperationalError, ProgrammingError
from contextlib import suppress
from asgiref.sync import sync_to_async

class AccountsConfig(AppConfig):
    name = "accounts"

    def ready(self):
        from common.models import FeatureFlag

        # Define a synchronous function
        def create_feature_flag():
            with suppress(ProgrammingError, OperationalError):
                FeatureFlag.objects.get_or_create(
                    name="SMS_SPECIFIC_TIME",
                    defaults={
                        "enabled": True,
                        "description": "Send SMS at the time (24H) that is declared in data",
                        "data": {"time": "20:00"},
                    },
                )

        # Run it in a synchronous context
        import asyncio
        try:
            loop = asyncio.get_event_loop()
            if loop.is_running():
                # We're in an async context, use sync_to_async
                sync_to_async(create_feature_flag, thread_sensitive=True)()
            else:
                # We're already in a sync context
                create_feature_flag()
        except RuntimeError:
            # No event loop running, we're in a sync context
            create_feature_flag()

        import accounts.signals  # noqa
        import accounts.messages  # noqa

2. Use a Management Command

A cleaner approach might be to move this initialization logic to a management command that you run separately during deployment:

PYTHONCopied
# management/commands/ensure_feature_flags.py
from django.core.management.base import BaseCommand
from common.models import FeatureFlag

class Command(BaseCommand):
    help = 'Ensures required feature flags exist'

    def handle(self, *args, **options):
        FeatureFlag.objects.get_or_create(
            name="SMS_SPECIFIC_TIME",
            defaults={
                "enabled": True,
                "description": "Send SMS at the time (24H) that is declared in data",
                "data": {"time": "20:00"},
            },
        )
        self.stdout.write(self.style.SUCCESS('Feature flags created/updated successfully'))

Then run this command during your deployment process before starting the ASGI server.

3. Use Django's AppConfig.ready() Only for Non-ORM Operations

Modify your ready() method to avoid ORM operations and handle them elsewhere:

PYTHONCopied
class AccountsConfig(AppConfig):
    name = "accounts"

    def ready(self):
        # Only import signals and messages here
        import accounts.signals  # noqa
        import accounts.messages  # noqa

Then handle the feature flag creation in a separate process or during a specific synchronous phase of your application lifecycle.

Running with Uvicorn

When running your application with Uvicorn, use:

python -m uvicorn myproject.asgi:application

Make sure you're running this command from the same directory as your manage.py file to ensure your project is on the Python path.

Remember that Django's ASGI support is designed to work alongside the existing WSGI support, so you can always fall back to WSGI if needed while you work through these asynchronous context issues.