Django は非同期 ("async") Python の試験的サポートをしていますが、ビューやミドルウェアの非同期サポートはなされていません。今後のリリースでサポートされる予定です。
\nasync エコシステムの他の部分のサポートは限定的です。つまり、 Django はネイティブで ASGI を話し、部分的に非同期安全性をサポートしています。
\nDjango の特定のキーパーツは、コルーチンが感知できないグローバルステートを持つため、非同期の環境では安全に操作できません。これらの Django のパーツは、"async-unsafe" として分類されており、非同期な環境での実行から保護されています。ORM は主な例ですが、この他にもこのように保護されているパーツがあります。
\nIf you try to run any of these parts from a thread where there is a running\nevent loop, you will get a\nSynchronousOnlyOperation error. Note that you\ndon't have to be inside an async function directly to have this error occur. If\nyou have called a synchronous function directly from an asynchronous function\nwithout going through something like sync_to_async() or a threadpool,\nthen it can also occur, as your code is still running in an asynchronous\ncontext.
If you encounter this error, you should fix your code to not call the offending\ncode from an async context; instead, write your code that talks to async-unsafe\nin its own, synchronous function, and call that using\nasgiref.sync.sync_to_async(), or any other preferred way of running\nsynchronous code in its own thread.
もしこのコードを 絶対に 切実に非同期コンテキストから実行する必要がある場合 - 例えば、外部の環境に強制されていて、同時に実行される可能性が確実にない場合 (例: Jupyter notebook の中など)、環境変数 DJANGO_ALLOW_ASYNC_UNSAFE で警告を無効化できます。
もし、これをPython内部から行いたい場合は、 os.environ:: を使用してください。
os.environ["DJANGO_ALLOW_ASYNC_UNSAFE"] = "true"\nIt is necessary to adapt the calling style when calling synchronous code from\nan asynchronous context, or vice-versa. For this there are two adapter\nfunctions, made available from the asgiref.sync package:\nasync_to_sync() and sync_to_async(). They are used to transition\nbetween sync and async calling styles while preserving compatibility.
These adapter functions are widely used in Django. The asgiref package\nitself is part of the Django project, and it is automatically installed as a\ndependency when you install Django with pip.
async_to_sync()Link to this heading#Wraps an asynchronous function and returns a synchronous function in its place.\nCan be used as either a direct wrapper or a decorator:
\nfrom asgiref.sync import async_to_sync\n\nsync_function = async_to_sync(async_function)\n\n@async_to_sync\nasync def async_function(...):\n ...\nThe asynchronous function is run in the event loop for the current thread, if\none is present. If there is no current event loop, a new event loop is spun up\nspecifically for the async function and shut down again once it completes. In\neither situation, the async function will execute on a different thread to the\ncalling code.
\nThreadlocals and contextvars values are preserved across the boundary in both\ndirections.
\nasync_to_sync() is essentially a more powerful version of the\nasyncio.run() function available in Python's standard library. As well\nas ensuring threadlocals work, it also enables the thread_sensitive mode of\nsync_to_async() when that wrapper is used below it.
sync_to_async()Link to this heading#Wraps a synchronous function and returns an asynchronous (awaitable) function\nin its place. Can be used as either a direct wrapper or a decorator:
\nfrom asgiref.sync import sync_to_async\n\nasync_function = sync_to_async(sync_function)\nasync_function = sync_to_async(sensitive_sync_function, thread_sensitive=True)\n\n@sync_to_async\ndef sync_function(...):\n ...\nThreadlocals and contextvars values are preserved across the boundary in both\ndirections.
\nSynchronous functions tend to be written assuming they all run in the main\nthread, so sync_to_async() has two threading modes:
thread_sensitive=False (the default): the synchronous function will run\nin a brand new thread which is then closed once it completes.
thread_sensitive=True: the synchronous function will run in the same\nthread as all other thread_sensitive functions, and this will be the main\nthread, if the main thread is synchronous and you are using the\nasync_to_sync() wrapper.
Thread-sensitive mode is quite special, and does a lot of work to run all\nfunctions in the same thread. Note, though, that it relies on usage of\nasync_to_sync() above it in the stack to correctly run things on the\nmain thread. If you use asyncio.run() (or other options instead), it will\nfall back to just running thread-sensitive functions in a single, shared thread\n(but not the main thread).
The reason this is needed in Django is that many libraries, specifically\ndatabase adapters, require that they are accessed in the same thread that they\nwere created in, and a lot of existing Django code assumes it all runs in the\nsame thread (e.g. middleware adding things to a request for later use by a\nview).
\nRather than introduce potential compatibility issues with this code, we instead\nopted to add this mode so that all existing Django synchronous code runs in the\nsame thread and thus is fully compatible with asynchronous mode. Note, that\nsynchronous code will always be in a different thread to any async code that\nis calling it, so you should avoid passing raw database handles or other\nthread-sensitive references around in any new code you write.
\n